* [PATCH 02/17] Add minimal p2p.c and p2p.h
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-17 15:19 ` Denis Kenzior
2020-04-03 16:14 ` [PATCH 03/17] manager: Create/destroy P2P devices Andrew Zaborowski
` (15 subsequent siblings)
16 siblings, 1 reply; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 11459 bytes --]
Add the functions to be called by manager.c and a minimal DBus API.
---
Makefile.am | 1 +
src/p2p.c | 354 ++++++++++++++++++++++++++++++++++++++++++++++++++++
src/p2p.h | 31 +++++
3 files changed, 386 insertions(+)
create mode 100644 src/p2p.c
create mode 100644 src/p2p.h
diff --git a/Makefile.am b/Makefile.am
index 768685f8..0a82878e 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -224,6 +224,7 @@ src_iwd_SOURCES = src/main.c linux/nl80211.h src/iwd.h src/missing.h \
src/netconfig.h src/netconfig.c\
src/resolve.h src/resolve.c\
src/hotspot.c \
+ src/p2p.h src/p2p.c \
src/p2putil.h src/p2putil.c \
src/module.h src/module.c \
src/rrm.c \
diff --git a/src/p2p.c b/src/p2p.c
new file mode 100644
index 00000000..957482eb
--- /dev/null
+++ b/src/p2p.c
@@ -0,0 +1,354 @@
+/*
+ *
+ * Wireless daemon for Linux
+ *
+ * Copyright (C) 2020 Intel Corporation. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <linux/rtnetlink.h>
+#include <linux/if_ether.h>
+#include <unistd.h>
+#include <limits.h>
+#include <stdio.h>
+#include <time.h>
+#include <errno.h>
+
+#include <ell/ell.h>
+
+#include "linux/nl80211.h"
+
+#include "src/iwd.h"
+#include "src/wiphy.h"
+#include "src/scan.h"
+#include "src/p2putil.h"
+#include "src/ie.h"
+#include "src/util.h"
+#include "src/dbus.h"
+#include "src/netdev.h"
+#include "src/mpdu.h"
+#include "src/common.h"
+#include "src/wsc.h"
+#include "src/handshake.h"
+#include "src/crypto.h"
+#include "src/module.h"
+#include "src/frame-xchg.h"
+#include "src/nl80211util.h"
+#include "src/p2p.h"
+
+struct p2p_device {
+ uint64_t wdev_id;
+ uint8_t addr[6];
+ struct wiphy *wiphy;
+ unsigned int connections_left;
+
+ struct l_queue *peer_list;
+};
+
+struct p2p_peer {
+ struct scan_bss *bss;
+ struct p2p_device *dev;
+ char *name;
+};
+
+static struct l_queue *p2p_device_list;
+
+static bool p2p_device_match(const void *a, const void *b)
+{
+ const struct p2p_device *dev = a;
+ const uint64_t *wdev_id = b;
+
+ return dev->wdev_id == *wdev_id;
+}
+
+struct p2p_device *p2p_device_find(uint64_t wdev_id)
+{
+ return l_queue_find(p2p_device_list, p2p_device_match, &wdev_id);
+}
+
+static const char *p2p_device_get_path(const struct p2p_device *dev)
+{
+ return wiphy_get_path(dev->wiphy);
+}
+
+static const char *p2p_peer_get_path(const struct p2p_peer *peer)
+{
+ static char path[256];
+
+ snprintf(path, sizeof(path),
+ "%s/p2p_peers/%02x_%02x_%02x_%02x_%02x_%02x",
+ p2p_device_get_path(peer->dev),
+ peer->bss->addr[0], peer->bss->addr[1],
+ peer->bss->addr[2], peer->bss->addr[3],
+ peer->bss->addr[4], peer->bss->addr[5]);
+ return path;
+}
+
+static void p2p_peer_free(void *user_data)
+{
+ struct p2p_peer *peer = user_data;
+
+ scan_bss_free(peer->bss);
+ l_free(peer->name);
+ l_free(peer);
+}
+
+static void p2p_peer_put(void *user_data)
+{
+ struct p2p_peer *peer = user_data;
+
+ l_dbus_unregister_object(dbus_get_bus(), p2p_peer_get_path(peer));
+ p2p_peer_free(peer);
+}
+
+struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
+ bool create)
+{
+ struct l_genl_attr attr;
+ uint16_t type, len;
+ const void *data;
+ const uint8_t *ifaddr = NULL;
+ const uint64_t *wdev_id = NULL;
+ struct wiphy *wiphy = NULL;
+ struct p2p_device *dev;
+
+ if (!l_genl_attr_init(&attr, msg))
+ return NULL;
+
+ while (l_genl_attr_next(&attr, &type, &len, &data)) {
+ switch (type) {
+ case NL80211_ATTR_WDEV:
+ if (len != sizeof(uint64_t)) {
+ l_warn("Invalid wdev index attribute");
+ return NULL;
+ }
+
+ wdev_id = data;
+ break;
+
+ case NL80211_ATTR_WIPHY:
+ if (len != sizeof(uint32_t)) {
+ l_warn("Invalid wiphy attribute");
+ return NULL;
+ }
+
+ wiphy = wiphy_find(*((uint32_t *) data));
+ break;
+
+ case NL80211_ATTR_IFTYPE:
+ if (len != sizeof(uint32_t)) {
+ l_warn("Invalid interface type attribute");
+ return NULL;
+ }
+
+ if (*((uint32_t *) data) != NL80211_IFTYPE_P2P_DEVICE)
+ return NULL;
+
+ break;
+
+ case NL80211_ATTR_MAC:
+ if (len != ETH_ALEN) {
+ l_warn("Invalid interface address attribute");
+ return NULL;
+ }
+
+ ifaddr = data;
+ break;
+ }
+ }
+
+ if (!wiphy || !wdev_id || !ifaddr) {
+ l_warn("Unable to parse interface information");
+ return NULL;
+ }
+
+ if (create) {
+ if (p2p_device_find(*wdev_id)) {
+ l_debug("Duplicate p2p device %" PRIx64, *wdev_id);
+ return NULL;
+ }
+ } else {
+ dev = p2p_device_find(*wdev_id);
+ if (!dev)
+ return NULL;
+
+ memcpy(dev->addr, ifaddr, ETH_ALEN);
+ return NULL;
+ }
+
+ dev = l_new(struct p2p_device, 1);
+ dev->wdev_id = *wdev_id;
+ memcpy(dev->addr, ifaddr, ETH_ALEN);
+ dev->wiphy = wiphy;
+ dev->connections_left = 1;
+
+ l_queue_push_tail(p2p_device_list, dev);
+
+ l_debug("Created P2P device %" PRIx64, dev->wdev_id);
+
+ if (!l_dbus_object_add_interface(dbus_get_bus(),
+ p2p_device_get_path(dev),
+ IWD_P2P_INTERFACE, dev))
+ l_info("Unable to add the %s interface to %s",
+ IWD_P2P_INTERFACE, p2p_device_get_path(dev));
+
+ return dev;
+}
+
+static void p2p_device_free(void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ l_dbus_unregister_object(dbus_get_bus(), p2p_device_get_path(dev));
+ l_queue_destroy(dev->peer_list, p2p_peer_put);
+ l_free(dev);
+}
+
+bool p2p_device_destroy(struct p2p_device *dev)
+{
+ if (!l_queue_remove(p2p_device_list, dev))
+ return false;
+
+ p2p_device_free(dev);
+ return true;
+}
+
+static bool p2p_device_get_avail_conns(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_builder *builder,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ uint16_t avail_conns = dev->connections_left;
+
+ l_dbus_message_builder_append_basic(builder, 'q', &avail_conns);
+ return true;
+}
+
+static struct l_dbus_message *p2p_device_get_peers(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ struct l_dbus_message *reply;
+ struct l_dbus_message_builder *builder;
+ const struct l_queue_entry *entry;
+
+ if (!l_dbus_message_get_arguments(message, ""))
+ return dbus_error_invalid_args(message);
+
+ reply = l_dbus_message_new_method_return(message);
+ builder = l_dbus_message_builder_new(reply);
+
+ l_dbus_message_builder_enter_array(builder, "(on)");
+
+ for (entry = l_queue_get_entries(dev->peer_list); entry;
+ entry = entry->next) {
+ const struct p2p_peer *peer = entry->data;
+ int16_t signal_strength = peer->bss->signal_strength;
+
+ l_dbus_message_builder_enter_struct(builder, "on");
+ l_dbus_message_builder_append_basic(builder, 'o',
+ p2p_peer_get_path(peer));
+ l_dbus_message_builder_append_basic(builder, 'n',
+ &signal_strength);
+ l_dbus_message_builder_leave_struct(builder);
+ }
+
+ l_dbus_message_builder_leave_array(builder);
+
+ l_dbus_message_builder_finalize(builder);
+ l_dbus_message_builder_destroy(builder);
+
+ return reply;
+}
+
+static void p2p_interface_setup(struct l_dbus_interface *interface)
+{
+ l_dbus_interface_property(interface, "AvailableConnections", 0, "q",
+ p2p_device_get_avail_conns, NULL);
+ l_dbus_interface_method(interface, "GetPeers", 0,
+ p2p_device_get_peers, "a(on)", "", "peers");
+}
+
+static bool p2p_peer_get_name(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_builder *builder,
+ void *user_data)
+{
+ struct p2p_peer *peer = user_data;
+
+ l_dbus_message_builder_append_basic(builder, 's', peer->name);
+ return true;
+}
+
+static bool p2p_peer_get_connected(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_builder *builder,
+ void *user_data)
+{
+ bool connected = false;
+
+ l_dbus_message_builder_append_basic(builder, 'b', &connected);
+ return true;
+}
+
+static void p2p_peer_interface_setup(struct l_dbus_interface *interface)
+{
+ l_dbus_interface_property(interface, "Name", 0, "s",
+ p2p_peer_get_name, NULL);
+ l_dbus_interface_property(interface, "Connected", 0, "b",
+ p2p_peer_get_connected, NULL);
+}
+
+static int p2p_init(void)
+{
+ if (!l_dbus_register_interface(dbus_get_bus(),
+ IWD_P2P_INTERFACE,
+ p2p_interface_setup,
+ NULL, false))
+ l_error("Unable to register the %s interface",
+ IWD_P2P_INTERFACE);
+
+ if (!l_dbus_register_interface(dbus_get_bus(),
+ IWD_P2P_PEER_INTERFACE,
+ p2p_peer_interface_setup,
+ NULL, false))
+ l_error("Unable to register the %s interface",
+ IWD_P2P_PEER_INTERFACE);
+
+ p2p_device_list = l_queue_new();
+
+ return 0;
+}
+
+static void p2p_exit(void)
+{
+ l_dbus_unregister_interface(dbus_get_bus(), IWD_P2P_INTERFACE);
+ l_dbus_unregister_interface(dbus_get_bus(), IWD_P2P_PEER_INTERFACE);
+ l_queue_destroy(p2p_device_list, p2p_device_free);
+ p2p_device_list = NULL;
+}
+
+IWD_MODULE(p2p, p2p_init, p2p_exit)
+IWD_MODULE_DEPENDS(p2p, wiphy)
+IWD_MODULE_DEPENDS(p2p, scan)
diff --git a/src/p2p.h b/src/p2p.h
new file mode 100644
index 00000000..93a8c625
--- /dev/null
+++ b/src/p2p.h
@@ -0,0 +1,31 @@
+/*
+ *
+ * Wireless daemon for Linux
+ *
+ * Copyright (C) 2020 Intel Corporation. All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <stdbool.h>
+
+struct l_genl_msg;
+struct p2p_device;
+
+struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
+ bool create);
+bool p2p_device_destroy(struct p2p_device *dev);
+struct p2p_device *p2p_device_find(uint64_t wdev_idx);
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* Re: [PATCH 02/17] Add minimal p2p.c and p2p.h
2020-04-03 16:14 ` [PATCH 02/17] Add minimal p2p.c and p2p.h Andrew Zaborowski
@ 2020-04-17 15:19 ` Denis Kenzior
2020-04-17 21:01 ` Andrew Zaborowski
0 siblings, 1 reply; 28+ messages in thread
From: Denis Kenzior @ 2020-04-17 15:19 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 3777 bytes --]
Hi Andrew,
On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> Add the functions to be called by manager.c and a minimal DBus API.
> ---
> Makefile.am | 1 +
> src/p2p.c | 354 ++++++++++++++++++++++++++++++++++++++++++++++++++++
> src/p2p.h | 31 +++++
> 3 files changed, 386 insertions(+)
> create mode 100644 src/p2p.c
> create mode 100644 src/p2p.h
>
<snip>
> +#include <stdlib.h>
> +#include <linux/rtnetlink.h>
> +#include <linux/if_ether.h>
> +#include <unistd.h>
> +#include <limits.h>
> +#include <stdio.h>
> +#include <time.h>
> +#include <errno.h>
So just for the future, it would be nice to introduce headers only as
you need them so it is a bit easier to track whether something is truly
required.
> +
> +#include <ell/ell.h>
> +
> +#include "linux/nl80211.h"
> +
> +#include "src/iwd.h"
> +#include "src/wiphy.h"
> +#include "src/scan.h"
> +#include "src/p2putil.h"
> +#include "src/ie.h"
> +#include "src/util.h"
> +#include "src/dbus.h"
> +#include "src/netdev.h"
> +#include "src/mpdu.h"
> +#include "src/common.h"
> +#include "src/wsc.h"
> +#include "src/handshake.h"
> +#include "src/crypto.h"
> +#include "src/module.h"
> +#include "src/frame-xchg.h"
> +#include "src/nl80211util.h"
> +#include "src/p2p.h"
Same for the internal ones...
<snip>
> +struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> + bool create)
> +{
> + struct l_genl_attr attr;
> + uint16_t type, len;
> + const void *data;
> + const uint8_t *ifaddr = NULL;
> + const uint64_t *wdev_id = NULL;
> + struct wiphy *wiphy = NULL;
> + struct p2p_device *dev;
> +
> + if (!l_genl_attr_init(&attr, msg))
> + return NULL;
> +
> + while (l_genl_attr_next(&attr, &type, &len, &data)) {
> + switch (type) {
> + case NL80211_ATTR_WDEV:
> + if (len != sizeof(uint64_t)) {
> + l_warn("Invalid wdev index attribute");
> + return NULL;
> + }
> +
> + wdev_id = data;
> + break;
> +
> + case NL80211_ATTR_WIPHY:
> + if (len != sizeof(uint32_t)) {
> + l_warn("Invalid wiphy attribute");
> + return NULL;
> + }
> +
> + wiphy = wiphy_find(*((uint32_t *) data));
> + break;
> +
> + case NL80211_ATTR_IFTYPE:
> + if (len != sizeof(uint32_t)) {
> + l_warn("Invalid interface type attribute");
> + return NULL;
> + }
> +
> + if (*((uint32_t *) data) != NL80211_IFTYPE_P2P_DEVICE)
> + return NULL;
> +
> + break;
> +
> + case NL80211_ATTR_MAC:
> + if (len != ETH_ALEN) {
> + l_warn("Invalid interface address attribute");
> + return NULL;
> + }
> +
> + ifaddr = data;
> + break;
> + }
> + }
I suspect you can change this to use nl80211util now...
> +
> + if (!wiphy || !wdev_id || !ifaddr) {
> + l_warn("Unable to parse interface information");
> + return NULL;
> + }
> +
> + if (create) {
> + if (p2p_device_find(*wdev_id)) {
> + l_debug("Duplicate p2p device %" PRIx64, *wdev_id);
> + return NULL;
> + }
> + } else {
> + dev = p2p_device_find(*wdev_id);
> + if (!dev)
> + return NULL;
> +
> + memcpy(dev->addr, ifaddr, ETH_ALEN);
> + return NULL;
> + }
> +
> + dev = l_new(struct p2p_device, 1);
> + dev->wdev_id = *wdev_id;
> + memcpy(dev->addr, ifaddr, ETH_ALEN);
> + dev->wiphy = wiphy;
> + dev->connections_left = 1;
> +
> + l_queue_push_tail(p2p_device_list, dev);
> +
> + l_debug("Created P2P device %" PRIx64, dev->wdev_id);
> +
> + if (!l_dbus_object_add_interface(dbus_get_bus(),
> + p2p_device_get_path(dev),
> + IWD_P2P_INTERFACE, dev))
> + l_info("Unable to add the %s interface to %s",
> + IWD_P2P_INTERFACE, p2p_device_get_path(dev));
> +
> + return dev;
> +}
> +
Applied, thanks.
Regards,
-Denis
^ permalink raw reply [flat|nested] 28+ messages in thread* Re: [PATCH 02/17] Add minimal p2p.c and p2p.h
2020-04-17 15:19 ` Denis Kenzior
@ 2020-04-17 21:01 ` Andrew Zaborowski
0 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-17 21:01 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 3751 bytes --]
On Fri, 17 Apr 2020 at 17:19, Denis Kenzior <denkenz@gmail.com> wrote:
> On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> > Add the functions to be called by manager.c and a minimal DBus API.
> > ---
> > Makefile.am | 1 +
> > src/p2p.c | 354 ++++++++++++++++++++++++++++++++++++++++++++++++++++
> > src/p2p.h | 31 +++++
> > 3 files changed, 386 insertions(+)
> > create mode 100644 src/p2p.c
> > create mode 100644 src/p2p.h
> >
>
> <snip>
>
> > +#include <stdlib.h>
> > +#include <linux/rtnetlink.h>
> > +#include <linux/if_ether.h>
> > +#include <unistd.h>
> > +#include <limits.h>
> > +#include <stdio.h>
> > +#include <time.h>
> > +#include <errno.h>
>
> So just for the future, it would be nice to introduce headers only as
> you need them so it is a bit easier to track whether something is truly
> required.
Ok, noted.
>
> > +
> > +#include <ell/ell.h>
> > +
> > +#include "linux/nl80211.h"
> > +
> > +#include "src/iwd.h"
> > +#include "src/wiphy.h"
> > +#include "src/scan.h"
> > +#include "src/p2putil.h"
> > +#include "src/ie.h"
> > +#include "src/util.h"
> > +#include "src/dbus.h"
> > +#include "src/netdev.h"
> > +#include "src/mpdu.h"
> > +#include "src/common.h"
> > +#include "src/wsc.h"
> > +#include "src/handshake.h"
> > +#include "src/crypto.h"
> > +#include "src/module.h"
> > +#include "src/frame-xchg.h"
> > +#include "src/nl80211util.h"
> > +#include "src/p2p.h"
>
> Same for the internal ones...
>
> <snip>
>
> > +struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> > + bool create)
> > +{
> > + struct l_genl_attr attr;
> > + uint16_t type, len;
> > + const void *data;
> > + const uint8_t *ifaddr = NULL;
> > + const uint64_t *wdev_id = NULL;
> > + struct wiphy *wiphy = NULL;
> > + struct p2p_device *dev;
> > +
> > + if (!l_genl_attr_init(&attr, msg))
> > + return NULL;
> > +
> > + while (l_genl_attr_next(&attr, &type, &len, &data)) {
> > + switch (type) {
> > + case NL80211_ATTR_WDEV:
> > + if (len != sizeof(uint64_t)) {
> > + l_warn("Invalid wdev index attribute");
> > + return NULL;
> > + }
> > +
> > + wdev_id = data;
> > + break;
> > +
> > + case NL80211_ATTR_WIPHY:
> > + if (len != sizeof(uint32_t)) {
> > + l_warn("Invalid wiphy attribute");
> > + return NULL;
> > + }
> > +
> > + wiphy = wiphy_find(*((uint32_t *) data));
> > + break;
> > +
> > + case NL80211_ATTR_IFTYPE:
> > + if (len != sizeof(uint32_t)) {
> > + l_warn("Invalid interface type attribute");
> > + return NULL;
> > + }
> > +
> > + if (*((uint32_t *) data) != NL80211_IFTYPE_P2P_DEVICE)
> > + return NULL;
> > +
> > + break;
> > +
> > + case NL80211_ATTR_MAC:
> > + if (len != ETH_ALEN) {
> > + l_warn("Invalid interface address attribute");
> > + return NULL;
> > + }
> > +
> > + ifaddr = data;
> > + break;
> > + }
> > + }
>
> I suspect you can change this to use nl80211util now...
I'll try to remember to do this afterwards.
Best regards
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH 03/17] manager: Create/destroy P2P devices
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 02/17] Add minimal p2p.c and p2p.h Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-17 15:30 ` Denis Kenzior
2020-04-03 16:14 ` [PATCH 04/17] p2p: Add peer WSC device type properties Andrew Zaborowski
` (14 subsequent siblings)
16 siblings, 1 reply; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 6252 bytes --]
Create a P2P device interface along with the station interface when
setting up a wiphy and handle the interface being removed.
---
src/manager.c | 122 +++++++++++++++++++++++++++++++++++++++++---------
1 file changed, 101 insertions(+), 21 deletions(-)
diff --git a/src/manager.c b/src/manager.c
index 533975d2..f351c780 100644
--- a/src/manager.c
+++ b/src/manager.c
@@ -42,6 +42,7 @@
#include "src/util.h"
#include "src/common.h"
#include "src/nl80211cmd.h"
+#include "src/p2p.h"
static struct l_genl_family *nl80211 = NULL;
static char **whitelist_filter;
@@ -125,7 +126,8 @@ static bool manager_use_default(struct wiphy_setup_state *state)
return true;
}
-static void manager_new_interface_cb(struct l_genl_msg *msg, void *user_data)
+static void manager_new_station_interface_cb(struct l_genl_msg *msg,
+ void *user_data)
{
struct wiphy_setup_state *state = user_data;
uint8_t addr_buf[6];
@@ -170,6 +172,25 @@ static void manager_new_interface_cb(struct l_genl_msg *msg, void *user_data)
netdev_create_from_genl(msg, addr);
}
+static void manager_new_p2p_interface_cb(struct l_genl_msg *msg,
+ void *user_data)
+{
+ struct wiphy_setup_state *state = user_data;
+
+ l_debug("");
+
+ if (state->aborted)
+ return;
+
+ if (l_genl_msg_get_error(msg) < 0) {
+ l_error("NEW_INTERFACE failed for p2p-device: %s",
+ strerror(-l_genl_msg_get_error(msg)));
+ return;
+ }
+
+ p2p_device_update_from_genl(msg, true);
+}
+
static void manager_new_interface_done(void *user_data)
{
struct wiphy_setup_state *state = user_data;
@@ -184,7 +205,7 @@ static void manager_create_interfaces(struct wiphy_setup_state *state)
{
struct l_genl_msg *msg;
char ifname[10];
- uint32_t iftype = NL80211_IFTYPE_STATION;
+ uint32_t iftype;
unsigned cmd_id;
if (state->aborted)
@@ -192,19 +213,26 @@ static void manager_create_interfaces(struct wiphy_setup_state *state)
if (state->use_default) {
manager_use_default(state);
- return;
+
+ /*
+ * Some drivers don't let us touch the default interface
+ * but still allow us to create/destroy P2P interfaces, so
+ * give it a chance.
+ */
+ goto try_create_p2p;
}
/*
* Current policy: we maintain one netdev per wiphy for station,
* AP and Ad-Hoc modes, one optional p2p-device and zero or more
- * p2p-GOs or p2p-clients. The P2P-related interfaces will be
+ * p2p-GOs or p2p-clients. The P2P-client/GO interfaces will be
* created on request.
*/
/* To be improved */
snprintf(ifname, sizeof(ifname), "wlan%i", (int) state->id);
l_debug("creating %s", ifname);
+ iftype = NL80211_IFTYPE_STATION;
msg = l_genl_msg_new(NL80211_CMD_NEW_INTERFACE);
l_genl_msg_append_attr(msg, NL80211_ATTR_WIPHY, 4, &state->id);
@@ -226,7 +254,48 @@ static void manager_create_interfaces(struct wiphy_setup_state *state)
}
cmd_id = l_genl_family_send(nl80211, msg,
- manager_new_interface_cb, state,
+ manager_new_station_interface_cb, state,
+ manager_new_interface_done);
+
+ if (!cmd_id) {
+ l_error("Error sending NEW_INTERFACE for %s", ifname);
+ return;
+ }
+
+ state->pending_cmd_count++;
+
+try_create_p2p:
+ /*
+ * Require the MAC on create feature so we can send our desired
+ * interface address during GO Negotiation before actually creating
+ * the local Client/GO interface. Could be worked around if needed.
+ */
+ if (!wiphy_supports_iftype(state->wiphy, NL80211_IFTYPE_P2P_DEVICE) ||
+ !wiphy_supports_iftype(state->wiphy,
+ NL80211_IFTYPE_P2P_CLIENT) ||
+ !wiphy_has_feature(state->wiphy,
+ NL80211_FEATURE_MAC_ON_CREATE))
+ return;
+
+ /*
+ * Use wlan%i-p2p for now. We might want to use
+ * <default_interface's_name>-p2p here (in case state->use_default
+ * is true) but the risk is that we'd go over the interface name
+ * length limit.
+ */
+ snprintf(ifname, sizeof(ifname), "wlan%i-p2p", (int) state->id);
+ l_debug("creating %s", ifname);
+ iftype = NL80211_IFTYPE_P2P_DEVICE;
+
+ msg = l_genl_msg_new(NL80211_CMD_NEW_INTERFACE);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_WIPHY, 4, &state->id);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_IFTYPE, 4, &iftype);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_IFNAME,
+ strlen(ifname) + 1, ifname);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_4ADDR, 1, "\0");
+ l_genl_msg_append_attr(msg, NL80211_ATTR_SOCKET_OWNER, 0, "");
+ cmd_id = l_genl_family_send(nl80211, msg,
+ manager_new_p2p_interface_cb, state,
manager_new_interface_done);
if (!cmd_id) {
@@ -378,17 +447,6 @@ static struct wiphy_setup_state *manager_find_pending(uint32_t id)
L_UINT_TO_PTR(id));
}
-static uint32_t manager_parse_ifindex(struct l_genl_msg *msg)
-{
- uint32_t ifindex;
-
- if (nl80211_parse_attrs(msg, NL80211_ATTR_IFINDEX, &ifindex,
- NL80211_ATTR_UNSPEC) < 0)
- return -1;
-
- return ifindex;
-}
-
static uint32_t manager_parse_wiphy_id(struct l_genl_msg *msg)
{
uint32_t wiphy;
@@ -593,7 +651,6 @@ static int manager_wiphy_filtered_dump(uint32_t wiphy_id,
static void manager_config_notify(struct l_genl_msg *msg, void *user_data)
{
uint8_t cmd;
- struct netdev *netdev;
uint32_t wiphy_id;
struct wiphy_setup_state *state;
@@ -692,13 +749,36 @@ static void manager_config_notify(struct l_genl_msg *msg, void *user_data)
return;
case NL80211_CMD_DEL_INTERFACE:
- netdev = netdev_find(manager_parse_ifindex(msg));
- if (!netdev)
- return;
+ {
+ uint32_t ifindex;
+
+ if (nl80211_parse_attrs(msg, NL80211_ATTR_IFINDEX, &ifindex,
+ NL80211_ATTR_UNSPEC) < 0) {
+ uint64_t wdev_id;
+ struct p2p_device *p2p_device;
+
+ if (nl80211_parse_attrs(msg, NL80211_ATTR_WDEV,
+ &wdev_id,
+ NL80211_ATTR_UNSPEC) < 0)
+ return;
+
+ p2p_device = p2p_device_find(wdev_id);
+ if (!p2p_device)
+ return;
+
+ p2p_device_destroy(p2p_device);
+ } else {
+ struct netdev *netdev = netdev_find(ifindex);
+
+ if (!netdev)
+ return;
+
+ netdev_destroy(netdev);
+ }
- netdev_destroy(netdev);
return;
}
+ }
}
static int manager_init(void)
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 04/17] p2p: Add peer WSC device type properties
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 02/17] Add minimal p2p.c and p2p.h Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 03/17] manager: Create/destroy P2P devices Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-17 17:33 ` Denis Kenzior
2020-04-03 16:14 ` [PATCH 05/17] p2p: Add main device settings Andrew Zaborowski
` (13 subsequent siblings)
16 siblings, 1 reply; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 5871 bytes --]
---
src/p2p.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 208 insertions(+)
diff --git a/src/p2p.c b/src/p2p.c
index 957482eb..49111a98 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -68,10 +68,156 @@ struct p2p_peer {
struct scan_bss *bss;
struct p2p_device *dev;
char *name;
+ struct wsc_primary_device_type primary_device_type;
};
static struct l_queue *p2p_device_list;
+struct device_type_category_info {
+ char *category_str;
+ unsigned int subcategory_max;
+ char **subcategory_str;
+};
+
+/* Wi-Fi Simple Configuration Technical Specification v2.0.5 Table 41 */
+struct device_type_category_info device_type_categories[] = {
+ [1] = {
+ "Computer",
+ 10,
+ (char *[]) {
+ [1] = "PC",
+ [2] = "Server",
+ [3] = "Media Center",
+ [4] = "Ultra-mobile PC",
+ [5] = "Notebook",
+ [6] = "Desktop",
+ [7] = "Mobile Internet Device",
+ [8] = "Netbook",
+ [9] = "Tablet",
+ [10] = "Ultrabook",
+ },
+ },
+ [2] = {
+ "Input Device",
+ 9,
+ (char *[]) {
+ [1] = "Keyboard",
+ [2] = "Mouse",
+ [3] = "Joystick",
+ [4] = "Trackball",
+ [5] = "Gaming controller",
+ [6] = "Remote",
+ [7] = "Touchscreen",
+ [8] = "Biometric reader",
+ [9] = "Barcode reader",
+ },
+ },
+ [3] = {
+ "Printer or Scanner",
+ 5,
+ (char *[]) {
+ [1] = "Printer/Print Server",
+ [2] = "Scanner",
+ [3] = "Fax",
+ [4] = "Copier",
+ [5] = "All-in-one printer, scanner, fax, copier",
+ },
+ },
+ [4] = {
+ "Camera",
+ 4,
+ (char *[]) {
+ [1] = "Digital Still Camera",
+ [2] = "Video Camera",
+ [3] = "Web Camera",
+ [4] = "Security Camera",
+ },
+ },
+ [5] = {
+ "Storage",
+ 1,
+ (char *[]) {
+ [1] = "NAS",
+ },
+ },
+ [6] = {
+ "Network Infrastructure",
+ 5,
+ (char *[]) {
+ [1] = "AP",
+ [2] = "Router",
+ [3] = "Switch",
+ [4] = "Gateway",
+ [5] = "Bridge",
+ },
+ },
+ [7] = {
+ "Display",
+ 4,
+ (char *[]) {
+ [1] = "Television",
+ [2] = "Electronic Picture Frame",
+ [3] = "Projector",
+ [4] = "Monitor",
+ },
+ },
+ [8] = {
+ "Multimedia Device",
+ 6,
+ (char *[]) {
+ [1] = "DAR",
+ [2] = "PVR",
+ [3] = "MCX",
+ [4] = "Set-top box",
+ [5] = "Media Server/Adapter/Extender",
+ [6] = "Portable Video Player",
+ },
+ },
+ [9] = {
+ "Gaming device",
+ 5,
+ (char *[]) {
+ [1] = "Xbox",
+ [2] = "Xbox360",
+ [3] = "Playstation",
+ [4] = "Game Console/Console Adapter",
+ [5] = "Portable Gaming Device",
+ },
+ },
+ [10] = {
+ "Telephone",
+ 5,
+ (char *[]) {
+ [1] = "Windows Mobile",
+ [2] = "Single mode phone",
+ [3] = "Dual mode phone",
+ [4] = "Single mode smartphone",
+ [5] = "Dual mode smartphone",
+ },
+ },
+ [11] = {
+ "Audio Device",
+ 7,
+ (char *[]) {
+ [1] = "Audio tuner/receiver",
+ [2] = "Speakers",
+ [3] = "Portable Music Player",
+ [4] = "Headset",
+ [5] = "Headphones",
+ [6] = "Microphone",
+ [7] = "Home Theater System",
+ },
+ },
+ [12] = {
+ "Docking Device",
+ 2,
+ (char *[]) {
+ [1] = "Computer docking station",
+ [2] = "Media kiosk",
+ },
+ },
+};
+
static bool p2p_device_match(const void *a, const void *b)
{
const struct p2p_device *dev = a;
@@ -301,6 +447,64 @@ static bool p2p_peer_get_name(struct l_dbus *dbus,
return true;
}
+static bool p2p_peer_get_category(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_builder *builder,
+ void *user_data)
+{
+ struct p2p_peer *peer = user_data;
+ uint16_t category_id = peer->primary_device_type.category;
+ const char *category = NULL;
+
+ if (category_id == 255)
+ category = "Other";
+ else if (category_id < L_ARRAY_SIZE(device_type_categories))
+ category = device_type_categories[category_id].category_str;
+
+ if (!category)
+ category = "Unknown";
+
+ l_dbus_message_builder_append_basic(builder, 's', category);
+ return true;
+}
+
+static bool p2p_peer_get_subcategory(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_builder *builder,
+ void *user_data)
+{
+ struct p2p_peer *peer = user_data;
+ uint16_t category_id = peer->primary_device_type.category;
+ uint16_t subcategory_id = peer->primary_device_type.subcategory;
+ const char *subcategory;
+
+ /*
+ * Should we generate subcategory strings with the numerical
+ * values for the subcategories we don't know, such as
+ * "Vendor-specific 00:11:22:33 44" ?
+ */
+
+ if (memcmp(peer->primary_device_type.oui, microsoft_oui, 3) ||
+ peer->primary_device_type.oui_type != 4)
+ return false;
+
+ if (category_id >= L_ARRAY_SIZE(device_type_categories))
+ return false;
+
+ if (!device_type_categories[category_id].subcategory_str ||
+ subcategory_id >
+ device_type_categories[category_id].subcategory_max)
+ return false;
+
+ subcategory = device_type_categories[category_id].
+ subcategory_str[subcategory_id];
+ if (!subcategory)
+ return false;
+
+ l_dbus_message_builder_append_basic(builder, 's', subcategory);
+ return true;
+}
+
static bool p2p_peer_get_connected(struct l_dbus *dbus,
struct l_dbus_message *message,
struct l_dbus_message_builder *builder,
@@ -316,6 +520,10 @@ static void p2p_peer_interface_setup(struct l_dbus_interface *interface)
{
l_dbus_interface_property(interface, "Name", 0, "s",
p2p_peer_get_name, NULL);
+ l_dbus_interface_property(interface, "DeviceCategory", 0, "s",
+ p2p_peer_get_category, NULL);
+ l_dbus_interface_property(interface, "DeviceSubcategory", 0, "s",
+ p2p_peer_get_subcategory, NULL);
l_dbus_interface_property(interface, "Connected", 0, "b",
p2p_peer_get_connected, NULL);
}
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* Re: [PATCH 04/17] p2p: Add peer WSC device type properties
2020-04-03 16:14 ` [PATCH 04/17] p2p: Add peer WSC device type properties Andrew Zaborowski
@ 2020-04-17 17:33 ` Denis Kenzior
2020-04-17 20:55 ` Andrew Zaborowski
0 siblings, 1 reply; 28+ messages in thread
From: Denis Kenzior @ 2020-04-17 17:33 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 6829 bytes --]
Hi Andrew,
On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> ---
> src/p2p.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 208 insertions(+)
>
> diff --git a/src/p2p.c b/src/p2p.c
> index 957482eb..49111a98 100644
> --- a/src/p2p.c
> +++ b/src/p2p.c
> @@ -68,10 +68,156 @@ struct p2p_peer {
> struct scan_bss *bss;
> struct p2p_device *dev;
> char *name;
> + struct wsc_primary_device_type primary_device_type;
> };
>
> static struct l_queue *p2p_device_list;
>
> +struct device_type_category_info {
> + char *category_str;
const char?
> + unsigned int subcategory_max;
> + char **subcategory_str;
const char **?
> +};
> +
> +/* Wi-Fi Simple Configuration Technical Specification v2.0.5 Table 41 */
> +struct device_type_category_info device_type_categories[] = {
> + [1] = {
> + "Computer",
> + 10,
> + (char *[]) {
> + [1] = "PC",
> + [2] = "Server",
> + [3] = "Media Center",
> + [4] = "Ultra-mobile PC",
> + [5] = "Notebook",
> + [6] = "Desktop",
> + [7] = "Mobile Internet Device",
> + [8] = "Netbook",
> + [9] = "Tablet",
> + [10] = "Ultrabook",
> + },
> + },
> + [2] = {
> + "Input Device",
> + 9,
> + (char *[]) {
> + [1] = "Keyboard",
> + [2] = "Mouse",
> + [3] = "Joystick",
> + [4] = "Trackball",
> + [5] = "Gaming controller",
> + [6] = "Remote",
> + [7] = "Touchscreen",
> + [8] = "Biometric reader",
> + [9] = "Barcode reader",
> + },
> + },
> + [3] = {
> + "Printer or Scanner",
> + 5,
> + (char *[]) {
> + [1] = "Printer/Print Server",
> + [2] = "Scanner",
> + [3] = "Fax",
> + [4] = "Copier",
> + [5] = "All-in-one printer, scanner, fax, copier",
> + },
> + },
> + [4] = {
> + "Camera",
> + 4,
> + (char *[]) {
> + [1] = "Digital Still Camera",
> + [2] = "Video Camera",
> + [3] = "Web Camera",
> + [4] = "Security Camera",
> + },
> + },
> + [5] = {
> + "Storage",
> + 1,
> + (char *[]) {
> + [1] = "NAS",
> + },
> + },
> + [6] = {
> + "Network Infrastructure",
> + 5,
> + (char *[]) {
> + [1] = "AP",
> + [2] = "Router",
> + [3] = "Switch",
> + [4] = "Gateway",
> + [5] = "Bridge",
> + },
> + },
> + [7] = {
> + "Display",
> + 4,
> + (char *[]) {
> + [1] = "Television",
> + [2] = "Electronic Picture Frame",
> + [3] = "Projector",
> + [4] = "Monitor",
> + },
> + },
> + [8] = {
> + "Multimedia Device",
> + 6,
> + (char *[]) {
> + [1] = "DAR",
> + [2] = "PVR",
> + [3] = "MCX",
> + [4] = "Set-top box",
> + [5] = "Media Server/Adapter/Extender",
> + [6] = "Portable Video Player",
> + },
> + },
> + [9] = {
> + "Gaming device",
> + 5,
> + (char *[]) {
> + [1] = "Xbox",
> + [2] = "Xbox360",
> + [3] = "Playstation",
> + [4] = "Game Console/Console Adapter",
> + [5] = "Portable Gaming Device",
> + },
> + },
> + [10] = {
> + "Telephone",
> + 5,
> + (char *[]) {
> + [1] = "Windows Mobile",
> + [2] = "Single mode phone",
> + [3] = "Dual mode phone",
> + [4] = "Single mode smartphone",
> + [5] = "Dual mode smartphone",
> + },
> + },
> + [11] = {
> + "Audio Device",
> + 7,
> + (char *[]) {
> + [1] = "Audio tuner/receiver",
> + [2] = "Speakers",
> + [3] = "Portable Music Player",
> + [4] = "Headset",
> + [5] = "Headphones",
> + [6] = "Microphone",
> + [7] = "Home Theater System",
> + },
> + },
> + [12] = {
> + "Docking Device",
> + 2,
> + (char *[]) {
> + [1] = "Computer docking station",
> + [2] = "Media kiosk",
> + },
> + },
> +};
> +
So two things I see here:
1. Does this belong in wscutil.c instead?
2. Your intent seems to be to expose these as D-Bus API values. If so,
then this gets a bit tricky. Our D-Bus APIs do not support translation.
This is by design, hence all values need to be defined in
doc/foo-api.txt. The values must also be all lower case.
> static bool p2p_device_match(const void *a, const void *b)
> {
> const struct p2p_device *dev = a;
> @@ -301,6 +447,64 @@ static bool p2p_peer_get_name(struct l_dbus *dbus,
> return true;
> }
>
> +static bool p2p_peer_get_category(struct l_dbus *dbus,
> + struct l_dbus_message *message,
> + struct l_dbus_message_builder *builder,
> + void *user_data)
> +{
> + struct p2p_peer *peer = user_data;
> + uint16_t category_id = peer->primary_device_type.category;
> + const char *category = NULL;
> +
> + if (category_id == 255)
> + category = "Other";
> + else if (category_id < L_ARRAY_SIZE(device_type_categories))
> + category = device_type_categories[category_id].category_str;
> +
> + if (!category)
> + category = "Unknown";
> +
> + l_dbus_message_builder_append_basic(builder, 's', category);
> + return true;
> +}
> +
> +static bool p2p_peer_get_subcategory(struct l_dbus *dbus,
> + struct l_dbus_message *message,
> + struct l_dbus_message_builder *builder,
> + void *user_data)
> +{
> + struct p2p_peer *peer = user_data;
> + uint16_t category_id = peer->primary_device_type.category;
> + uint16_t subcategory_id = peer->primary_device_type.subcategory;
> + const char *subcategory;
> +
> + /*
> + * Should we generate subcategory strings with the numerical
> + * values for the subcategories we don't know, such as
> + * "Vendor-specific 00:11:22:33 44" ?
> + */
> +
> + if (memcmp(peer->primary_device_type.oui, microsoft_oui, 3) ||
> + peer->primary_device_type.oui_type != 4)
> + return false;
> +
> + if (category_id >= L_ARRAY_SIZE(device_type_categories))
> + return false;
> +
> + if (!device_type_categories[category_id].subcategory_str ||
> + subcategory_id >
> + device_type_categories[category_id].subcategory_max)
> + return false;
> +
> + subcategory = device_type_categories[category_id].
> + subcategory_str[subcategory_id];
> + if (!subcategory)
> + return false;
> +
> + l_dbus_message_builder_append_basic(builder, 's', subcategory);
> + return true;
> +}
> +
> static bool p2p_peer_get_connected(struct l_dbus *dbus,
> struct l_dbus_message *message,
> struct l_dbus_message_builder *builder,
> @@ -316,6 +520,10 @@ static void p2p_peer_interface_setup(struct l_dbus_interface *interface)
> {
> l_dbus_interface_property(interface, "Name", 0, "s",
> p2p_peer_get_name, NULL);
> + l_dbus_interface_property(interface, "DeviceCategory", 0, "s",
> + p2p_peer_get_category, NULL);
> + l_dbus_interface_property(interface, "DeviceSubcategory", 0, "s",
> + p2p_peer_get_subcategory, NULL);
> l_dbus_interface_property(interface, "Connected", 0, "b",
> p2p_peer_get_connected, NULL);
> }
>
Regards,
-Denis
^ permalink raw reply [flat|nested] 28+ messages in thread* Re: [PATCH 04/17] p2p: Add peer WSC device type properties
2020-04-17 17:33 ` Denis Kenzior
@ 2020-04-17 20:55 ` Andrew Zaborowski
0 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-17 20:55 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 6695 bytes --]
Hi Denis,
On Fri, 17 Apr 2020 at 21:33, Denis Kenzior <denkenz@gmail.com> wrote:
> Hi Andrew,
>
> On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> > ---
> > src/p2p.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > 1 file changed, 208 insertions(+)
> >
> > diff --git a/src/p2p.c b/src/p2p.c
> > index 957482eb..49111a98 100644
> > --- a/src/p2p.c
> > +++ b/src/p2p.c
> > @@ -68,10 +68,156 @@ struct p2p_peer {
> > struct scan_bss *bss;
> > struct p2p_device *dev;
> > char *name;
> > + struct wsc_primary_device_type primary_device_type;
> > };
> >
> > static struct l_queue *p2p_device_list;
> >
> > +struct device_type_category_info {
> > + char *category_str;
>
> const char?
Ok, makes sense.
>
> > + unsigned int subcategory_max;
> > + char **subcategory_str;
>
> const char **?
Same here.
>
> > +};
> > +
> > +/* Wi-Fi Simple Configuration Technical Specification v2.0.5 Table 41 */
> > +struct device_type_category_info device_type_categories[] = {
> > + [1] = {
> > + "Computer",
> > + 10,
> > + (char *[]) {
> > + [1] = "PC",
> > + [2] = "Server",
> > + [3] = "Media Center",
> > + [4] = "Ultra-mobile PC",
> > + [5] = "Notebook",
> > + [6] = "Desktop",
> > + [7] = "Mobile Internet Device",
> > + [8] = "Netbook",
> > + [9] = "Tablet",
> > + [10] = "Ultrabook",
> > + },
> > + },
> > + [2] = {
> > + "Input Device",
> > + 9,
> > + (char *[]) {
> > + [1] = "Keyboard",
> > + [2] = "Mouse",
> > + [3] = "Joystick",
> > + [4] = "Trackball",
> > + [5] = "Gaming controller",
> > + [6] = "Remote",
> > + [7] = "Touchscreen",
> > + [8] = "Biometric reader",
> > + [9] = "Barcode reader",
> > + },
> > + },
> > + [3] = {
> > + "Printer or Scanner",
> > + 5,
> > + (char *[]) {
> > + [1] = "Printer/Print Server",
> > + [2] = "Scanner",
> > + [3] = "Fax",
> > + [4] = "Copier",
> > + [5] = "All-in-one printer, scanner, fax, copier",
> > + },
> > + },
> > + [4] = {
> > + "Camera",
> > + 4,
> > + (char *[]) {
> > + [1] = "Digital Still Camera",
> > + [2] = "Video Camera",
> > + [3] = "Web Camera",
> > + [4] = "Security Camera",
> > + },
> > + },
> > + [5] = {
> > + "Storage",
> > + 1,
> > + (char *[]) {
> > + [1] = "NAS",
> > + },
> > + },
> > + [6] = {
> > + "Network Infrastructure",
> > + 5,
> > + (char *[]) {
> > + [1] = "AP",
> > + [2] = "Router",
> > + [3] = "Switch",
> > + [4] = "Gateway",
> > + [5] = "Bridge",
> > + },
> > + },
> > + [7] = {
> > + "Display",
> > + 4,
> > + (char *[]) {
> > + [1] = "Television",
> > + [2] = "Electronic Picture Frame",
> > + [3] = "Projector",
> > + [4] = "Monitor",
> > + },
> > + },
> > + [8] = {
> > + "Multimedia Device",
> > + 6,
> > + (char *[]) {
> > + [1] = "DAR",
> > + [2] = "PVR",
> > + [3] = "MCX",
> > + [4] = "Set-top box",
> > + [5] = "Media Server/Adapter/Extender",
> > + [6] = "Portable Video Player",
> > + },
> > + },
> > + [9] = {
> > + "Gaming device",
> > + 5,
> > + (char *[]) {
> > + [1] = "Xbox",
> > + [2] = "Xbox360",
> > + [3] = "Playstation",
> > + [4] = "Game Console/Console Adapter",
> > + [5] = "Portable Gaming Device",
> > + },
> > + },
> > + [10] = {
> > + "Telephone",
> > + 5,
> > + (char *[]) {
> > + [1] = "Windows Mobile",
> > + [2] = "Single mode phone",
> > + [3] = "Dual mode phone",
> > + [4] = "Single mode smartphone",
> > + [5] = "Dual mode smartphone",
> > + },
> > + },
> > + [11] = {
> > + "Audio Device",
> > + 7,
> > + (char *[]) {
> > + [1] = "Audio tuner/receiver",
> > + [2] = "Speakers",
> > + [3] = "Portable Music Player",
> > + [4] = "Headset",
> > + [5] = "Headphones",
> > + [6] = "Microphone",
> > + [7] = "Home Theater System",
> > + },
> > + },
> > + [12] = {
> > + "Docking Device",
> > + 2,
> > + (char *[]) {
> > + [1] = "Computer docking station",
> > + [2] = "Media kiosk",
> > + },
> > + },
> > +};
> > +
>
> So two things I see here:
>
> 1. Does this belong in wscutil.c instead?
True, it fits better there.
> 2. Your intent seems to be to expose these as D-Bus API values. If so,
> then this gets a bit tricky. Our D-Bus APIs do not support translation.
> This is by design, hence all values need to be defined in
> doc/foo-api.txt. The values must also be all lower case.
Hmmm okay. The other option would be to export these as numeric values
but we'd be forcing the API users to look them up in the spec,
possibly also their translators. I think it might be worth listing
the values in p2p-peer-api.txt even though there are 75 strings. Or
could we reference "Wi-Fi Simple Configuration Technical Specification
v2.0.5 Table 41" in the docs instead?
Best regards
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH 05/17] p2p: Add main device settings
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (2 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 04/17] p2p: Add peer WSC device type properties Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-17 16:26 ` Denis Kenzior
2020-04-03 16:14 ` [PATCH 06/17] p2p: Add device enable/disable logic Andrew Zaborowski
` (12 subsequent siblings)
16 siblings, 1 reply; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 7195 bytes --]
Read the country code (for channel operating classes), WSC configuration
methods and the Primary Device Type from the config file and expose
device name as a property.
---
src/p2p.c | 189 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 189 insertions(+)
diff --git a/src/p2p.c b/src/p2p.c
index 49111a98..ab21239d 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -60,7 +60,10 @@ struct p2p_device {
uint8_t addr[6];
struct wiphy *wiphy;
unsigned int connections_left;
+ struct p2p_capability_attr capability;
+ struct p2p_device_info_attr device_info;
+ uint8_t country[3];
struct l_queue *peer_list;
};
@@ -276,6 +279,9 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
const uint64_t *wdev_id = NULL;
struct wiphy *wiphy = NULL;
struct p2p_device *dev;
+ char hostname[HOST_NAME_MAX + 1];
+ char *str;
+ unsigned int uint_val;
if (!l_genl_attr_init(&attr, msg))
return NULL;
@@ -345,8 +351,148 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
dev->wdev_id = *wdev_id;
memcpy(dev->addr, ifaddr, ETH_ALEN);
dev->wiphy = wiphy;
+ gethostname(hostname, sizeof(hostname));
dev->connections_left = 1;
+ dev->country[0] = 'X';
+ dev->country[1] = 'X';
+ dev->country[2] = 4; /* Table E-4 */
+
+ str = l_settings_get_string(iwd_get_config(), "General", "CountryCode");
+ if (str) {
+ if (strlen(str) != 2)
+ l_error("[General].CountryCode must be a 2-character "
+ "string");
+ else {
+ dev->country[0] = str[0];
+ dev->country[1] = str[1];
+ }
+
+ l_free(str);
+ }
+
+ /* TODO: allow masking capability bits through a setting? */
+ dev->capability.device_caps = P2P_DEVICE_CAP_CONCURRENT_OP;
+ dev->capability.group_caps = 0;
+
+ memcpy(dev->device_info.device_addr, dev->addr, 6);
+
+ dev->device_info.wsc_config_methods =
+ WSC_CONFIGURATION_METHOD_LABEL |
+ WSC_CONFIGURATION_METHOD_KEYPAD |
+ WSC_CONFIGURATION_METHOD_VIRTUAL_PUSH_BUTTON |
+ WSC_CONFIGURATION_METHOD_PHYSICAL_PUSH_BUTTON |
+ WSC_CONFIGURATION_METHOD_P2P |
+ WSC_CONFIGURATION_METHOD_VIRTUAL_DISPLAY_PIN |
+ WSC_CONFIGURATION_METHOD_PHYSICAL_DISPLAY_PIN;
+ dev->device_info.primary_device_type.category = 1; /* Computer */
+ memcpy(dev->device_info.primary_device_type.oui, microsoft_oui, 3);
+ dev->device_info.primary_device_type.oui_type = 0x04;
+ dev->device_info.primary_device_type.subcategory = 1; /* PC */
+ l_strlcpy(dev->device_info.device_name, hostname,
+ sizeof(dev->device_info.device_name));
+
+ /* TODO: possibly interpret a list of strings of config method names */
+ if (l_settings_get_uint(iwd_get_config(), "P2P",
+ "ConfigurationMethodMask", &uint_val)) {
+ if (!(dev->device_info.wsc_config_methods & uint_val))
+ l_error("[P2P].ConfigurationMethodMask must contain "
+ "at least one supported method");
+ else if (uint_val & ~0xffff)
+ l_error("[P2P].ConfigurationMethodMask should be a "
+ "16-bit integer");
+ else
+ dev->device_info.wsc_config_methods &= uint_val;
+ }
+
+ str = l_settings_get_string(iwd_get_config(), "P2P", "DeviceCategory");
+ if (str) {
+ unsigned int i;
+ char *endp;
+
+ i = strtoul(str, &endp, 0);
+
+ if (*endp == '\0') {
+ if (i < 1 || i > 255) {
+ l_error("[P2P].DeviceCategory must be in the "
+ "range 1-255");
+ i = 0;
+ }
+ } else if (!strcmp(str, "Other"))
+ i = 255;
+ else {
+ for (i = 0; i < L_ARRAY_SIZE(device_type_categories);
+ i++) {
+ struct device_type_category_info *cat_info =
+ &device_type_categories[i];
+
+ if (!cat_info->category_str)
+ continue;
+
+ if (strcasecmp(str, cat_info->category_str))
+ continue;
+
+ break;
+ }
+
+ if (i == L_ARRAY_SIZE(device_type_categories)) {
+ l_error("Unkown [P2P].DeviceCategory %s", str);
+ i = 0;
+ }
+ }
+
+ if (i)
+ dev->device_info.primary_device_type.category = i;
+ }
+
+ str = l_settings_get_string(iwd_get_config(), "P2P",
+ "DeviceSubcategory");
+ if (str) {
+ unsigned int i;
+ char *endp;
+ unsigned int category =
+ dev->device_info.primary_device_type.category;
+ struct device_type_category_info *cat_info =
+ &device_type_categories[category];
+
+ i = strtoul(str, &endp, 0);
+
+ if (*endp == '\0') {
+ if (i < 1 || i > 255) {
+ l_error("[P2P].DeviceSubcategory must be in "
+ "the range 1-255");
+ i = 0;
+ }
+ } else if (!strcmp(str, "Other"))
+ i = 255;
+ else if (category < L_ARRAY_SIZE(device_type_categories) &&
+ cat_info->subcategory_max) {
+ for (i = 0; i <= cat_info->subcategory_max; i++) {
+ if (!cat_info->subcategory_str[i])
+ continue;
+
+ if (strcasecmp(str,
+ cat_info->subcategory_str[i]))
+ continue;
+
+ break;
+ }
+
+ if (i > cat_info->subcategory_max) {
+ l_error("Unkown [P2P].DeviceSubcategory %s",
+ str);
+ i = 0;
+ }
+ } else {
+ l_error("Only numeric [P2P].DeviceSubcategory values "
+ "allowed for this category");
+ i = 0;
+ }
+
+ if (i)
+ dev->device_info.primary_device_type.subcategory = i;
+ }
+
l_queue_push_tail(p2p_device_list, dev);
l_debug("Created P2P device %" PRIx64, dev->wdev_id);
@@ -378,6 +524,46 @@ bool p2p_device_destroy(struct p2p_device *dev)
return true;
}
+static bool p2p_device_get_name(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_builder *builder,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ l_dbus_message_builder_append_basic(builder, 's',
+ dev->device_info.device_name);
+ return true;
+}
+
+static struct l_dbus_message *p2p_device_set_name(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_iter *new_value,
+ l_dbus_property_complete_cb_t complete,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ const char *new_name;
+
+ if (!l_dbus_message_iter_get_variant(new_value, "s", &new_name))
+ return dbus_error_invalid_args(message);
+
+ if (!strcmp(new_name, dev->device_info.device_name))
+ goto done;
+
+ if (strlen(new_name) > sizeof(dev->device_info.device_name) - 1)
+ return dbus_error_invalid_args(message);
+
+ l_strlcpy(dev->device_info.device_name, new_name,
+ sizeof(dev->device_info.device_name));
+ l_dbus_property_changed(dbus, p2p_device_get_path(dev),
+ IWD_P2P_INTERFACE, "Name");
+
+done:
+ complete(dbus, message, NULL);
+ return NULL;
+}
+
static bool p2p_device_get_avail_conns(struct l_dbus *dbus,
struct l_dbus_message *message,
struct l_dbus_message_builder *builder,
@@ -430,6 +616,9 @@ static struct l_dbus_message *p2p_device_get_peers(struct l_dbus *dbus,
static void p2p_interface_setup(struct l_dbus_interface *interface)
{
+ l_dbus_interface_property(interface, "Name", 0, "s",
+ p2p_device_get_name,
+ p2p_device_set_name);
l_dbus_interface_property(interface, "AvailableConnections", 0, "q",
p2p_device_get_avail_conns, NULL);
l_dbus_interface_method(interface, "GetPeers", 0,
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* Re: [PATCH 05/17] p2p: Add main device settings
2020-04-03 16:14 ` [PATCH 05/17] p2p: Add main device settings Andrew Zaborowski
@ 2020-04-17 16:26 ` Denis Kenzior
2020-04-17 23:02 ` Andrew Zaborowski
0 siblings, 1 reply; 28+ messages in thread
From: Denis Kenzior @ 2020-04-17 16:26 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 8584 bytes --]
Hi Andrew,
On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> Read the country code (for channel operating classes), WSC configuration
hmm, shouldn't we be getting this from the kernel directly and not some
config file? What if we're roaming?
> methods and the Primary Device Type from the config file and expose
> device name as a property.
> ---
> src/p2p.c | 189 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 189 insertions(+)
>
> diff --git a/src/p2p.c b/src/p2p.c
> index 49111a98..ab21239d 100644
> --- a/src/p2p.c
> +++ b/src/p2p.c
> @@ -60,7 +60,10 @@ struct p2p_device {
> uint8_t addr[6];
> struct wiphy *wiphy;
> unsigned int connections_left;
> + struct p2p_capability_attr capability;
> + struct p2p_device_info_attr device_info;
>
> + uint8_t country[3];
> struct l_queue *peer_list;
> };
>
> @@ -276,6 +279,9 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> const uint64_t *wdev_id = NULL;
> struct wiphy *wiphy = NULL;
> struct p2p_device *dev;
> + char hostname[HOST_NAME_MAX + 1];
> + char *str;
> + unsigned int uint_val;
>
> if (!l_genl_attr_init(&attr, msg))
> return NULL;
> @@ -345,8 +351,148 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> dev->wdev_id = *wdev_id;
> memcpy(dev->addr, ifaddr, ETH_ALEN);
> dev->wiphy = wiphy;
> + gethostname(hostname, sizeof(hostname));
> dev->connections_left = 1;
>
> + dev->country[0] = 'X';
> + dev->country[1] = 'X';
> + dev->country[2] = 4; /* Table E-4 */
> +
> + str = l_settings_get_string(iwd_get_config(), "General", "CountryCode");
> + if (str) {
> + if (strlen(str) != 2)
> + l_error("[General].CountryCode must be a 2-character "
> + "string");
> + else {
> + dev->country[0] = str[0];
> + dev->country[1] = str[1];
> + }
> +
> + l_free(str);
> + }
> +
> + /* TODO: allow masking capability bits through a setting? */
> + dev->capability.device_caps = P2P_DEVICE_CAP_CONCURRENT_OP;
> + dev->capability.group_caps = 0;
> +
> + memcpy(dev->device_info.device_addr, dev->addr, 6);
> +
> + dev->device_info.wsc_config_methods =
> + WSC_CONFIGURATION_METHOD_LABEL |
Do you really need this one? I think we discussed this at some point,
and it should be okay, but just checking...
> + WSC_CONFIGURATION_METHOD_KEYPAD |
> + WSC_CONFIGURATION_METHOD_VIRTUAL_PUSH_BUTTON |
> + WSC_CONFIGURATION_METHOD_PHYSICAL_PUSH_BUTTON |
Not sure about this one as a 'default'.
> + WSC_CONFIGURATION_METHOD_P2P |
> + WSC_CONFIGURATION_METHOD_VIRTUAL_DISPLAY_PIN |
> + WSC_CONFIGURATION_METHOD_PHYSICAL_DISPLAY_PIN;
> + dev->device_info.primary_device_type.category = 1; /* Computer */
> + memcpy(dev->device_info.primary_device_type.oui, microsoft_oui, 3);
> + dev->device_info.primary_device_type.oui_type = 0x04;
> + dev->device_info.primary_device_type.subcategory = 1; /* PC */
> + l_strlcpy(dev->device_info.device_name, hostname,
> + sizeof(dev->device_info.device_name));
> +
Okay
> + /* TODO: possibly interpret a list of strings of config method names */
> + if (l_settings_get_uint(iwd_get_config(), "P2P",
> + "ConfigurationMethodMask", &uint_val)) {
> + if (!(dev->device_info.wsc_config_methods & uint_val))
> + l_error("[P2P].ConfigurationMethodMask must contain "
> + "at least one supported method");
> + else if (uint_val & ~0xffff)
> + l_error("[P2P].ConfigurationMethodMask should be a "
> + "16-bit integer");
> + else
> + dev->device_info.wsc_config_methods &= uint_val;
> + }
> +
Why a mask? Why not specify these directly?
> + str = l_settings_get_string(iwd_get_config(), "P2P", "DeviceCategory");
> + if (str) {
> + unsigned int i;
> + char *endp;
> +
> + i = strtoul(str, &endp, 0);
> +
> + if (*endp == '\0') {
> + if (i < 1 || i > 255) {
> + l_error("[P2P].DeviceCategory must be in the "
> + "range 1-255");
> + i = 0;
> + }
> + } else if (!strcmp(str, "Other"))
> + i = 255;
> + else {
> + for (i = 0; i < L_ARRAY_SIZE(device_type_categories);
> + i++) {
> + struct device_type_category_info *cat_info =
> + &device_type_categories[i];
> +
> + if (!cat_info->category_str)
> + continue;
> +
> + if (strcasecmp(str, cat_info->category_str))
> + continue;
> +
> + break;
> + }
> +
> + if (i == L_ARRAY_SIZE(device_type_categories)) {
> + l_error("Unkown [P2P].DeviceCategory %s", str);
> + i = 0;
> + }
> + }
> +
> + if (i)
> + dev->device_info.primary_device_type.category = i;
> + }
> +
> + str = l_settings_get_string(iwd_get_config(), "P2P",
> + "DeviceSubcategory");
> + if (str) {
> + unsigned int i;
> + char *endp;
> + unsigned int category =
> + dev->device_info.primary_device_type.category;
> + struct device_type_category_info *cat_info =
> + &device_type_categories[category];
> +
> + i = strtoul(str, &endp, 0);
> +
> + if (*endp == '\0') {
> + if (i < 1 || i > 255) {
> + l_error("[P2P].DeviceSubcategory must be in "
> + "the range 1-255");
> + i = 0;
> + }
> + } else if (!strcmp(str, "Other"))
> + i = 255;
> + else if (category < L_ARRAY_SIZE(device_type_categories) &&
> + cat_info->subcategory_max) {
> + for (i = 0; i <= cat_info->subcategory_max; i++) {
> + if (!cat_info->subcategory_str[i])
> + continue;
> +
> + if (strcasecmp(str,
> + cat_info->subcategory_str[i]))
> + continue;
> +
> + break;
> + }
> +
> + if (i > cat_info->subcategory_max) {
> + l_error("Unkown [P2P].DeviceSubcategory %s",
> + str);
> + i = 0;
> + }
> + } else {
> + l_error("Only numeric [P2P].DeviceSubcategory values "
> + "allowed for this category");
> + i = 0;
> + }
> +
> + if (i)
> + dev->device_info.primary_device_type.subcategory = i;
> + }
So two things:
Are you sure you want to have the user specify strings instead of the
oui / type directly? What does BlueZ do here for example?
Handling of 'Other' might need to be tweaked depending on how you
resolve comments to the previous patch.
> +
> l_queue_push_tail(p2p_device_list, dev);
>
> l_debug("Created P2P device %" PRIx64, dev->wdev_id);
> @@ -378,6 +524,46 @@ bool p2p_device_destroy(struct p2p_device *dev)
> return true;
> }
>
> +static bool p2p_device_get_name(struct l_dbus *dbus,
> + struct l_dbus_message *message,
> + struct l_dbus_message_builder *builder,
> + void *user_data)
> +{
> + struct p2p_device *dev = user_data;
> +
> + l_dbus_message_builder_append_basic(builder, 's',
> + dev->device_info.device_name);
> + return true;
> +}
> +
> +static struct l_dbus_message *p2p_device_set_name(struct l_dbus *dbus,
> + struct l_dbus_message *message,
> + struct l_dbus_message_iter *new_value,
> + l_dbus_property_complete_cb_t complete,
> + void *user_data)
> +{
> + struct p2p_device *dev = user_data;
> + const char *new_name;
> +
> + if (!l_dbus_message_iter_get_variant(new_value, "s", &new_name))
> + return dbus_error_invalid_args(message);
> +
> + if (!strcmp(new_name, dev->device_info.device_name))
> + goto done;
> +
> + if (strlen(new_name) > sizeof(dev->device_info.device_name) - 1)
> + return dbus_error_invalid_args(message);
> +
> + l_strlcpy(dev->device_info.device_name, new_name,
> + sizeof(dev->device_info.device_name));
> + l_dbus_property_changed(dbus, p2p_device_get_path(dev),
> + IWD_P2P_INTERFACE, "Name");
Hmm, our convention is to do method_return, then signal.
> +
> +done:
> + complete(dbus, message, NULL);
> + return NULL;
> +}
> +
> static bool p2p_device_get_avail_conns(struct l_dbus *dbus,
> struct l_dbus_message *message,
> struct l_dbus_message_builder *builder,
> @@ -430,6 +616,9 @@ static struct l_dbus_message *p2p_device_get_peers(struct l_dbus *dbus,
>
> static void p2p_interface_setup(struct l_dbus_interface *interface)
> {
> + l_dbus_interface_property(interface, "Name", 0, "s",
> + p2p_device_get_name,
> + p2p_device_set_name);
you don't want to use AUTO_EMIT to make things easier on yourself? As a
bonus, the previous comment would be fixed auto-magically.
> l_dbus_interface_property(interface, "AvailableConnections", 0, "q",
> p2p_device_get_avail_conns, NULL);
> l_dbus_interface_method(interface, "GetPeers", 0,
>
Regards,
-Denis
^ permalink raw reply [flat|nested] 28+ messages in thread* Re: [PATCH 05/17] p2p: Add main device settings
2020-04-17 16:26 ` Denis Kenzior
@ 2020-04-17 23:02 ` Andrew Zaborowski
0 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-17 23:02 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 13134 bytes --]
Hi Denis,
On Fri, 17 Apr 2020 at 18:26, Denis Kenzior <denkenz@gmail.com> wrote:
> On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> > Read the country code (for channel operating classes), WSC configuration
>
> hmm, shouldn't we be getting this from the kernel directly and not some
> config file? What if we're roaming?
Looks like we can use NL80211_CMD_GET_REG when initialising the wiphy
in wiphy.c, in the hope that the regulatory domain has been set
already, and query wiphy.c from p2p.c for the domain. We would also
have to listen for NL80211_CMD_REG_CHANGEs.
My understanding is that as long as the third byte is 4 the channel
numbers don't change their meanings so we don't have to do anything
else than inserting the alpha 2 code in the frame.
Most P2P devices use 'X', 'X', 4 (XX\x4) as the country code in the
P2P frames where the code is required.
>
> > methods and the Primary Device Type from the config file and expose
> > device name as a property.
> > ---
> > src/p2p.c | 189 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > 1 file changed, 189 insertions(+)
> >
> > diff --git a/src/p2p.c b/src/p2p.c
> > index 49111a98..ab21239d 100644
> > --- a/src/p2p.c
> > +++ b/src/p2p.c
> > @@ -60,7 +60,10 @@ struct p2p_device {
> > uint8_t addr[6];
> > struct wiphy *wiphy;
> > unsigned int connections_left;
> > + struct p2p_capability_attr capability;
> > + struct p2p_device_info_attr device_info;
> >
> > + uint8_t country[3];
> > struct l_queue *peer_list;
> > };
> >
> > @@ -276,6 +279,9 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> > const uint64_t *wdev_id = NULL;
> > struct wiphy *wiphy = NULL;
> > struct p2p_device *dev;
> > + char hostname[HOST_NAME_MAX + 1];
> > + char *str;
> > + unsigned int uint_val;
> >
> > if (!l_genl_attr_init(&attr, msg))
> > return NULL;
> > @@ -345,8 +351,148 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> > dev->wdev_id = *wdev_id;
> > memcpy(dev->addr, ifaddr, ETH_ALEN);
> > dev->wiphy = wiphy;
> > + gethostname(hostname, sizeof(hostname));
> > dev->connections_left = 1;
> >
> > + dev->country[0] = 'X';
> > + dev->country[1] = 'X';
> > + dev->country[2] = 4; /* Table E-4 */
> > +
> > + str = l_settings_get_string(iwd_get_config(), "General", "CountryCode");
> > + if (str) {
> > + if (strlen(str) != 2)
> > + l_error("[General].CountryCode must be a 2-character "
> > + "string");
> > + else {
> > + dev->country[0] = str[0];
> > + dev->country[1] = str[1];
> > + }
> > +
> > + l_free(str);
> > + }
> > +
> > + /* TODO: allow masking capability bits through a setting? */
> > + dev->capability.device_caps = P2P_DEVICE_CAP_CONCURRENT_OP;
> > + dev->capability.group_caps = 0;
> > +
> > + memcpy(dev->device_info.device_addr, dev->addr, 6);
> > +
> > + dev->device_info.wsc_config_methods =
> > + WSC_CONFIGURATION_METHOD_LABEL |
>
> Do you really need this one? I think we discussed this at some point,
> and it should be okay, but just checking...
I think we concluded that the current code could support this method.
>
> > + WSC_CONFIGURATION_METHOD_KEYPAD |
> > + WSC_CONFIGURATION_METHOD_VIRTUAL_PUSH_BUTTON |
> > + WSC_CONFIGURATION_METHOD_PHYSICAL_PUSH_BUTTON |
>
> Not sure about this one as a 'default'.
Maybe we should separate 'default' from 'supported', here I set all
the methods that we can support as the default because if we have no
info on the physical capabilities it's difficult to judge what methods
are likely to be available. On a standard laptop we're likely to have
physical and virtual buttons.
>
> > + WSC_CONFIGURATION_METHOD_P2P |
> > + WSC_CONFIGURATION_METHOD_VIRTUAL_DISPLAY_PIN |
> > + WSC_CONFIGURATION_METHOD_PHYSICAL_DISPLAY_PIN;
> > + dev->device_info.primary_device_type.category = 1; /* Computer */
> > + memcpy(dev->device_info.primary_device_type.oui, microsoft_oui, 3);
> > + dev->device_info.primary_device_type.oui_type = 0x04;
> > + dev->device_info.primary_device_type.subcategory = 1; /* PC */
> > + l_strlcpy(dev->device_info.device_name, hostname,
> > + sizeof(dev->device_info.device_name));
> > +
>
> Okay
>
> > + /* TODO: possibly interpret a list of strings of config method names */
> > + if (l_settings_get_uint(iwd_get_config(), "P2P",
> > + "ConfigurationMethodMask", &uint_val)) {
> > + if (!(dev->device_info.wsc_config_methods & uint_val))
> > + l_error("[P2P].ConfigurationMethodMask must contain "
> > + "at least one supported method");
> > + else if (uint_val & ~0xffff)
> > + l_error("[P2P].ConfigurationMethodMask should be a "
> > + "16-bit integer");
> > + else
> > + dev->device_info.wsc_config_methods &= uint_val;
> > + }
> > +
>
> Why a mask? Why not specify these directly?
We could skip 'Mask' from the name but the idea was that we only
enable the methods that both us and the user can support.
>
> > + str = l_settings_get_string(iwd_get_config(), "P2P", "DeviceCategory");
> > + if (str) {
> > + unsigned int i;
> > + char *endp;
> > +
> > + i = strtoul(str, &endp, 0);
> > +
> > + if (*endp == '\0') {
> > + if (i < 1 || i > 255) {
> > + l_error("[P2P].DeviceCategory must be in the "
> > + "range 1-255");
> > + i = 0;
> > + }
> > + } else if (!strcmp(str, "Other"))
> > + i = 255;
> > + else {
> > + for (i = 0; i < L_ARRAY_SIZE(device_type_categories);
> > + i++) {
> > + struct device_type_category_info *cat_info =
> > + &device_type_categories[i];
> > +
> > + if (!cat_info->category_str)
> > + continue;
> > +
> > + if (strcasecmp(str, cat_info->category_str))
> > + continue;
> > +
> > + break;
> > + }
> > +
> > + if (i == L_ARRAY_SIZE(device_type_categories)) {
> > + l_error("Unkown [P2P].DeviceCategory %s", str);
> > + i = 0;
> > + }
> > + }
> > +
> > + if (i)
> > + dev->device_info.primary_device_type.category = i;
> > + }
> > +
> > + str = l_settings_get_string(iwd_get_config(), "P2P",
> > + "DeviceSubcategory");
> > + if (str) {
> > + unsigned int i;
> > + char *endp;
> > + unsigned int category =
> > + dev->device_info.primary_device_type.category;
> > + struct device_type_category_info *cat_info =
> > + &device_type_categories[category];
> > +
> > + i = strtoul(str, &endp, 0);
> > +
> > + if (*endp == '\0') {
> > + if (i < 1 || i > 255) {
> > + l_error("[P2P].DeviceSubcategory must be in "
> > + "the range 1-255");
> > + i = 0;
> > + }
> > + } else if (!strcmp(str, "Other"))
> > + i = 255;
> > + else if (category < L_ARRAY_SIZE(device_type_categories) &&
> > + cat_info->subcategory_max) {
> > + for (i = 0; i <= cat_info->subcategory_max; i++) {
> > + if (!cat_info->subcategory_str[i])
> > + continue;
> > +
> > + if (strcasecmp(str,
> > + cat_info->subcategory_str[i]))
> > + continue;
> > +
> > + break;
> > + }
> > +
> > + if (i > cat_info->subcategory_max) {
> > + l_error("Unkown [P2P].DeviceSubcategory %s",
> > + str);
> > + i = 0;
> > + }
> > + } else {
> > + l_error("Only numeric [P2P].DeviceSubcategory values "
> > + "allowed for this category");
> > + i = 0;
> > + }
> > +
> > + if (i)
> > + dev->device_info.primary_device_type.subcategory = i;
> > + }
>
> So two things:
>
> Are you sure you want to have the user specify strings instead of the
> oui / type directly?
This supports a numeric or text category and subcategory and the OUI
is hardcoded to microsoft. I guess we could support specifying the
whole thing as one number too. I don't see a reason to not support
the string values though.
> What does BlueZ do here for example?
It only supports a hex value and only uses some bits of it. The DBus
API also only exports and accepts integer values. We could do this
too, I used strings because it seemed nicer to the users but it does
have the translation problem when used on DBus.
>
> Handling of 'Other' might need to be tweaked depending on how you
> resolve comments to the previous patch.
>
> > +
> > l_queue_push_tail(p2p_device_list, dev);
> >
> > l_debug("Created P2P device %" PRIx64, dev->wdev_id);
> > @@ -378,6 +524,46 @@ bool p2p_device_destroy(struct p2p_device *dev)
> > return true;
> > }
> >
> > +static bool p2p_device_get_name(struct l_dbus *dbus,
> > + struct l_dbus_message *message,
> > + struct l_dbus_message_builder *builder,
> > + void *user_data)
> > +{
> > + struct p2p_device *dev = user_data;
> > +
> > + l_dbus_message_builder_append_basic(builder, 's',
> > + dev->device_info.device_name);
> > + return true;
> > +}
> > +
> > +static struct l_dbus_message *p2p_device_set_name(struct l_dbus *dbus,
> > + struct l_dbus_message *message,
> > + struct l_dbus_message_iter *new_value,
> > + l_dbus_property_complete_cb_t complete,
> > + void *user_data)
> > +{
> > + struct p2p_device *dev = user_data;
> > + const char *new_name;
> > +
> > + if (!l_dbus_message_iter_get_variant(new_value, "s", &new_name))
> > + return dbus_error_invalid_args(message);
> > +
> > + if (!strcmp(new_name, dev->device_info.device_name))
> > + goto done;
> > +
> > + if (strlen(new_name) > sizeof(dev->device_info.device_name) - 1)
> > + return dbus_error_invalid_args(message);
> > +
> > + l_strlcpy(dev->device_info.device_name, new_name,
> > + sizeof(dev->device_info.device_name));
> > + l_dbus_property_changed(dbus, p2p_device_get_path(dev),
> > + IWD_P2P_INTERFACE, "Name");
>
> Hmm, our convention is to do method_return, then signal.
Ok.
>
> > +
> > +done:
> > + complete(dbus, message, NULL);
> > + return NULL;
> > +}
> > +
> > static bool p2p_device_get_avail_conns(struct l_dbus *dbus,
> > struct l_dbus_message *message,
> > struct l_dbus_message_builder *builder,
> > @@ -430,6 +616,9 @@ static struct l_dbus_message *p2p_device_get_peers(struct l_dbus *dbus,
> >
> > static void p2p_interface_setup(struct l_dbus_interface *interface)
> > {
> > + l_dbus_interface_property(interface, "Name", 0, "s",
> > + p2p_device_get_name,
> > + p2p_device_set_name);
>
> you don't want to use AUTO_EMIT to make things easier on yourself? As a
> bonus, the previous comment would be fixed auto-magically.
I considered it but thought it doesn't cost us much to trigger the
signal ourselves and then we avoid sending it if the new name is same
as the old one.
Best regards
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH 06/17] p2p: Add device enable/disable logic
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (3 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 05/17] p2p: Add main device settings Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-17 16:41 ` Denis Kenzior
2020-04-03 16:14 ` [PATCH 07/17] p2p: Add the Scan Phase Andrew Zaborowski
` (11 subsequent siblings)
16 siblings, 1 reply; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 5739 bytes --]
Implement the Enabled property on device interface. The P2P device is
currently disabled on startup but automatically enabling the P2P device
can be considered.
---
src/p2p.c | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 136 insertions(+)
diff --git a/src/p2p.c b/src/p2p.c
index ab21239d..fa8e0e55 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -58,13 +58,19 @@
struct p2p_device {
uint64_t wdev_id;
uint8_t addr[6];
+ struct l_genl_family *nl80211;
struct wiphy *wiphy;
unsigned int connections_left;
struct p2p_capability_attr capability;
struct p2p_device_info_attr device_info;
+ uint32_t start_stop_cmd_id;
+ l_dbus_property_complete_cb_t pending_complete;
+ struct l_dbus_message *pending_message;
uint8_t country[3];
struct l_queue *peer_list;
+
+ bool enabled : 1;
};
struct p2p_peer {
@@ -269,6 +275,78 @@ static void p2p_peer_put(void *user_data)
p2p_peer_free(peer);
}
+static void p2p_device_enable_cb(struct l_genl_msg *msg, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ int error = l_genl_msg_get_error(msg);
+ struct l_dbus_message *message = dev->pending_message;
+
+ l_debug("START/STOP_P2P_DEVICE: %s (%i)", strerror(-error), -error);
+
+ if (error)
+ goto done;
+
+ dev->enabled = !dev->enabled;
+
+ if (!message)
+ l_dbus_property_changed(dbus_get_bus(),
+ p2p_device_get_path(dev),
+ IWD_P2P_INTERFACE, "Enabled");
+
+done:
+ if (message) {
+ dev->pending_complete(dbus_get_bus(), message,
+ error ? dbus_error_failed(message) :
+ NULL);
+ dev->pending_message = NULL;
+ dev->pending_complete = NULL;
+ }
+}
+
+static void p2p_device_enable_destroy(void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ dev->start_stop_cmd_id = 0;
+}
+
+static bool p2p_device_start_stop(struct p2p_device *dev,
+ l_dbus_property_complete_cb_t complete,
+ struct l_dbus_message *message)
+{
+ struct l_genl_msg *cmd;
+
+ if (!dev->enabled)
+ cmd = l_genl_msg_new_sized(NL80211_CMD_START_P2P_DEVICE, 16);
+ else
+ cmd = l_genl_msg_new_sized(NL80211_CMD_STOP_P2P_DEVICE, 16);
+
+ l_genl_msg_append_attr(cmd, NL80211_ATTR_WDEV, 8, &dev->wdev_id);
+
+ dev->start_stop_cmd_id = l_genl_family_send(dev->nl80211, cmd,
+ p2p_device_enable_cb, dev,
+ p2p_device_enable_destroy);
+ if (!dev->start_stop_cmd_id) {
+ l_genl_msg_unref(cmd);
+ complete(dbus_get_bus(), message, dbus_error_failed(message));
+ return true;
+ }
+
+ dev->pending_message = message;
+ dev->pending_complete = complete;
+
+ if (dev->enabled) {
+ /*
+ * Stopping the P2P device, drop all peers as we can't start
+ * new connections from now on.
+ */
+ l_queue_destroy(dev->peer_list, p2p_peer_put);
+ dev->peer_list = NULL;
+ }
+
+ return true;
+}
+
struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
bool create)
{
@@ -350,6 +428,7 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
dev = l_new(struct p2p_device, 1);
dev->wdev_id = *wdev_id;
memcpy(dev->addr, ifaddr, ETH_ALEN);
+ dev->nl80211 = l_genl_family_new(iwd_get_genl(), NL80211_GENL_NAME);
dev->wiphy = wiphy;
gethostname(hostname, sizeof(hostname));
dev->connections_left = 1;
@@ -510,8 +589,23 @@ static void p2p_device_free(void *user_data)
{
struct p2p_device *dev = user_data;
+ if (dev->pending_message) {
+ struct l_dbus_message *reply =
+ dbus_error_aborted(dev->pending_message);
+
+ if (dev->pending_complete)
+ dev->pending_complete(dbus_get_bus(),
+ dev->pending_message, reply);
+ else
+ dbus_pending_reply(&dev->pending_message, reply);
+
+ dev->pending_message = NULL;
+ dev->pending_complete = NULL;
+ }
+
l_dbus_unregister_object(dbus_get_bus(), p2p_device_get_path(dev));
l_queue_destroy(dev->peer_list, p2p_peer_put);
+ l_genl_family_free(dev->nl80211); /* Cancels dev->start_stop_cmd_id */
l_free(dev);
}
@@ -524,6 +618,45 @@ bool p2p_device_destroy(struct p2p_device *dev)
return true;
}
+static bool p2p_device_get_enabled(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_builder *builder,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ bool enabled = dev->enabled;
+
+ l_dbus_message_builder_append_basic(builder, 'b', &enabled);
+
+ return true;
+}
+
+static struct l_dbus_message *p2p_device_set_enabled(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ struct l_dbus_message_iter *new_value,
+ l_dbus_property_complete_cb_t complete,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ bool new_enabled;
+
+ if (!l_dbus_message_iter_get_variant(new_value, "b", &new_enabled))
+ return dbus_error_invalid_args(message);
+
+ if (dev->start_stop_cmd_id || dev->pending_message)
+ return dbus_error_busy(message);
+
+ if (dev->enabled == new_enabled) {
+ complete(dbus, message, NULL);
+ return NULL;
+ }
+
+ if (!p2p_device_start_stop(dev, complete, message))
+ return dbus_error_failed(message);
+
+ return NULL;
+}
+
static bool p2p_device_get_name(struct l_dbus *dbus,
struct l_dbus_message *message,
struct l_dbus_message_builder *builder,
@@ -616,6 +749,9 @@ static struct l_dbus_message *p2p_device_get_peers(struct l_dbus *dbus,
static void p2p_interface_setup(struct l_dbus_interface *interface)
{
+ l_dbus_interface_property(interface, "Enabled", 0, "b",
+ p2p_device_get_enabled,
+ p2p_device_set_enabled);
l_dbus_interface_property(interface, "Name", 0, "s",
p2p_device_get_name,
p2p_device_set_name);
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* Re: [PATCH 06/17] p2p: Add device enable/disable logic
2020-04-03 16:14 ` [PATCH 06/17] p2p: Add device enable/disable logic Andrew Zaborowski
@ 2020-04-17 16:41 ` Denis Kenzior
2020-04-25 8:45 ` Andrew Zaborowski
0 siblings, 1 reply; 28+ messages in thread
From: Denis Kenzior @ 2020-04-17 16:41 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 6656 bytes --]
Hi Andrew,
On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> Implement the Enabled property on device interface. The P2P device is
> currently disabled on startup but automatically enabling the P2P device
> can be considered.
> ---
> src/p2p.c | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 136 insertions(+)
>
> diff --git a/src/p2p.c b/src/p2p.c
> index ab21239d..fa8e0e55 100644
> --- a/src/p2p.c
> +++ b/src/p2p.c
> @@ -58,13 +58,19 @@
> struct p2p_device {
> uint64_t wdev_id;
> uint8_t addr[6];
> + struct l_genl_family *nl80211;
> struct wiphy *wiphy;
> unsigned int connections_left;
> struct p2p_capability_attr capability;
> struct p2p_device_info_attr device_info;
> + uint32_t start_stop_cmd_id;
> + l_dbus_property_complete_cb_t pending_complete;
> + struct l_dbus_message *pending_message;
>
> uint8_t country[3];
> struct l_queue *peer_list;
> +
> + bool enabled : 1;
> };
>
> struct p2p_peer {
> @@ -269,6 +275,78 @@ static void p2p_peer_put(void *user_data)
> p2p_peer_free(peer);
> }
>
> +static void p2p_device_enable_cb(struct l_genl_msg *msg, void *user_data)
> +{
> + struct p2p_device *dev = user_data;
> + int error = l_genl_msg_get_error(msg);
> + struct l_dbus_message *message = dev->pending_message;
> +
> + l_debug("START/STOP_P2P_DEVICE: %s (%i)", strerror(-error), -error);
> +
> + if (error)
> + goto done;
> +
> + dev->enabled = !dev->enabled;
> +
> + if (!message)
> + l_dbus_property_changed(dbus_get_bus(),
> + p2p_device_get_path(dev),
> + IWD_P2P_INTERFACE, "Enabled");
Whats this doing? Shouldn't the property always be emitted?
> +
> +done:
> + if (message) {
> + dev->pending_complete(dbus_get_bus(), message,
> + error ? dbus_error_failed(message) :
> + NULL);
> + dev->pending_message = NULL;
> + dev->pending_complete = NULL;
> + }
What this is doing is also not quite clear? Are you going to be
invoking this outside the D-Bus path?
> +}
> +
> +static void p2p_device_enable_destroy(void *user_data)
> +{
> + struct p2p_device *dev = user_data;
> +
> + dev->start_stop_cmd_id = 0;
> +}
> +
> +static bool p2p_device_start_stop(struct p2p_device *dev,
> + l_dbus_property_complete_cb_t complete,
> + struct l_dbus_message *message)
> +{
> + struct l_genl_msg *cmd;
> +
> + if (!dev->enabled)
> + cmd = l_genl_msg_new_sized(NL80211_CMD_START_P2P_DEVICE, 16);
> + else
> + cmd = l_genl_msg_new_sized(NL80211_CMD_STOP_P2P_DEVICE, 16);
> +
> + l_genl_msg_append_attr(cmd, NL80211_ATTR_WDEV, 8, &dev->wdev_id);
> +
> + dev->start_stop_cmd_id = l_genl_family_send(dev->nl80211, cmd,
> + p2p_device_enable_cb, dev,
> + p2p_device_enable_destroy);
> + if (!dev->start_stop_cmd_id) {
> + l_genl_msg_unref(cmd);
> + complete(dbus_get_bus(), message, dbus_error_failed(message));
> + return true;
> + }
> +
> + dev->pending_message = message;
> + dev->pending_complete = complete;
> +
> + if (dev->enabled) {
> + /*
> + * Stopping the P2P device, drop all peers as we can't start
> + * new connections from now on.
> + */
> + l_queue_destroy(dev->peer_list, p2p_peer_put);
> + dev->peer_list = NULL;
> + }
> +
> + return true;
> +}
Note that this function always returns true...
> +
> struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> bool create)
> {
> @@ -350,6 +428,7 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> dev = l_new(struct p2p_device, 1);
> dev->wdev_id = *wdev_id;
> memcpy(dev->addr, ifaddr, ETH_ALEN);
> + dev->nl80211 = l_genl_family_new(iwd_get_genl(), NL80211_GENL_NAME);
> dev->wiphy = wiphy;
> gethostname(hostname, sizeof(hostname));
> dev->connections_left = 1;
> @@ -510,8 +589,23 @@ static void p2p_device_free(void *user_data)
> {
> struct p2p_device *dev = user_data;
>
> + if (dev->pending_message) {
> + struct l_dbus_message *reply =
> + dbus_error_aborted(dev->pending_message);
> +
> + if (dev->pending_complete)
Can this ever be NULL? I checked and at least in this series it doesn't
seem to be the case...
> + dev->pending_complete(dbus_get_bus(),
> + dev->pending_message, reply);
> + else
> + dbus_pending_reply(&dev->pending_message, reply);
> +
> + dev->pending_message = NULL;
> + dev->pending_complete = NULL;
> + }
> +
> l_dbus_unregister_object(dbus_get_bus(), p2p_device_get_path(dev));
> l_queue_destroy(dev->peer_list, p2p_peer_put);
> + l_genl_family_free(dev->nl80211); /* Cancels dev->start_stop_cmd_id */
> l_free(dev);
> }
>
> @@ -524,6 +618,45 @@ bool p2p_device_destroy(struct p2p_device *dev)
> return true;
> }
>
> +static bool p2p_device_get_enabled(struct l_dbus *dbus,
> + struct l_dbus_message *message,
> + struct l_dbus_message_builder *builder,
> + void *user_data)
> +{
> + struct p2p_device *dev = user_data;
> + bool enabled = dev->enabled;
> +
> + l_dbus_message_builder_append_basic(builder, 'b', &enabled);
> +
> + return true;
> +}
> +
> +static struct l_dbus_message *p2p_device_set_enabled(struct l_dbus *dbus,
> + struct l_dbus_message *message,
> + struct l_dbus_message_iter *new_value,
> + l_dbus_property_complete_cb_t complete,
> + void *user_data)
> +{
> + struct p2p_device *dev = user_data;
> + bool new_enabled;
> +
> + if (!l_dbus_message_iter_get_variant(new_value, "b", &new_enabled))
> + return dbus_error_invalid_args(message);
> +
> + if (dev->start_stop_cmd_id || dev->pending_message)
> + return dbus_error_busy(message);
> +
> + if (dev->enabled == new_enabled) {
> + complete(dbus, message, NULL);
> + return NULL;
> + }
> +
> + if (!p2p_device_start_stop(dev, complete, message))
> + return dbus_error_failed(message);
This can never happen? p2p_device_start_stop always returns true...
> +
> + return NULL;
> +}
> +
> static bool p2p_device_get_name(struct l_dbus *dbus,
> struct l_dbus_message *message,
> struct l_dbus_message_builder *builder,
> @@ -616,6 +749,9 @@ static struct l_dbus_message *p2p_device_get_peers(struct l_dbus *dbus,
>
> static void p2p_interface_setup(struct l_dbus_interface *interface)
> {
> + l_dbus_interface_property(interface, "Enabled", 0, "b",
> + p2p_device_get_enabled,
> + p2p_device_set_enabled);
> l_dbus_interface_property(interface, "Name", 0, "s",
> p2p_device_get_name,
> p2p_device_set_name);
>
Regards,
-Denis
^ permalink raw reply [flat|nested] 28+ messages in thread* Re: [PATCH 06/17] p2p: Add device enable/disable logic
2020-04-17 16:41 ` Denis Kenzior
@ 2020-04-25 8:45 ` Andrew Zaborowski
0 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-25 8:45 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 5682 bytes --]
Hi Denis,
I forgot to reply to this email.
On Fri, 17 Apr 2020 at 18:41, Denis Kenzior <denkenz@gmail.com> wrote:
> On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> > Implement the Enabled property on device interface. The P2P device is
> > currently disabled on startup but automatically enabling the P2P device
> > can be considered.
> > ---
> > src/p2p.c | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > 1 file changed, 136 insertions(+)
> >
> > diff --git a/src/p2p.c b/src/p2p.c
> > index ab21239d..fa8e0e55 100644
> > --- a/src/p2p.c
> > +++ b/src/p2p.c
> > @@ -58,13 +58,19 @@
> > struct p2p_device {
> > uint64_t wdev_id;
> > uint8_t addr[6];
> > + struct l_genl_family *nl80211;
> > struct wiphy *wiphy;
> > unsigned int connections_left;
> > struct p2p_capability_attr capability;
> > struct p2p_device_info_attr device_info;
> > + uint32_t start_stop_cmd_id;
> > + l_dbus_property_complete_cb_t pending_complete;
> > + struct l_dbus_message *pending_message;
> >
> > uint8_t country[3];
> > struct l_queue *peer_list;
> > +
> > + bool enabled : 1;
> > };
> >
> > struct p2p_peer {
> > @@ -269,6 +275,78 @@ static void p2p_peer_put(void *user_data)
> > p2p_peer_free(peer);
> > }
> >
> > +static void p2p_device_enable_cb(struct l_genl_msg *msg, void *user_data)
> > +{
> > + struct p2p_device *dev = user_data;
> > + int error = l_genl_msg_get_error(msg);
> > + struct l_dbus_message *message = dev->pending_message;
> > +
> > + l_debug("START/STOP_P2P_DEVICE: %s (%i)", strerror(-error), -error);
> > +
> > + if (error)
> > + goto done;
> > +
> > + dev->enabled = !dev->enabled;
> > +
> > + if (!message)
> > + l_dbus_property_changed(dbus_get_bus(),
> > + p2p_device_get_path(dev),
> > + IWD_P2P_INTERFACE, "Enabled");
>
> Whats this doing? Shouldn't the property always be emitted?
Yeah, I'm not sure how this was supposed to work.
>
> > +
> > +done:
> > + if (message) {
> > + dev->pending_complete(dbus_get_bus(), message,
> > + error ? dbus_error_failed(message) :
> > + NULL);
> > + dev->pending_message = NULL;
> > + dev->pending_complete = NULL;
> > + }
>
> What this is doing is also not quite clear? Are you going to be
> invoking this outside the D-Bus path?
Initially I was automatically enabling P2P when the interface was
created, now I removed the condition here.
>
> > +}
> > +
> > +static void p2p_device_enable_destroy(void *user_data)
> > +{
> > + struct p2p_device *dev = user_data;
> > +
> > + dev->start_stop_cmd_id = 0;
> > +}
> > +
> > +static bool p2p_device_start_stop(struct p2p_device *dev,
> > + l_dbus_property_complete_cb_t complete,
> > + struct l_dbus_message *message)
> > +{
> > + struct l_genl_msg *cmd;
> > +
> > + if (!dev->enabled)
> > + cmd = l_genl_msg_new_sized(NL80211_CMD_START_P2P_DEVICE, 16);
> > + else
> > + cmd = l_genl_msg_new_sized(NL80211_CMD_STOP_P2P_DEVICE, 16);
> > +
> > + l_genl_msg_append_attr(cmd, NL80211_ATTR_WDEV, 8, &dev->wdev_id);
> > +
> > + dev->start_stop_cmd_id = l_genl_family_send(dev->nl80211, cmd,
> > + p2p_device_enable_cb, dev,
> > + p2p_device_enable_destroy);
> > + if (!dev->start_stop_cmd_id) {
> > + l_genl_msg_unref(cmd);
> > + complete(dbus_get_bus(), message, dbus_error_failed(message));
> > + return true;
> > + }
> > +
> > + dev->pending_message = message;
> > + dev->pending_complete = complete;
> > +
> > + if (dev->enabled) {
> > + /*
> > + * Stopping the P2P device, drop all peers as we can't start
> > + * new connections from now on.
> > + */
> > + l_queue_destroy(dev->peer_list, p2p_peer_put);
> > + dev->peer_list = NULL;
> > + }
> > +
> > + return true;
> > +}
>
> Note that this function always returns true...
Right, I could have removed the return value when I removed the
automatic enabling of P2P.
>
> > +
> > struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> > bool create)
> > {
> > @@ -350,6 +428,7 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
> > dev = l_new(struct p2p_device, 1);
> > dev->wdev_id = *wdev_id;
> > memcpy(dev->addr, ifaddr, ETH_ALEN);
> > + dev->nl80211 = l_genl_family_new(iwd_get_genl(), NL80211_GENL_NAME);
> > dev->wiphy = wiphy;
> > gethostname(hostname, sizeof(hostname));
> > dev->connections_left = 1;
> > @@ -510,8 +589,23 @@ static void p2p_device_free(void *user_data)
> > {
> > struct p2p_device *dev = user_data;
> >
> > + if (dev->pending_message) {
> > + struct l_dbus_message *reply =
> > + dbus_error_aborted(dev->pending_message);
> > +
> > + if (dev->pending_complete)
>
> Can this ever be NULL? I checked and at least in this series it doesn't
> seem to be the case...
Right. I think this is from when I was storing the Connect/Disconnect
messages in pending_message.
Best regards
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH 07/17] p2p: Add the Scan Phase
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (4 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 06/17] p2p: Add device enable/disable logic Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-17 17:27 ` Denis Kenzior
2020-04-03 16:14 ` [PATCH 08/17] p2p: Add the Listen State Andrew Zaborowski
` (10 subsequent siblings)
16 siblings, 1 reply; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 17807 bytes --]
Add some of the Device Discovery logic and the DBus API. Device
Discovery is documented as having three states: the Scan Phase, the Find
Phase and the Listen State.
This patch adds the Scan Phase and the next patch adds the Listen State,
which will happen sequentially in a loop until discovery is stopped.
The Find Phase, which is documented as happening at the beginning of the
Discovery Phase, is incorporated into the Scan Phases. The difference
between the two is that Find Phase scans all of the supported channels
while the Scan Phase only scans the three "social" channels. In
practical terms the Find Phase would discover existing groups, which may
operate on any channel, while the Scan Phase will only discover P2P
Devices -- peers that are not in a group yet. To cover existing groups,
we add a few "non-social" channels to each of our active scans
implementing the Scan Phases.
---
src/p2p.c | 460 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 460 insertions(+)
diff --git a/src/p2p.c b/src/p2p.c
index fa8e0e55..de70d1a8 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -68,20 +68,43 @@ struct p2p_device {
struct l_dbus_message *pending_message;
uint8_t country[3];
+ uint8_t oper_class;
+ uint32_t listen_channel;
+ uint32_t scan_id;
+ unsigned int chans_per_scan;
+ unsigned int scan_chan_idx;
+ struct l_queue *discovery_users;
struct l_queue *peer_list;
bool enabled : 1;
};
+struct p2p_discovery_user {
+ char *client;
+ struct p2p_device *dev;
+ unsigned int disconnect_watch;
+};
+
struct p2p_peer {
struct scan_bss *bss;
struct p2p_device *dev;
+ struct wsc_dbus wsc;
char *name;
struct wsc_primary_device_type primary_device_type;
+ const uint8_t *device_addr;
+ /* Whether peer is currently a GO */
+ bool group;
};
static struct l_queue *p2p_device_list;
+/*
+ * For now we only scan the common 2.4GHz channels, to be replaced with
+ * a query of actual allowed channels per band and reg-domain.
+ */
+static const int channels_social[] = { 1, 6, 11 };
+static const int channels_scan_2_4_other[] = { 2, 3, 4, 5, 7, 8, 9, 10 };
+
struct device_type_category_info {
char *category_str;
unsigned int subcategory_max;
@@ -245,6 +268,32 @@ static const char *p2p_device_get_path(const struct p2p_device *dev)
return wiphy_get_path(dev->wiphy);
}
+static bool p2p_discovery_user_match(const void *a, const void *b)
+{
+ const struct p2p_discovery_user *user = a;
+
+ return !strcmp(user->client, b);
+}
+
+static void p2p_discovery_user_free(void *data)
+{
+ struct p2p_discovery_user *user = data;
+
+ if (user->disconnect_watch)
+ l_dbus_remove_watch(dbus_get_bus(), user->disconnect_watch);
+
+ l_free(user->client);
+ l_free(user);
+}
+
+static bool p2p_peer_match(const void *a, const void *b)
+{
+ const struct p2p_peer *peer = a;
+ const uint8_t *addr = b;
+
+ return !memcmp(peer->bss->addr, addr, 6);
+}
+
static const char *p2p_peer_get_path(const struct p2p_peer *peer)
{
static char path[256];
@@ -275,6 +324,326 @@ static void p2p_peer_put(void *user_data)
p2p_peer_free(peer);
}
+/* TODO: convert to iovecs */
+static uint8_t *p2p_build_scan_ies(struct p2p_device *dev, uint8_t *buf,
+ size_t buf_len, size_t *out_len)
+{
+ struct p2p_probe_req p2p_info = {};
+ struct wsc_probe_request wsc_info = {};
+ L_AUTO_FREE_VAR(uint8_t *, p2p_ie) = NULL;
+ size_t p2p_ie_size;
+ uint8_t *wsc_data;
+ size_t wsc_data_size;
+ L_AUTO_FREE_VAR(uint8_t *, wsc_ie) = NULL;
+ size_t wsc_ie_size;
+
+ p2p_info.capability = dev->capability;
+ memcpy(p2p_info.listen_channel.country, dev->country, 3);
+ p2p_info.listen_channel.oper_class = dev->oper_class;
+ p2p_info.listen_channel.channel_num = dev->listen_channel;
+
+ /*
+ * Note that through an attribute we can also request Group Owners
+ * to send us info on clients within their groups and could also
+ * show those on D-Bus. Doesn't seem useful at this time but may
+ * be desired at some point.
+ */
+
+ p2p_ie = p2p_build_probe_req(&p2p_info, &p2p_ie_size);
+ if (!p2p_ie)
+ return NULL;
+
+ wsc_info.version2 = true;
+ wsc_info.request_type = WSC_REQUEST_TYPE_ENROLLEE_INFO;
+ wsc_info.config_methods = dev->device_info.wsc_config_methods;
+
+ if (!wsc_uuid_from_addr(dev->addr, wsc_info.uuid_e))
+ return NULL;
+
+ wsc_info.primary_device_type = dev->device_info.primary_device_type;
+ wsc_info.rf_bands = WSC_RF_BAND_2_4_GHZ;
+ wsc_info.association_state = WSC_ASSOCIATION_STATE_NOT_ASSOCIATED;
+ wsc_info.configuration_error = WSC_CONFIGURATION_ERROR_NO_ERROR;
+ wsc_info.device_password_id = WSC_DEVICE_PASSWORD_ID_DEFAULT;
+ l_strlcpy(wsc_info.device_name, dev->device_info.device_name,
+ sizeof(wsc_info.device_name));
+
+ wsc_data = wsc_build_probe_request(&wsc_info, &wsc_data_size);
+ if (!wsc_data)
+ return NULL;
+
+ wsc_ie = ie_tlv_encapsulate_wsc_payload(wsc_data, wsc_data_size,
+ &wsc_ie_size);
+ l_free(wsc_data);
+
+ if (!wsc_ie)
+ return NULL;
+
+ /* WFD and other service IEs go here */
+
+ if (buf_len < wsc_ie_size + p2p_ie_size)
+ return NULL;
+
+ memcpy(buf + 0, wsc_ie, wsc_ie_size);
+ memcpy(buf + wsc_ie_size, p2p_ie, p2p_ie_size);
+ *out_len = wsc_ie_size + p2p_ie_size;
+ return buf;
+}
+
+static void p2p_scan_destroy(void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ dev->scan_id = 0;
+}
+
+#define CHANS_PER_SCAN_INITIAL 2
+#define CHANS_PER_SCAN 2
+
+static bool p2p_device_peer_add(struct p2p_device *dev, struct p2p_peer *peer)
+{
+ if (!strlen(peer->name) || !l_utf8_validate(
+ peer->name, strlen(peer->name), NULL)) {
+ l_debug("Device name doesn't validate for bssid %s",
+ util_address_to_string(peer->bss->addr));
+ return false;
+ }
+
+ if (!l_dbus_object_add_interface(dbus_get_bus(),
+ p2p_peer_get_path(peer),
+ IWD_P2P_PEER_INTERFACE, peer)) {
+ l_debug("Unable to add the %s interface to %s",
+ IWD_P2P_PEER_INTERFACE, p2p_peer_get_path(peer));
+ return false;
+ }
+
+ if (!l_dbus_object_add_interface(dbus_get_bus(),
+ p2p_peer_get_path(peer),
+ L_DBUS_INTERFACE_PROPERTIES,
+ NULL)) {
+ l_dbus_unregister_object(dbus_get_bus(),
+ p2p_peer_get_path(peer));
+ l_debug("Unable to add the %s interface to %s",
+ L_DBUS_INTERFACE_PROPERTIES, p2p_peer_get_path(peer));
+ return false;
+ }
+
+ l_queue_push_tail(dev->peer_list, peer);
+
+ return true;
+}
+
+struct p2p_peer_move_data {
+ struct l_queue *new_list;
+ uint64_t now;
+};
+
+static bool p2p_peer_move_recent(void *data, void *user_data)
+{
+ struct p2p_peer *peer = data;
+ struct p2p_peer_move_data *move_data = user_data;
+
+ if (move_data->now > peer->bss->time_stamp + 30 * L_USEC_PER_SEC)
+ return false; /* Old, keep on the list */
+
+ /* Recently seen or currently connected, move to the new list */
+ l_queue_push_tail(move_data->new_list, peer);
+ return true;
+}
+
+static bool p2p_peer_update_existing(struct scan_bss *bss,
+ struct l_queue *old_list,
+ struct l_queue *new_list)
+{
+ struct p2p_peer *peer;
+
+ peer = l_queue_remove_if(old_list, p2p_peer_match, bss->addr);
+ if (!peer)
+ return false;
+
+ /*
+ * We've seen this peer already, only update the scan_bss object.
+ * Do we need to update DBus properties?
+ */
+ scan_bss_free(peer->bss);
+ peer->bss = bss;
+
+ l_queue_push_tail(new_list, peer);
+ return true;
+}
+
+static bool p2p_scan_notify(int err, struct l_queue *bss_list,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ const struct l_queue_entry *entry;
+ struct l_queue *old_peer_list = dev->peer_list;
+ struct p2p_peer_move_data move_data;
+
+ if (err) {
+ l_debug("P2P scan failed: %s (%i)", strerror(-err), -err);
+ goto schedule;
+ }
+
+ dev->peer_list = l_queue_new();
+
+ for (entry = l_queue_get_entries(bss_list); entry;
+ entry = entry->next) {
+ struct scan_bss *bss = entry->data;
+ struct p2p_peer *peer;
+
+ if (bss->source_frame != SCAN_BSS_PROBE_RESP ||
+ !bss->p2p_probe_resp_info) {
+ scan_bss_free(bss);
+ continue;
+ }
+
+ if (p2p_peer_update_existing(bss, old_peer_list,
+ dev->peer_list))
+ continue;
+
+ peer = l_new(struct p2p_peer, 1);
+ peer->dev = dev;
+ peer->bss = bss;
+ peer->name = l_strdup(bss->p2p_probe_resp_info->
+ device_info.device_name);
+ peer->primary_device_type =
+ bss->p2p_probe_resp_info->device_info.primary_device_type;
+ peer->group =
+ !!(bss->p2p_probe_resp_info->capability.group_caps &
+ P2P_GROUP_CAP_GO);
+ /*
+ * Both P2P Devices and GOs can send Probe Responses so the
+ * frame's source address may not necessarily be the Device
+ * Address, use what's in the obligatory Device Info.
+ */
+ peer->device_addr =
+ bss->p2p_probe_resp_info->device_info.device_addr;
+
+ if (!p2p_device_peer_add(dev, peer))
+ p2p_peer_free(peer);
+ }
+
+ /*
+ * old_peer_list now only contains peers not present in the new
+ * results. Move any peers seen in the last 30 secs to the new
+ * dev->peer_list and unref only the remaining peers.
+ */
+ move_data.new_list = dev->peer_list;
+ move_data.now = l_time_now();
+ l_queue_foreach_remove(old_peer_list, p2p_peer_move_recent, &move_data);
+ l_queue_destroy(old_peer_list, p2p_peer_put);
+ l_queue_destroy(bss_list, NULL);
+
+schedule:
+ /* TODO: move to listen state */
+ return true;
+}
+
+static bool p2p_device_scan_start(struct p2p_device *dev)
+{
+ struct scan_parameters params = {};
+ uint8_t buf[256];
+ unsigned int i;
+
+ params.extra_ie = p2p_build_scan_ies(dev, buf, sizeof(buf),
+ ¶ms.extra_ie_size);
+ L_WARN_ON(!params.extra_ie);
+ params.flush = true;
+ /* P2P Wildcard SSID because we don't need legacy networks to reply */
+ params.ssid = "DIRECT-";
+ /*
+ * Must send probe requests at 6Mb/s, OFDM only. The no-CCK rates
+ * flag forces the drivers to do exactly this for 2.4GHz frames.
+ *
+ * "- P2P Devices shall not use 11b rates (1, 2, 5.5, 11 Mbps) for data
+ * and management frames except:
+ * * Probe Request frames sent to both P2P Devices and non-P2P
+ * Devices.
+ * - P2P Devices shall not respond to Probe Request frames that indicate
+ * support for 11b rates only.
+ * Note 1 - This means that the P2P Group Owner transmits Beacon frames
+ * using OFDM.
+ * Note 2 - This means that the P2P Group Owner transmits Probe Response
+ * frames using OFDM, including frames sent in response to Probe
+ * Requests received at 11b rates from non 11b-only devices.
+ * Note 3 - P2P Devices shall not include 11b rates in the list of
+ * supported rates in Probe Request frame intended only for P2P Devices.
+ * 11b rates may be included in the list of supported rates in Probe
+ * Request frames intended for both P2P Devices and non-P2P Devices."
+ */
+ params.no_cck_rates = true;
+ params.freqs = scan_freq_set_new();
+
+ for (i = 0; i < L_ARRAY_SIZE(channels_social); i++) {
+ int chan = channels_social[i];
+ uint32_t freq = scan_channel_to_freq(chan, SCAN_BAND_2_4_GHZ);
+
+ scan_freq_set_add(params.freqs, freq);
+ }
+
+ /*
+ * Instead of doing a single Scan Phase at the beginning of the Device
+ * Discovery and then strictly a Find Phase loop as defined in the
+ * spec, mix both to keep watching for P2P groups on the non-social
+ * channels, slowly going through a few channels@a time in each
+ * Scan State iteration. Scan dev->chans_per_scan channels each time,
+ * use dev->scan_chan_idx to keep track of which channels we've
+ * visited recently.
+ */
+ for (i = 0; i < dev->chans_per_scan; i++) {
+ int idx = dev->scan_chan_idx++;
+ int chan = channels_scan_2_4_other[idx];
+ uint32_t freq = scan_channel_to_freq(chan, SCAN_BAND_2_4_GHZ);
+
+ if (dev->scan_chan_idx >=
+ L_ARRAY_SIZE(channels_scan_2_4_other)) {
+ dev->scan_chan_idx = 0;
+ /*
+ * Do fewer channels per scan after we've initially
+ * gone through the 2.4 band.
+ */
+ dev->chans_per_scan = CHANS_PER_SCAN;
+ }
+
+ scan_freq_set_add(params.freqs, freq);
+ }
+
+ dev->scan_id = scan_active_full(dev->wdev_id, ¶ms, NULL,
+ p2p_scan_notify, dev, p2p_scan_destroy);
+ scan_freq_set_free(params.freqs);
+
+ return dev->scan_id != 0;
+}
+
+static void p2p_device_discovery_start(struct p2p_device *dev)
+{
+ if (dev->scan_id)
+ return;
+
+ dev->chans_per_scan = CHANS_PER_SCAN_INITIAL;
+ dev->scan_chan_idx = 0;
+
+ /*
+ * 3.1.2.1.1: "The Listen Channel shall be chosen at the beginning of
+ * the In-band Device Discovery"
+ *
+ * (Unless we're waiting for a GO Negotiation Request from a peer on
+ * a known channel)
+ */
+ dev->listen_channel = channels_social[l_getrandom_uint32() %
+ L_ARRAY_SIZE(channels_social)];
+ dev->oper_class = 81;
+
+ p2p_device_scan_start(dev);
+}
+
+static void p2p_device_discovery_stop(struct p2p_device *dev)
+{
+ if (dev->scan_id)
+ scan_cancel(dev->wdev_id, dev->scan_id);
+}
+
static void p2p_device_enable_cb(struct l_genl_msg *msg, void *user_data)
{
struct p2p_device *dev = user_data;
@@ -293,6 +662,9 @@ static void p2p_device_enable_cb(struct l_genl_msg *msg, void *user_data)
p2p_device_get_path(dev),
IWD_P2P_INTERFACE, "Enabled");
+ if (dev->enabled && !l_queue_isempty(dev->discovery_users))
+ p2p_device_discovery_start(dev);
+
done:
if (message) {
dev->pending_complete(dbus_get_bus(), message,
@@ -316,6 +688,9 @@ static bool p2p_device_start_stop(struct p2p_device *dev,
{
struct l_genl_msg *cmd;
+ if (dev->enabled)
+ p2p_device_discovery_stop(dev);
+
if (!dev->enabled)
cmd = l_genl_msg_new_sized(NL80211_CMD_START_P2P_DEVICE, 16);
else
@@ -576,6 +951,8 @@ struct p2p_device *p2p_device_update_from_genl(struct l_genl_msg *msg,
l_debug("Created P2P device %" PRIx64, dev->wdev_id);
+ scan_wdev_add(dev->wdev_id);
+
if (!l_dbus_object_add_interface(dbus_get_bus(),
p2p_device_get_path(dev),
IWD_P2P_INTERFACE, dev))
@@ -603,9 +980,12 @@ static void p2p_device_free(void *user_data)
dev->pending_complete = NULL;
}
+ p2p_device_discovery_stop(dev);
l_dbus_unregister_object(dbus_get_bus(), p2p_device_get_path(dev));
l_queue_destroy(dev->peer_list, p2p_peer_put);
+ l_queue_destroy(dev->discovery_users, p2p_discovery_user_free);
l_genl_family_free(dev->nl80211); /* Cancels dev->start_stop_cmd_id */
+ scan_wdev_remove(dev->wdev_id);
l_free(dev);
}
@@ -747,6 +1127,82 @@ static struct l_dbus_message *p2p_device_get_peers(struct l_dbus *dbus,
return reply;
}
+static void p2p_device_discovery_disconnect(struct l_dbus *dbus, void *user_data)
+{
+ struct p2p_discovery_user *user = user_data;
+ struct p2p_device *dev = user->dev;
+
+ l_debug("P2P Device Discovery user %s disconnected", user->client);
+
+ l_queue_remove(dev->discovery_users, user);
+ p2p_discovery_user_free(user);
+
+ if (l_queue_isempty(dev->discovery_users))
+ p2p_device_discovery_stop(dev);
+}
+
+static void p2p_device_discovery_destroy(void *user_data)
+{
+ struct p2p_discovery_user *user = user_data;
+
+ user->disconnect_watch = 0;
+}
+
+static struct l_dbus_message *p2p_device_request_discovery(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ struct p2p_discovery_user *user;
+ bool first_user = l_queue_isempty(dev->discovery_users);
+
+ if (!l_dbus_message_get_arguments(message, ""))
+ return dbus_error_invalid_args(message);
+
+ if (l_queue_find(dev->discovery_users, p2p_discovery_user_match,
+ l_dbus_message_get_sender(message)))
+ return dbus_error_already_exists(message);
+
+ user = l_new(struct p2p_discovery_user, 1);
+ user->client = l_strdup(l_dbus_message_get_sender(message));
+ user->dev = dev;
+ user->disconnect_watch = l_dbus_add_disconnect_watch(dbus,
+ user->client,
+ p2p_device_discovery_disconnect,
+ user,
+ p2p_device_discovery_destroy);
+ l_queue_push_tail(dev->discovery_users, user);
+
+ if (first_user && dev->enabled)
+ p2p_device_discovery_start(dev);
+
+ return l_dbus_message_new_method_return(message);
+}
+
+static struct l_dbus_message *p2p_device_release_discovery(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ struct p2p_discovery_user *user;
+
+ if (!l_dbus_message_get_arguments(message, ""))
+ return dbus_error_invalid_args(message);
+
+ user = l_queue_remove_if(dev->discovery_users,
+ p2p_discovery_user_match,
+ l_dbus_message_get_sender(message));
+ if (!user)
+ return dbus_error_not_found(message);
+
+ p2p_discovery_user_free(user);
+
+ if (l_queue_isempty(dev->discovery_users))
+ p2p_device_discovery_stop(dev);
+
+ return l_dbus_message_new_method_return(message);
+}
+
static void p2p_interface_setup(struct l_dbus_interface *interface)
{
l_dbus_interface_property(interface, "Enabled", 0, "b",
@@ -759,6 +1215,10 @@ static void p2p_interface_setup(struct l_dbus_interface *interface)
p2p_device_get_avail_conns, NULL);
l_dbus_interface_method(interface, "GetPeers", 0,
p2p_device_get_peers, "a(on)", "", "peers");
+ l_dbus_interface_method(interface, "RequestDiscovery", 0,
+ p2p_device_request_discovery, "", "");
+ l_dbus_interface_method(interface, "ReleaseDiscovery", 0,
+ p2p_device_release_discovery, "", "");
}
static bool p2p_peer_get_name(struct l_dbus *dbus,
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* Re: [PATCH 07/17] p2p: Add the Scan Phase
2020-04-03 16:14 ` [PATCH 07/17] p2p: Add the Scan Phase Andrew Zaborowski
@ 2020-04-17 17:27 ` Denis Kenzior
0 siblings, 0 replies; 28+ messages in thread
From: Denis Kenzior @ 2020-04-17 17:27 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 1156 bytes --]
Hi Andrew,
On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> Add some of the Device Discovery logic and the DBus API. Device
> Discovery is documented as having three states: the Scan Phase, the Find
> Phase and the Listen State.
>
> This patch adds the Scan Phase and the next patch adds the Listen State,
> which will happen sequentially in a loop until discovery is stopped.
>
> The Find Phase, which is documented as happening at the beginning of the
> Discovery Phase, is incorporated into the Scan Phases. The difference
> between the two is that Find Phase scans all of the supported channels
> while the Scan Phase only scans the three "social" channels. In
> practical terms the Find Phase would discover existing groups, which may
> operate on any channel, while the Scan Phase will only discover P2P
> Devices -- peers that are not in a group yet. To cover existing groups,
> we add a few "non-social" channels to each of our active scans
> implementing the Scan Phases.
> ---
> src/p2p.c | 460 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 1 file changed, 460 insertions(+)
LGTM.
Regards,
-Denis
^ permalink raw reply [flat|nested] 28+ messages in thread
* [PATCH 08/17] p2p: Add the Listen State
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (5 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 07/17] p2p: Add the Scan Phase Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 09/17] p2p: Add the WSC interface on peer DBus objects Andrew Zaborowski
` (9 subsequent siblings)
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 13834 bytes --]
Start a remain-on-channel cmd implementing the Listen State, after each
the Scan Phase implemented as an active scan.
---
src/p2p.c | 371 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 369 insertions(+), 2 deletions(-)
diff --git a/src/p2p.c b/src/p2p.c
index de70d1a8..d0e0d9ac 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -70,9 +70,15 @@ struct p2p_device {
uint8_t country[3];
uint8_t oper_class;
uint32_t listen_channel;
+ unsigned int scan_interval;
+ time_t next_scan_ts;
+ struct l_timeout *scan_timeout;
uint32_t scan_id;
unsigned int chans_per_scan;
unsigned int scan_chan_idx;
+ uint64_t roc_cookie;
+ bool have_roc_cookie;
+ unsigned int listen_duration;
struct l_queue *discovery_users;
struct l_queue *peer_list;
@@ -97,6 +103,7 @@ struct p2p_peer {
};
static struct l_queue *p2p_device_list;
+static uint32_t unicast_watch;
/*
* For now we only scan the common 2.4GHz channels, to be replaced with
@@ -105,6 +112,11 @@ static struct l_queue *p2p_device_list;
static const int channels_social[] = { 1, 6, 11 };
static const int channels_scan_2_4_other[] = { 2, 3, 4, 5, 7, 8, 9, 10 };
+enum {
+ FRAME_GROUP_DEFAULT = 0,
+ FRAME_GROUP_LISTEN,
+};
+
struct device_type_category_info {
char *category_str;
unsigned int subcategory_max;
@@ -397,9 +409,170 @@ static void p2p_scan_destroy(void *user_data)
dev->scan_id = 0;
}
+#define SCAN_INTERVAL_MAX 3
+#define SCAN_INTERVAL_STEP 1
#define CHANS_PER_SCAN_INITIAL 2
#define CHANS_PER_SCAN 2
+static bool p2p_device_scan_start(struct p2p_device *dev);
+static void p2p_device_roc_start(struct p2p_device *dev);
+
+static void p2p_device_roc_timeout(struct l_timeout *timeout, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ l_timeout_remove(dev->scan_timeout);
+
+ if (time(NULL) < dev->next_scan_ts) {
+ /*
+ * dev->scan_timeout destroy function will have been called
+ * by now so it won't overwrite the new timeout set by
+ * p2p_device_roc_start.
+ */
+ p2p_device_roc_start(dev);
+ return;
+ }
+
+ p2p_device_scan_start(dev);
+}
+
+static void p2p_device_roc_cancel(struct p2p_device *dev, uint64_t *cookie,
+ bool *have_cookie, bool frame_tx)
+{
+ struct l_genl_msg *msg;
+ enum nl80211_commands cmd = frame_tx ? NL80211_CMD_FRAME_WAIT_CANCEL :
+ NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL;
+
+ if (!*have_cookie)
+ return;
+
+ l_debug("");
+
+ msg = l_genl_msg_new_sized(cmd, 32);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_WDEV, 8, &dev->wdev_id);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_COOKIE, 8, cookie);
+ l_genl_family_send(dev->nl80211, msg, NULL, NULL, NULL);
+
+ *have_cookie = false;
+}
+
+static void p2p_scan_timeout_destroy(void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ dev->scan_timeout = NULL;
+
+ if (dev->nl80211) {
+ /*
+ * Most likely when the timer expires the ROC period
+ * has finished but send a cancel command to make sure,
+ * as well as handle situations like disabling P2P.
+ */
+ p2p_device_roc_cancel(dev, &dev->roc_cookie,
+ &dev->have_roc_cookie, false);
+ }
+}
+
+static void p2p_device_roc_cb(struct l_genl_msg *msg, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ struct l_genl_attr attr;
+ uint16_t type;
+ uint16_t len;
+ const void *data;
+ int error = l_genl_msg_get_error(msg);
+
+ l_debug("ROC: %s (%i)", strerror(-error), -error);
+
+ if (error)
+ return;
+
+ if (!l_genl_attr_init(&attr, msg))
+ return;
+
+ while (l_genl_attr_next(&attr, &type, &len, &data)) {
+ switch (type) {
+ case NL80211_ATTR_COOKIE:
+ if (len != 8)
+ break;
+
+ dev->roc_cookie = *(const uint64_t *) data;
+ dev->have_roc_cookie = true;
+
+ if (!dev->scan_timeout)
+ p2p_device_roc_cancel(dev, &dev->roc_cookie,
+ &dev->have_roc_cookie,
+ false);
+
+ break;
+ }
+ }
+}
+
+static void p2p_device_roc_start(struct p2p_device *dev)
+{
+ struct l_genl_msg *msg;
+ uint32_t listen_freq;
+ uint32_t duration;
+ uint32_t cmd_id;
+
+ l_debug("");
+
+ /*
+ * One second granularity is fine here because some randomess
+ * is desired and the intervals don't have strictly defined
+ * limits.
+ */
+ duration = (dev->next_scan_ts - time(NULL)) * 1000;
+
+ if (duration < 200)
+ duration = 200;
+
+ /*
+ * Driver max duration seems to be 5000ms or more for all drivers
+ * except mac80211_hwsim where it is only 1000ms.
+ */
+ if (duration > wiphy_get_max_roc_duration(dev->wiphy))
+ duration = wiphy_get_max_roc_duration(dev->wiphy);
+
+ /*
+ * Some drivers seem to miss fewer frames if we start new requests
+ * often.
+ */
+ if (duration > 1000)
+ duration = 1000;
+
+ listen_freq = scan_channel_to_freq(dev->listen_channel,
+ SCAN_BAND_2_4_GHZ);
+
+ msg = l_genl_msg_new_sized(NL80211_CMD_REMAIN_ON_CHANNEL, 64);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_WDEV, 8, &dev->wdev_id);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_WIPHY_FREQ, 4, &listen_freq);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_DURATION, 4, &duration);
+
+ cmd_id = l_genl_family_send(dev->nl80211, msg, p2p_device_roc_cb, dev,
+ NULL);
+ if (!cmd_id)
+ l_genl_msg_unref(msg);
+
+ /*
+ * Time out after @duration ms independent of whether we were able to
+ * start the ROC command. If we receive the CMD_REMAIN_ON_CHANNEL
+ * event we'll update the timeout to give the ROC command enough time
+ * to finish. On an error or if we time out before the ROC command
+ * even starts, we'll just retry after @duration ms so we don't even
+ * need to handle errors specifically.
+ */
+ dev->scan_timeout = l_timeout_create_ms(duration,
+ p2p_device_roc_timeout, dev,
+ p2p_scan_timeout_destroy);
+ dev->listen_duration = duration;
+ dev->have_roc_cookie = false;
+
+ l_debug("started a ROC command on channel %i for %i ms",
+ (int) dev->listen_channel, (int) duration);
+}
+
static bool p2p_device_peer_add(struct p2p_device *dev, struct p2p_peer *peer)
{
if (!strlen(peer->name) || !l_utf8_validate(
@@ -536,7 +709,32 @@ static bool p2p_scan_notify(int err, struct l_queue *bss_list,
l_queue_destroy(bss_list, NULL);
schedule:
- /* TODO: move to listen state */
+ /*
+ * Calculate interval between now and when we want the next active
+ * scan to start. Keep issuing Remain-on-Channel commands of
+ * maximum duration until it's time to start the new scan.
+ * The listen periods are actually like a passive scan except that
+ * instead of listening for Beacons only, we also look at Probe
+ * Requests and Probe Responses because they, too, carry P2P IEs
+ * with all the information we need about peer devices. Beacons
+ * also do, in case of GOs, but we will already get the same
+ * information from the Probe Responses and (even if we can
+ * receive the beacons in userspace in the first place) we don't
+ * want to handle so many frames.
+ *
+ * According to 3.1.2.1.1 we shall be available in listen state
+ * during Find for at least 500ms continuously at least once in
+ * every 5s. According to 3.1.2.1.3, the Listen State lasts for
+ * between 1 and 3 one-hundred TU Intervals.
+ *
+ * The Search State duration is implementation dependent.
+ */
+ if (dev->scan_interval < SCAN_INTERVAL_MAX)
+ dev->scan_interval += SCAN_INTERVAL_STEP;
+
+ dev->next_scan_ts = time(NULL) + dev->scan_interval;
+
+ p2p_device_roc_start(dev);
return true;
}
@@ -616,11 +814,118 @@ static bool p2p_device_scan_start(struct p2p_device *dev)
return dev->scan_id != 0;
}
+static void p2p_device_probe_cb(const struct mmpdu_header *mpdu,
+ const void *body, size_t body_len,
+ int rssi, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ struct p2p_peer *peer;
+ struct p2p_probe_req p2p_info;
+ struct wsc_probe_request wsc_info;
+ int r;
+ uint8_t *wsc_payload;
+ ssize_t wsc_len;
+ struct scan_bss *bss;
+ struct p2p_channel_attr *channel;
+ enum scan_band band;
+ uint32_t frequency;
+
+ l_debug("");
+
+ if (!dev->scan_timeout && !dev->scan_id)
+ return;
+
+ wsc_payload = ie_tlv_extract_wsc_payload(body, body_len, &wsc_len);
+ if (!wsc_payload) /* Not a P2P Probe Req, ignore */
+ return;
+
+ r = wsc_parse_probe_request(wsc_payload, wsc_len, &wsc_info);
+ l_free(wsc_payload);
+
+ if (r < 0) {
+ l_error("Probe Request WSC IE parse error %s (%i)",
+ strerror(-r), -r);
+ return;
+ }
+
+ r = p2p_parse_probe_req(body, body_len, &p2p_info);
+ if (r < 0) {
+ if (r == -ENOENT) /* Not a P2P Probe Req, ignore */
+ return;
+
+ l_error("Probe Request P2P IE parse error %s (%i)",
+ strerror(-r), -r);
+ return;
+ }
+
+ /*
+ * We don't currently have a use case for replying to Probe Requests
+ * except when waiting for a GO Negotiation Request from our target
+ * peer.
+ */
+
+ /*
+ * The peer's listen frequency may be different from ours.
+ * The Listen Channel attribute is optional but if neither
+ * it nor the Operating Channel are set then we have no way
+ * to contact that peer. Ignore such peers.
+ */
+ if (p2p_info.listen_channel.country[0])
+ channel = &p2p_info.listen_channel;
+ else if (p2p_info.operating_channel.country[0])
+ channel = &p2p_info.operating_channel;
+ else
+ goto p2p_free;
+
+ band = scan_oper_class_to_band((const uint8_t *) channel->country,
+ channel->oper_class);
+ frequency = scan_channel_to_freq(channel->channel_num, band);
+ if (!frequency)
+ goto p2p_free;
+
+ bss = scan_bss_new_from_probe_req(mpdu, body, body_len, frequency,
+ rssi);
+ if (!bss)
+ goto p2p_free;
+
+ bss->time_stamp = l_time_now();
+
+ if (p2p_peer_update_existing(bss, dev->peer_list, dev->peer_list))
+ goto p2p_free;
+
+ peer = l_new(struct p2p_peer, 1);
+ peer->dev = dev;
+ peer->bss = bss;
+ peer->name = l_strdup(wsc_info.device_name);
+ peer->primary_device_type = wsc_info.primary_device_type;
+ peer->group = !!(p2p_info.capability.group_caps & P2P_GROUP_CAP_GO);
+ /*
+ * The Device Info attribute is present conditionally so we can't get
+ * the Device Address from there. In theory only P2P Devices send
+ * out Probe Requests, not P2P GOs, so we assume the source address
+ * is the Device Address.
+ */
+ peer->device_addr = bss->addr;
+
+ if (!p2p_device_peer_add(dev, peer))
+ p2p_peer_free(peer);
+
+ /*
+ * Note: check SSID/BSSID are wildcard values if present and
+ * reply with a Probe Response -- not useful in our current usage
+ * scenarios but required by the spec.
+ */
+
+p2p_free:
+ p2p_clear_probe_req(&p2p_info);
+}
+
static void p2p_device_discovery_start(struct p2p_device *dev)
{
- if (dev->scan_id)
+ if (dev->scan_timeout || dev->scan_id)
return;
+ dev->scan_interval = 1;
dev->chans_per_scan = CHANS_PER_SCAN_INITIAL;
dev->scan_chan_idx = 0;
@@ -635,13 +940,26 @@ static void p2p_device_discovery_start(struct p2p_device *dev)
L_ARRAY_SIZE(channels_social)];
dev->oper_class = 81;
+ frame_watch_add(dev->wdev_id, FRAME_GROUP_LISTEN, 0x0040,
+ (uint8_t *) "", 0, p2p_device_probe_cb, dev, NULL);
+
p2p_device_scan_start(dev);
}
static void p2p_device_discovery_stop(struct p2p_device *dev)
{
+ dev->scan_interval = 0;
+
if (dev->scan_id)
scan_cancel(dev->wdev_id, dev->scan_id);
+
+ if (dev->scan_timeout)
+ l_timeout_remove(dev->scan_timeout);
+
+ p2p_device_roc_cancel(dev, &dev->roc_cookie, &dev->have_roc_cookie,
+ false);
+
+ frame_watch_group_remove(dev->wdev_id, FRAME_GROUP_LISTEN);
}
static void p2p_device_enable_cb(struct l_genl_msg *msg, void *user_data)
@@ -1313,8 +1631,47 @@ static void p2p_peer_interface_setup(struct l_dbus_interface *interface)
p2p_peer_get_connected, NULL);
}
+static void p2p_unicast_notify(struct l_genl_msg *msg, void *user_data)
+{
+ struct p2p_device *dev;
+ uint64_t wdev_id;
+ uint64_t cookie;
+ uint8_t cmd = l_genl_msg_get_command(msg);
+
+ if (nl80211_parse_attrs(msg, NL80211_ATTR_WDEV, &wdev_id,
+ NL80211_ATTR_COOKIE, &cookie,
+ NL80211_ATTR_UNSPEC) < 0)
+ return;
+
+ dev = p2p_device_find(wdev_id);
+ if (!dev)
+ return;
+
+ switch (cmd) {
+ case NL80211_CMD_REMAIN_ON_CHANNEL:
+ if (!dev->have_roc_cookie || cookie != dev->roc_cookie)
+ break;
+
+ if (!dev->scan_timeout)
+ break;
+
+ /*
+ * The Listen phase is actually starting here, update the
+ * timeout so we know more or less when it ends.
+ */
+ l_debug("ROC started");
+ l_timeout_modify_ms(dev->scan_timeout, dev->listen_duration);
+ break;
+ case NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL:
+ /* TODO */
+ break;
+ }
+}
+
static int p2p_init(void)
{
+ struct l_genl *genl = iwd_get_genl();
+
if (!l_dbus_register_interface(dbus_get_bus(),
IWD_P2P_INTERFACE,
p2p_interface_setup,
@@ -1329,6 +1686,12 @@ static int p2p_init(void)
l_error("Unable to register the %s interface",
IWD_P2P_PEER_INTERFACE);
+ unicast_watch = l_genl_add_unicast_watch(genl, NL80211_GENL_NAME,
+ p2p_unicast_notify,
+ NULL, NULL);
+ if (!unicast_watch)
+ l_error("Registering for unicast notification failed");
+
p2p_device_list = l_queue_new();
return 0;
@@ -1336,6 +1699,10 @@ static int p2p_init(void)
static void p2p_exit(void)
{
+ struct l_genl *genl = iwd_get_genl();
+
+ l_genl_remove_unicast_watch(genl, unicast_watch);
+ unicast_watch = 0;
l_dbus_unregister_interface(dbus_get_bus(), IWD_P2P_INTERFACE);
l_dbus_unregister_interface(dbus_get_bus(), IWD_P2P_PEER_INTERFACE);
l_queue_destroy(p2p_device_list, p2p_device_free);
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 09/17] p2p: Add the WSC interface on peer DBus objects
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (6 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 08/17] p2p: Add the Listen State Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 10/17] p2p: Build and send the GO Negotiation Request Andrew Zaborowski
` (8 subsequent siblings)
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 12629 bytes --]
Add net.connman.iwd.SimpleConfiguration interfaces to peer objects on
DBus and handle method calls. Building and transmitting the actual
action frames to start the connection sequence is done in the following
commits.
---
src/p2p.c | 290 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 288 insertions(+), 2 deletions(-)
diff --git a/src/p2p.c b/src/p2p.c
index d0e0d9ac..86d2b3a1 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -82,6 +82,12 @@ struct p2p_device {
struct l_queue *discovery_users;
struct l_queue *peer_list;
+ struct p2p_peer *conn_peer;
+ uint16_t conn_config_method;
+ char *conn_pin;
+ uint8_t conn_addr[6];
+ uint16_t conn_password_id;
+
bool enabled : 1;
};
@@ -332,10 +338,14 @@ static void p2p_peer_put(void *user_data)
{
struct p2p_peer *peer = user_data;
+ /* Removes both interfaces, no need to call wsc_dbus_remove_interface */
l_dbus_unregister_object(dbus_get_bus(), p2p_peer_get_path(peer));
p2p_peer_free(peer);
}
+static void p2p_device_discovery_start(struct p2p_device *dev);
+static void p2p_device_discovery_stop(struct p2p_device *dev);
+
/* TODO: convert to iovecs */
static uint8_t *p2p_build_scan_ies(struct p2p_device *dev, uint8_t *buf,
size_t buf_len, size_t *out_len)
@@ -402,6 +412,61 @@ static uint8_t *p2p_build_scan_ies(struct p2p_device *dev, uint8_t *buf,
return buf;
}
+static void p2p_connection_reset(struct p2p_device *dev)
+{
+ struct p2p_peer *peer = dev->conn_peer;
+
+ if (!peer)
+ return;
+
+ /*
+ * conn_peer is currently not refcounted and we make sure it's always
+ * on the dev->peer_list so we can just drop our reference. Since we
+ * may not have been scanning for a while, don't drop the peer object
+ * now just because it's not been seen in scan results recently, its
+ * age will be checked on the next scan.
+ */
+ dev->conn_peer = NULL;
+ dev->connections_left++;
+
+ if (dev->conn_pin) {
+ explicit_bzero(dev->conn_pin, strlen(dev->conn_pin));
+ l_free(dev->conn_pin);
+ dev->conn_pin = NULL;
+ }
+
+ l_dbus_property_changed(dbus_get_bus(), p2p_device_get_path(dev),
+ IWD_P2P_INTERFACE, "AvailableConnections");
+
+ if (!dev->enabled || (dev->enabled && dev->start_stop_cmd_id)) {
+ /*
+ * The device has been disabled in the mean time, all peers
+ * have been removed except this one. Now it's safe to
+ * drop this peer from the scan results too.
+ */
+ l_queue_destroy(dev->peer_list, p2p_peer_put);
+ dev->peer_list = NULL;
+ }
+
+ if (dev->enabled && !dev->start_stop_cmd_id &&
+ !l_queue_isempty(dev->discovery_users))
+ p2p_device_discovery_start(dev);
+}
+
+static void p2p_connect_failed(struct p2p_device *dev)
+{
+ struct p2p_peer *peer = dev->conn_peer;
+
+ if (!peer)
+ return;
+
+ if (peer->wsc.pending_connect)
+ dbus_pending_reply(&peer->wsc.pending_connect,
+ dbus_error_failed(peer->wsc.pending_connect));
+
+ p2p_connection_reset(dev);
+}
+
static void p2p_scan_destroy(void *user_data)
{
struct p2p_device *dev = user_data;
@@ -409,6 +474,165 @@ static void p2p_scan_destroy(void *user_data)
dev->scan_id = 0;
}
+static void p2p_start_go_negotiation(struct p2p_device *dev)
+{
+ /* TODO: start GO Negotiation */
+}
+
+static void p2p_start_provision_discovery(struct p2p_device *dev)
+{
+ /* TODO: start Provision Discovery */
+}
+
+static bool p2p_peer_get_info(struct p2p_peer *peer,
+ uint16_t *wsc_config_methods,
+ struct p2p_capability_attr **capability)
+{
+ struct wsc_probe_request wsc_info;
+
+ switch (peer->bss->source_frame) {
+ case SCAN_BSS_PROBE_RESP:
+ if (!peer->bss->p2p_probe_resp_info)
+ return false;
+
+ if (wsc_config_methods)
+ *wsc_config_methods = peer->bss->p2p_probe_resp_info->
+ device_info.wsc_config_methods;
+
+ *capability = &peer->bss->p2p_probe_resp_info->capability;
+ return true;
+ case SCAN_BSS_PROBE_REQ:
+ if (!peer->bss->p2p_probe_req_info || !peer->bss->wsc)
+ return false;
+
+ if (wsc_parse_probe_request(peer->bss->wsc, peer->bss->wsc_size,
+ &wsc_info) < 0)
+ return false;
+
+ if (wsc_config_methods)
+ *wsc_config_methods = wsc_info.config_methods;
+
+ *capability = &peer->bss->p2p_probe_req_info->capability;
+ return true;
+ case SCAN_BSS_BEACON:
+ if (!peer->bss->p2p_beacon_info || !peer->bss->wsc)
+ return false;
+
+ if (wsc_parse_probe_request(peer->bss->wsc, peer->bss->wsc_size,
+ &wsc_info) < 0)
+ return false;
+
+ if (wsc_config_methods)
+ *wsc_config_methods = wsc_info.config_methods;
+
+ *capability = &peer->bss->p2p_beacon_info->capability;
+ break;
+ }
+
+ return false;
+}
+
+static void p2p_peer_connect(struct p2p_peer *peer, const char *pin)
+{
+ struct p2p_device *dev = peer->dev;
+ uint16_t wsc_config_methods;
+ struct p2p_capability_attr *capability;
+ struct l_dbus_message *message = peer->wsc.pending_connect;
+ struct l_dbus_message *reply;
+
+ if (dev->conn_peer) {
+ reply = dbus_error_busy(message);
+ goto send_error;
+ }
+
+ /*
+ * Step 1, check if the device indicates it supports our WSC method
+ * and check other flags to make sure a connection is possible.
+ */
+ if (!p2p_peer_get_info(peer, &wsc_config_methods, &capability)) {
+ reply = dbus_error_failed(message);
+ goto send_error;
+ }
+
+ dev->conn_config_method = pin ? WSC_CONFIGURATION_METHOD_KEYPAD :
+ WSC_CONFIGURATION_METHOD_PUSH_BUTTON;
+ dev->conn_password_id = pin ?
+ (strlen(pin) == 4 || wsc_pin_is_checksum_valid(pin) ?
+ WSC_DEVICE_PASSWORD_ID_DEFAULT :
+ WSC_DEVICE_PASSWORD_ID_USER_SPECIFIED) :
+ WSC_DEVICE_PASSWORD_ID_PUSH_BUTTON;
+
+ if (!(wsc_config_methods & dev->conn_config_method)) {
+ reply = dbus_error_not_supported(message);
+ goto send_error;
+ }
+
+ if (capability->device_caps & P2P_DEVICE_CAP_DEVICE_LIMIT) {
+ reply = dbus_error_not_supported(message);
+ goto send_error;
+ }
+
+ if (capability->group_caps & P2P_GROUP_CAP_GROUP_LIMIT) {
+ reply = dbus_error_not_supported(message);
+ goto send_error;
+ }
+
+ if (capability->group_caps & P2P_GROUP_CAP_GROUP_FORMATION) {
+ reply = dbus_error_busy(message);
+ goto send_error;
+ }
+
+ p2p_device_discovery_stop(dev);
+
+ /* Generate the interface address for our P2P-Client connection */
+ wiphy_generate_random_address(dev->wiphy, dev->conn_addr);
+
+ dev->conn_peer = peer; /* No ref counting so just set the pointer */
+ dev->conn_pin = l_strdup(pin);
+ dev->connections_left--;
+ l_dbus_property_changed(dbus_get_bus(), p2p_device_get_path(dev),
+ IWD_P2P_INTERFACE, "AvailableConnections");
+
+ /*
+ * Step 2, if peer is already a GO then send the Provision Discovery
+ * before doing WSC. If it's not then do Provision Discovery
+ * optionally as seems to be required by some implementations, and
+ * start GO negotiation following that.
+ * TODO: Add a AlwaysUsePD config setting.
+ */
+ if (dev->conn_peer->group)
+ p2p_start_provision_discovery(dev);
+ else
+ p2p_start_go_negotiation(dev);
+
+ return;
+
+send_error:
+ dbus_pending_reply(&peer->wsc.pending_connect, reply);
+}
+
+static void p2p_peer_disconnect(struct p2p_peer *peer)
+{
+ struct p2p_device *dev = peer->dev;
+ struct l_dbus_message *message = peer->wsc.pending_cancel;
+ struct l_dbus_message *reply;
+
+ if (dev->conn_peer != peer) {
+ reply = dbus_error_not_connected(message);
+ goto send_reply;
+ }
+
+ if (peer->wsc.pending_connect)
+ dbus_pending_reply(&peer->wsc.pending_connect,
+ dbus_error_aborted(peer->wsc.pending_connect));
+
+ p2p_connection_reset(dev);
+ reply = l_dbus_message_new_method_return(message);
+
+send_reply:
+ dbus_pending_reply(&peer->wsc.pending_cancel, reply);
+}
+
#define SCAN_INTERVAL_MAX 3
#define SCAN_INTERVAL_STEP 1
#define CHANS_PER_SCAN_INITIAL 2
@@ -573,6 +797,29 @@ static void p2p_device_roc_start(struct p2p_device *dev)
(int) dev->listen_channel, (int) duration);
}
+static const char *p2p_peer_wsc_get_path(struct wsc_dbus *wsc)
+{
+ return p2p_peer_get_path(l_container_of(wsc, struct p2p_peer, wsc));
+}
+
+static void p2p_peer_wsc_connect(struct wsc_dbus *wsc, const char *pin)
+{
+ p2p_peer_connect(l_container_of(wsc, struct p2p_peer, wsc), pin);
+}
+
+static void p2p_peer_wsc_cancel(struct wsc_dbus *wsc)
+{
+ p2p_peer_disconnect(l_container_of(wsc, struct p2p_peer, wsc));
+}
+
+static void p2p_peer_wsc_remove(struct wsc_dbus *wsc)
+{
+ /*
+ * The WSC removal is triggered in p2p_peer_put so we call
+ * p2p_peer_free directly from there too.
+ */
+}
+
static bool p2p_device_peer_add(struct p2p_device *dev, struct p2p_peer *peer)
{
if (!strlen(peer->name) || !l_utf8_validate(
@@ -601,6 +848,17 @@ static bool p2p_device_peer_add(struct p2p_device *dev, struct p2p_peer *peer)
return false;
}
+ peer->wsc.get_path = p2p_peer_wsc_get_path;
+ peer->wsc.connect = p2p_peer_wsc_connect;
+ peer->wsc.cancel = p2p_peer_wsc_cancel;
+ peer->wsc.remove = p2p_peer_wsc_remove;
+
+ if (!wsc_dbus_add_interface(&peer->wsc)) {
+ l_dbus_unregister_object(dbus_get_bus(),
+ p2p_peer_get_path(peer));
+ return false;
+ }
+
l_queue_push_tail(dev->peer_list, peer);
return true;
@@ -608,6 +866,7 @@ static bool p2p_device_peer_add(struct p2p_device *dev, struct p2p_peer *peer)
struct p2p_peer_move_data {
struct l_queue *new_list;
+ struct p2p_peer *conn_peer;
uint64_t now;
};
@@ -616,7 +875,8 @@ static bool p2p_peer_move_recent(void *data, void *user_data)
struct p2p_peer *peer = data;
struct p2p_peer_move_data *move_data = user_data;
- if (move_data->now > peer->bss->time_stamp + 30 * L_USEC_PER_SEC)
+ if (move_data->now > peer->bss->time_stamp + 30 * L_USEC_PER_SEC &&
+ peer != move_data->conn_peer)
return false; /* Old, keep on the list */
/* Recently seen or currently connected, move to the new list */
@@ -703,6 +963,7 @@ static bool p2p_scan_notify(int err, struct l_queue *bss_list,
* dev->peer_list and unref only the remaining peers.
*/
move_data.new_list = dev->peer_list;
+ move_data.conn_peer = dev->conn_peer;
move_data.now = l_time_now();
l_queue_foreach_remove(old_peer_list, p2p_peer_move_recent, &move_data);
l_queue_destroy(old_peer_list, p2p_peer_put);
@@ -1033,6 +1294,9 @@ static bool p2p_device_start_stop(struct p2p_device *dev,
* Stopping the P2P device, drop all peers as we can't start
* new connections from now on.
*/
+ if (dev->conn_peer)
+ p2p_connect_failed(dev);
+
l_queue_destroy(dev->peer_list, p2p_peer_put);
dev->peer_list = NULL;
}
@@ -1299,6 +1563,7 @@ static void p2p_device_free(void *user_data)
}
p2p_device_discovery_stop(dev);
+ p2p_connection_reset(dev);
l_dbus_unregister_object(dbus_get_bus(), p2p_device_get_path(dev));
l_queue_destroy(dev->peer_list, p2p_peer_put);
l_queue_destroy(dev->discovery_users, p2p_discovery_user_free);
@@ -1491,7 +1756,7 @@ static struct l_dbus_message *p2p_device_request_discovery(struct l_dbus *dbus,
p2p_device_discovery_destroy);
l_queue_push_tail(dev->discovery_users, user);
- if (first_user && dev->enabled)
+ if (first_user && !dev->conn_peer && dev->enabled)
p2p_device_discovery_start(dev);
return l_dbus_message_new_method_return(message);
@@ -1619,6 +1884,25 @@ static bool p2p_peer_get_connected(struct l_dbus *dbus,
return true;
}
+static struct l_dbus_message *p2p_peer_dbus_disconnect(struct l_dbus *dbus,
+ struct l_dbus_message *message,
+ void *user_data)
+{
+ struct p2p_peer *peer = user_data;
+
+ if (!l_dbus_message_get_arguments(message, ""))
+ return dbus_error_invalid_args(message);
+
+ /*
+ * Save the message for both WSC.Cancel and Peer.Disconnect the
+ * same way.
+ */
+ peer->wsc.pending_cancel = l_dbus_message_ref(message);
+
+ p2p_peer_disconnect(peer);
+ return NULL;
+}
+
static void p2p_peer_interface_setup(struct l_dbus_interface *interface)
{
l_dbus_interface_property(interface, "Name", 0, "s",
@@ -1629,6 +1913,8 @@ static void p2p_peer_interface_setup(struct l_dbus_interface *interface)
p2p_peer_get_subcategory, NULL);
l_dbus_interface_property(interface, "Connected", 0, "b",
p2p_peer_get_connected, NULL);
+ l_dbus_interface_method(interface, "Disconnect", 0,
+ p2p_peer_dbus_disconnect, "", "");
}
static void p2p_unicast_notify(struct l_genl_msg *msg, void *user_data)
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 10/17] p2p: Build and send the GO Negotiation Request
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (7 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 09/17] p2p: Add the WSC interface on peer DBus objects Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 11/17] p2p: Handle GO Negotiation Response, send Confirmation Andrew Zaborowski
` (7 subsequent siblings)
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 7946 bytes --]
---
src/p2p.c | 205 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 204 insertions(+), 1 deletion(-)
diff --git a/src/p2p.c b/src/p2p.c
index 86d2b3a1..fea689da 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -121,6 +121,7 @@ static const int channels_scan_2_4_other[] = { 2, 3, 4, 5, 7, 8, 9, 10 };
enum {
FRAME_GROUP_DEFAULT = 0,
FRAME_GROUP_LISTEN,
+ FRAME_GROUP_CONNECT,
};
struct device_type_category_info {
@@ -438,6 +439,9 @@ static void p2p_connection_reset(struct p2p_device *dev)
l_dbus_property_changed(dbus_get_bus(), p2p_device_get_path(dev),
IWD_P2P_INTERFACE, "AvailableConnections");
+ frame_watch_group_remove(dev->wdev_id, FRAME_GROUP_CONNECT);
+ frame_xchg_stop(dev->wdev_id);
+
if (!dev->enabled || (dev->enabled && dev->start_stop_cmd_id)) {
/*
* The device has been disabled in the mean time, all peers
@@ -467,6 +471,63 @@ static void p2p_connect_failed(struct p2p_device *dev)
p2p_connection_reset(dev);
}
+static void p2p_peer_frame_xchg(struct p2p_peer *peer, struct iovec *tx_body,
+ const uint8_t *bssid,
+ unsigned int retry_interval,
+ unsigned int resp_timeout,
+ unsigned int retries_on_ack, bool own_channel,
+ uint32_t group_id, frame_xchg_cb_t cb, ...)
+{
+ struct p2p_device *dev = peer->dev;
+ struct iovec *frame;
+ const struct iovec *iov;
+ struct mmpdu_header *header;
+ uint8_t header_buf[32] __attribute__ ((aligned));
+ int iov_cnt;
+ uint32_t freq;
+ va_list args;
+
+ /* Header */
+ memset(header_buf, 0, sizeof(header_buf));
+ header = (void *) header_buf;
+ header->fc.protocol_version = 0;
+ header->fc.type = MPDU_TYPE_MANAGEMENT;
+ header->fc.subtype = MPDU_MANAGEMENT_SUBTYPE_ACTION;
+ /* Section 2.4.3 */
+ memcpy(header->address_1, peer->device_addr, 6); /* DA */
+ memcpy(header->address_2, dev->addr, 6); /* SA */
+ memcpy(header->address_3, bssid, 6); /* BSSID */
+
+ for (iov = tx_body, iov_cnt = 0; iov->iov_base; iov++)
+ iov_cnt++;
+
+ frame = l_new(struct iovec, iov_cnt + 2);
+ frame[0].iov_base = header_buf;
+ frame[0].iov_len = (const uint8_t *) mmpdu_body(header) - header_buf;
+ memcpy(frame + 1, tx_body, sizeof(struct iovec) * iov_cnt);
+
+ freq = own_channel ?
+ scan_channel_to_freq(dev->listen_channel, SCAN_BAND_2_4_GHZ) :
+ peer->bss->frequency;
+
+ va_start(args, cb);
+ frame_xchg_startv(dev->wdev_id, frame, freq, retry_interval,
+ resp_timeout, retries_on_ack, group_id,
+ cb, dev, args);
+ va_end(args);
+
+ l_free(frame);
+}
+
+static const struct frame_xchg_prefix p2p_frame_go_neg_resp = {
+ /* Management -> Public Action -> P2P -> GO Negotiation Response */
+ .data = (uint8_t []) {
+ 0x04, 0x09, 0x50, 0x6f, 0x9a, 0x09,
+ P2P_ACTION_GO_NEGOTIATION_RESP
+ },
+ .len = 7,
+};
+
static void p2p_scan_destroy(void *user_data)
{
struct p2p_device *dev = user_data;
@@ -474,9 +535,151 @@ static void p2p_scan_destroy(void *user_data)
dev->scan_id = 0;
}
+/*
+ * It seems that sending more than about 42 channels in a frame's Channel
+ * List attribute will baffle some devices enough that they will ignore
+ * the frame.
+ */
+#define MAX_CHANNELS 40
+
+static void p2p_add_freq_func(uint32_t freq, void *user_data)
+{
+ struct p2p_channel_entries *channel_entry = user_data;
+ uint8_t channel;
+ enum scan_band band;
+
+ if (channel_entry->n_channels >= MAX_CHANNELS)
+ return;
+
+ channel = scan_freq_to_channel(freq, &band);
+
+ if (band != scan_oper_class_to_band((const uint8_t *) "XX\x4",
+ channel_entry->oper_class))
+ return;
+
+ channel_entry->channels[channel_entry->n_channels++] = channel;
+}
+
+static void p2p_device_fill_channel_list(struct p2p_device *dev,
+ struct p2p_channel_list_attr *attr)
+{
+ struct p2p_channel_entries *channel_entry;
+ unsigned int total_channels;
+
+ memcpy(attr->country, dev->country, 3);
+ attr->channel_entries = l_queue_new();
+
+ channel_entry = l_malloc(sizeof(struct p2p_channel_entries) +
+ MAX_CHANNELS);
+ channel_entry->oper_class = 81;
+ channel_entry->n_channels = 0;
+ scan_freq_set_foreach(wiphy_get_supported_freqs(dev->wiphy),
+ p2p_add_freq_func, channel_entry);
+ l_queue_push_tail(attr->channel_entries, channel_entry);
+ total_channels = channel_entry->n_channels;
+
+ if (total_channels >= MAX_CHANNELS)
+ return;
+
+ channel_entry = l_malloc(sizeof(struct p2p_channel_entries) +
+ MAX_CHANNELS);
+ channel_entry->oper_class = 115;
+ channel_entry->n_channels = 0;
+ scan_freq_set_foreach(wiphy_get_supported_freqs(dev->wiphy),
+ p2p_add_freq_func, channel_entry);
+
+ if (total_channels + channel_entry->n_channels > MAX_CHANNELS)
+ channel_entry->n_channels = MAX_CHANNELS - total_channels;
+
+ l_queue_push_tail(attr->channel_entries, channel_entry);
+}
+
+static bool p2p_go_negotiation_resp_cb(const struct mmpdu_header *mpdu,
+ const void *body, size_t body_len,
+ int rssi, struct p2p_device *dev)
+{
+ /* TODO: handle the GO Negotiation Response frame */
+ return false;
+}
+
+static void p2p_go_negotiation_req_done(int error, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ if (error)
+ l_error("Sending the GO Negotiation Req failed: %s (%i)",
+ strerror(-error), -error);
+ else
+ l_error("No GO Negotiation Response after Request ACKed");
+
+ p2p_connect_failed(dev);
+}
+
static void p2p_start_go_negotiation(struct p2p_device *dev)
{
- /* TODO: start GO Negotiation */
+ struct p2p_go_negotiation_req info = {};
+ uint8_t *req_body;
+ size_t req_len;
+ struct iovec iov[16];
+ int iov_len = 0;
+ /*
+ * Devices should respond within 100ms but times of ~400ms are
+ * often seen instead.
+ *
+ * 3.1.4.2: "The P2P Device that sent the Group Owner Negotiation
+ * frame shall assume that Group Owner Negotiation failed and is
+ * complete if it does not receive the next frame in the exchange
+ * within 100 milliseconds of receiving an acknowledgement frame."
+ */
+ unsigned int resp_timeout = 600;
+
+ info.dialog_token = 1;
+ info.capability = dev->capability;
+ info.go_intent = 0; /* Don't want to be the GO */
+ info.go_tie_breaker = 0;
+ info.config_timeout.go_config_timeout = 50; /* 500ms */
+ info.config_timeout.client_config_timeout = 50; /* 500ms */
+ memcpy(info.listen_channel.country, dev->country, 3);
+ info.listen_channel.oper_class = dev->oper_class;
+ info.listen_channel.channel_num = dev->listen_channel;
+ memcpy(info.intended_interface_addr, dev->conn_addr, 6);
+
+ /*
+ * In theory we support an empty set of operating channels for
+ * our potential group as a GO but we have to include our
+ * supported channels because the peer can only choose their
+ * own channels from our list. Use the listen channel as the
+ * preferred operating channel because we have no preference.
+ */
+ p2p_device_fill_channel_list(dev, &info.channel_list);
+ memcpy(info.operating_channel.country, dev->country, 3);
+ info.operating_channel.oper_class = dev->oper_class;
+ info.operating_channel.channel_num = dev->listen_channel;
+ info.device_info = dev->device_info;
+ info.device_password_id = dev->conn_password_id;
+
+ req_body = p2p_build_go_negotiation_req(&info, &req_len);
+ p2p_clear_go_negotiation_req(&info);
+
+ if (!req_body) {
+ p2p_connect_failed(dev);
+ return;
+ }
+
+ iov[iov_len].iov_base = req_body;
+ iov[iov_len].iov_len = req_len;
+ iov_len++;
+
+ /* WFD and other service IEs go here */
+
+ iov[iov_len].iov_base = NULL;
+
+ p2p_peer_frame_xchg(dev->conn_peer, iov, dev->conn_peer->device_addr,
+ 100, resp_timeout, 256, false,
+ FRAME_GROUP_CONNECT,
+ p2p_go_negotiation_req_done,
+ &p2p_frame_go_neg_resp,
+ p2p_go_negotiation_resp_cb, NULL);
}
static void p2p_start_provision_discovery(struct p2p_device *dev)
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 11/17] p2p: Handle GO Negotiation Response, send Confirmation
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (8 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 10/17] p2p: Build and send the GO Negotiation Request Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 12/17] p2p: Handle the Information Not Available response code Andrew Zaborowski
` (6 subsequent siblings)
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 7320 bytes --]
Parse the GO Negotiation Response frame and if no errors found send the
GO Negotiation Confirmation. If that gets ACKed wait for the GO to set
up the group.
---
src/p2p.c | 198 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 196 insertions(+), 2 deletions(-)
diff --git a/src/p2p.c b/src/p2p.c
index fea689da..ed820c09 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -88,6 +88,12 @@ struct p2p_device {
uint8_t conn_addr[6];
uint16_t conn_password_id;
+ struct l_timeout *config_timeout;
+ unsigned long go_config_delay;
+ uint32_t go_oper_freq;
+ struct p2p_group_id_attr go_group_id;
+ uint8_t go_interface_addr[6];
+
bool enabled : 1;
};
@@ -439,6 +445,8 @@ static void p2p_connection_reset(struct p2p_device *dev)
l_dbus_property_changed(dbus_get_bus(), p2p_device_get_path(dev),
IWD_P2P_INTERFACE, "AvailableConnections");
+ l_timeout_remove(dev->config_timeout);
+
frame_watch_group_remove(dev->wdev_id, FRAME_GROUP_CONNECT);
frame_xchg_stop(dev->wdev_id);
@@ -535,6 +543,53 @@ static void p2p_scan_destroy(void *user_data)
dev->scan_id = 0;
}
+static void p2p_start_client_provision(struct p2p_device *dev)
+{
+ char bssid_str[18];
+
+ memcpy(bssid_str, util_address_to_string(dev->go_interface_addr), 18);
+ l_debug("freq=%u ssid=%s group_addr=%s bssid=%s", dev->go_oper_freq,
+ dev->go_group_id.ssid,
+ util_address_to_string(dev->go_group_id.device_addr),
+ bssid_str);
+
+ /* TODO: start client provisioning */
+}
+
+static void p2p_config_timeout_destroy(void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ dev->config_timeout = NULL;
+}
+
+static void p2p_config_timeout(struct l_timeout *timeout, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ l_timeout_remove(dev->config_timeout);
+
+ /* Ready to start WSC */
+ p2p_start_client_provision(dev);
+}
+
+/*
+ * Called by GO Negotiation Response and Confirmation receive handlers,
+ * in both cases the channel lists are required to be subsets of our
+ * own supported channels and the Operating Channel must appear in the
+ * channel list.
+ */
+static bool p2p_device_validate_channel_list(struct p2p_device *dev,
+ const struct p2p_channel_list_attr *attr,
+ const struct p2p_channel_attr *oper_channel)
+{
+ if (l_queue_isempty(attr->channel_entries))
+ return false;
+
+ /* TODO */
+ return true;
+}
+
/*
* It seems that sending more than about 42 channels in a frame's Channel
* List attribute will baffle some devices enough that they will ignore
@@ -594,12 +649,151 @@ static void p2p_device_fill_channel_list(struct p2p_device *dev,
l_queue_push_tail(attr->channel_entries, channel_entry);
}
+static void p2p_go_negotiation_confirm_done(int error, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ if (error) {
+ /* TODO: we should probably ignore the missing ACK error */
+ l_error("Sending the GO Negotiation Confirm failed: %s (%i)",
+ strerror(-error), -error);
+ p2p_connect_failed(dev);
+ return;
+ }
+
+ /*
+ * Frame was ACKed. For simplicity wait idly the maximum amount of
+ * time indicated by the peer in the GO Negotiation Response's
+ * Configuration Timeout attribute and start the provisioning phase.
+ */
+ dev->config_timeout = l_timeout_create_ms(dev->go_config_delay,
+ p2p_config_timeout, dev,
+ p2p_config_timeout_destroy);
+}
+
static bool p2p_go_negotiation_resp_cb(const struct mmpdu_header *mpdu,
const void *body, size_t body_len,
int rssi, struct p2p_device *dev)
{
- /* TODO: handle the GO Negotiation Response frame */
- return false;
+ struct p2p_go_negotiation_resp resp_info;
+ struct p2p_go_negotiation_confirmation confirm_info = {};
+ uint8_t *confirm_body;
+ size_t confirm_len;
+ int r;
+ struct iovec iov[16];
+ int iov_len = 0;
+ enum scan_band band;
+ uint32_t frequency;
+
+ l_debug("");
+
+ if (!dev->conn_peer)
+ return true;
+
+ if (body_len < 8) {
+ l_error("GO Negotiation Response frame too short");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ r = p2p_parse_go_negotiation_resp(body + 7, body_len - 7, &resp_info);
+ if (r < 0) {
+ l_error("GO Negotiation Response parse error %s (%i)",
+ strerror(-r), -r);
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (resp_info.dialog_token != 1) {
+ l_error("GO Negotiation Response dialog token doesn't match");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (resp_info.status != P2P_STATUS_SUCCESS) {
+ l_error("GO Negotiation Response status %i", resp_info.status);
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ /*
+ * 3.1.4.2: "The Tie breaker bit in a GO Negotiation Response frame
+ * shall be toggled from the corresponding GO Negotiation Request
+ * frame."
+ */
+ if (!resp_info.go_tie_breaker) {
+ l_error("GO Negotiation Response tie breaker value wrong");
+
+ if (resp_info.go_intent == 0) {
+ /* Can't continue */
+ p2p_connect_failed(dev);
+ return true;
+ }
+ }
+
+ if (resp_info.capability.group_caps & P2P_GROUP_CAP_PERSISTENT_GROUP) {
+ l_error("Persistent groups not supported");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (resp_info.device_password_id != dev->conn_password_id) {
+ l_error("GO Negotiation Response WSC device password ID wrong");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (!p2p_device_validate_channel_list(dev, &resp_info.channel_list,
+ &resp_info.operating_channel))
+ return true;
+
+ band = scan_oper_class_to_band(
+ (const uint8_t *) resp_info.operating_channel.country,
+ resp_info.operating_channel.oper_class);
+ frequency = scan_channel_to_freq(
+ resp_info.operating_channel.channel_num,
+ band);
+ if (!frequency) {
+ l_error("Bad operating channel in GO Negotiation Response");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ dev->go_config_delay = resp_info.config_timeout.go_config_timeout * 10;
+ dev->go_oper_freq = frequency;
+ memcpy(&dev->go_group_id, &resp_info.group_id,
+ sizeof(struct p2p_group_id_attr));
+ memcpy(dev->go_interface_addr, resp_info.intended_interface_addr, 6);
+
+ /* Build and send the GO Negotiation Confirmation */
+ confirm_info.dialog_token = resp_info.dialog_token;
+ confirm_info.status = P2P_STATUS_SUCCESS;
+ confirm_info.capability.device_caps = 0; /* Reserved */
+ confirm_info.capability.group_caps = 0; /* Reserved */
+ confirm_info.channel_list = resp_info.channel_list;
+ confirm_info.operating_channel = resp_info.operating_channel;
+
+ confirm_body = p2p_build_go_negotiation_confirmation(&confirm_info,
+ &confirm_len);
+ p2p_clear_go_negotiation_resp(&resp_info);
+
+ if (!confirm_body) {
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ iov[iov_len].iov_base = confirm_body;
+ iov[iov_len].iov_len = confirm_len;
+ iov_len++;
+
+ /* WFD and other service IEs go here */
+
+ iov[iov_len].iov_base = NULL;
+
+ p2p_peer_frame_xchg(dev->conn_peer, iov, dev->conn_peer->device_addr,
+ 0, 0, 0, false, FRAME_GROUP_CONNECT,
+ p2p_go_negotiation_confirm_done, NULL);
+ return true;
}
static void p2p_go_negotiation_req_done(int error, void *user_data)
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 12/17] p2p: Handle the Information Not Available response code
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (9 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 11/17] p2p: Handle GO Negotiation Response, send Confirmation Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 13/17] p2p: Respond to Probe Reqs when waiting for GO negotiation Andrew Zaborowski
` (5 subsequent siblings)
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 17186 bytes --]
Handle the scenario where the peer's P2P state machine doesn't know
whether a connection has been authorized by the user and needs some time
to ask the user or a higher software layer whether to accept a
connection. In that case their GO Negotiation Response to our GO
Negotiation Request will have the status code "Fail: Information Not
Available" and we need to give the peer 120s to start a new GO
Negotiation with us. In this patch we handle the GO Negotiation
responder side where we parse the Request frame, build and send the
Response and finally parse the Confirmation. The existing code so far
only did the initiator side.
---
src/p2p.c | 382 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 376 insertions(+), 6 deletions(-)
diff --git a/src/p2p.c b/src/p2p.c
index ed820c09..a9e26b5d 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -90,6 +90,8 @@ struct p2p_device {
struct l_timeout *config_timeout;
unsigned long go_config_delay;
+ struct l_timeout *go_neg_req_timeout;
+ uint8_t go_dialog_token;
uint32_t go_oper_freq;
struct p2p_group_id_attr go_group_id;
uint8_t go_interface_addr[6];
@@ -446,6 +448,7 @@ static void p2p_connection_reset(struct p2p_device *dev)
IWD_P2P_INTERFACE, "AvailableConnections");
l_timeout_remove(dev->config_timeout);
+ l_timeout_remove(dev->go_neg_req_timeout);
frame_watch_group_remove(dev->wdev_id, FRAME_GROUP_CONNECT);
frame_xchg_stop(dev->wdev_id);
@@ -527,6 +530,15 @@ static void p2p_peer_frame_xchg(struct p2p_peer *peer, struct iovec *tx_body,
l_free(frame);
}
+static const struct frame_xchg_prefix p2p_frame_go_neg_req = {
+ /* Management -> Public Action -> P2P -> GO Negotiation Request */
+ .data = (uint8_t []) {
+ 0x04, 0x09, 0x50, 0x6f, 0x9a, 0x09,
+ P2P_ACTION_GO_NEGOTIATION_REQ
+ },
+ .len = 7,
+};
+
static const struct frame_xchg_prefix p2p_frame_go_neg_resp = {
/* Management -> Public Action -> P2P -> GO Negotiation Response */
.data = (uint8_t []) {
@@ -536,6 +548,15 @@ static const struct frame_xchg_prefix p2p_frame_go_neg_resp = {
.len = 7,
};
+static const struct frame_xchg_prefix p2p_frame_go_neg_confirm = {
+ /* Management -> Public Action -> P2P -> GO Negotiation Confirm */
+ .data = (uint8_t []) {
+ 0x04, 0x09, 0x50, 0x6f, 0x9a, 0x09,
+ P2P_ACTION_GO_NEGOTIATION_CONFIRM
+ },
+ .len = 7,
+};
+
static void p2p_scan_destroy(void *user_data)
{
struct p2p_device *dev = user_data;
@@ -573,6 +594,26 @@ static void p2p_config_timeout(struct l_timeout *timeout, void *user_data)
p2p_start_client_provision(dev);
}
+static void p2p_go_negotiation_resp_done(int error, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ if (error)
+ l_error("Sending the GO Negotiation Response failed: %s (%i)",
+ strerror(-error), -error);
+ else
+ l_error("No GO Negotiation Confirmation frame received");
+
+ p2p_connect_failed(dev);
+}
+
+static void p2p_go_negotiation_resp_err_done(int error, void *user_data)
+{
+ if (error)
+ l_error("Sending the GO Negotiation Response failed: %s (%i)",
+ strerror(-error), -error);
+}
+
/*
* Called by GO Negotiation Response and Confirmation receive handlers,
* in both cases the channel lists are required to be subsets of our
@@ -649,6 +690,236 @@ static void p2p_device_fill_channel_list(struct p2p_device *dev,
l_queue_push_tail(attr->channel_entries, channel_entry);
}
+static bool p2p_go_negotiation_confirm_cb(const struct mmpdu_header *mpdu,
+ const void *body, size_t body_len,
+ int rssi, struct p2p_device *dev)
+{
+ struct p2p_go_negotiation_confirmation info;
+ int r;
+ enum scan_band band;
+ uint32_t frequency;
+
+ l_debug("");
+
+ if (body_len < 8) {
+ l_error("GO Negotiation Confirmation frame too short");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ r = p2p_parse_go_negotiation_confirmation(body + 7, body_len - 7,
+ &info);
+ if (r < 0) {
+ l_error("GO Negotiation Confirmation parse error %s (%i)",
+ strerror(-r), -r);
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (info.dialog_token != dev->go_dialog_token) {
+ l_error("GO Negotiation Response dialog token doesn't match");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (info.status != P2P_STATUS_SUCCESS) {
+ l_error("GO Negotiation Confirmation status %i", info.status);
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (!p2p_device_validate_channel_list(dev, &info.channel_list,
+ &info.operating_channel))
+ return true;
+
+ band = scan_oper_class_to_band(
+ (const uint8_t *) info.operating_channel.country,
+ info.operating_channel.oper_class);
+ frequency = scan_channel_to_freq(info.operating_channel.channel_num,
+ band);
+ if (!frequency) {
+ l_error("Bad operating channel in GO Negotiation Confirmation");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ dev->go_oper_freq = frequency;
+ memcpy(&dev->go_group_id, &info.group_id,
+ sizeof(struct p2p_group_id_attr));
+
+ /*
+ * Confirmation received. For simplicity wait idly the maximum amount
+ * of time indicated by the peer in the GO Negotiation Response's
+ * Configuration Timeout attribute and start the provisioning phase.
+ */
+ dev->config_timeout = l_timeout_create_ms(dev->go_config_delay,
+ p2p_config_timeout, dev,
+ p2p_config_timeout_destroy);
+ return true;
+}
+
+static void p2p_device_go_negotiation_req_cb(const struct mmpdu_header *mpdu,
+ const void *body,
+ size_t body_len, int rssi,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ struct p2p_go_negotiation_req req_info;
+ struct p2p_go_negotiation_resp resp_info = {};
+ int r;
+ uint8_t *resp_body;
+ size_t resp_len;
+ struct iovec iov[16];
+ int iov_len = 0;
+ struct p2p_peer *peer;
+ enum p2p_attr_status_code status = P2P_STATUS_SUCCESS;
+ bool tie_breaker = false;
+
+ l_debug("");
+
+ /*
+ * Check the Destination Address and the BSSID. Section 2.4.3:
+ * "When communication is not within a P2P Group, e.g. during
+ * [...] GO Negotiation [...], a P2P Device shall use the
+ * P2P Device Address of the intended destination as the BSSID in
+ * Request, or Confirmation frames and its own P2P Device Address
+ * as the BSSID in Response frames."
+ *
+ * Some drivers (brcmfmac) will report the BSSID as all zeros and
+ * some Wi-Fi Display dongles will pass their own address as the
+ * BSSID in the GO Negotiation Request so allow all three possible
+ * values.
+ */
+ if (memcmp(mpdu->address_1, dev->addr, 6) ||
+ (memcmp(mpdu->address_3, dev->addr, 6) &&
+ memcmp(mpdu->address_3, mpdu->address_2, 6) &&
+ !util_mem_is_zero(mpdu->address_3, 6)))
+ return;
+
+ peer = l_queue_find(dev->peer_list, p2p_peer_match, mpdu->address_2);
+ if (!peer)
+ return;
+
+ if (body_len < 8)
+ return;
+
+ if (!dev->go_neg_req_timeout || peer != dev->conn_peer) {
+ status = P2P_STATUS_FAIL_INFO_NOT_AVAIL;
+ goto respond;
+ }
+
+ if (memcmp(mpdu->address_2, dev->conn_peer->bss->addr, 6)) {
+ status = P2P_STATUS_FAIL_UNABLE_TO_ACCOMMODATE_REQUEST;
+ goto respond;
+ }
+
+ r = p2p_parse_go_negotiation_req(body + 7, body_len - 7, &req_info);
+ if (r < 0) {
+ l_error("GO Negotiation Request parse error %s (%i)",
+ strerror(-r), -r);
+ p2p_connect_failed(dev);
+ status = P2P_STATUS_FAIL_INVALID_PARAMS;
+ goto respond;
+ }
+
+ if (req_info.go_intent == 0 && !req_info.go_tie_breaker) {
+ l_error("Can't negotiate client role and GO operation not "
+ "supported");
+
+ if (peer->wsc.pending_connect) {
+ struct l_dbus_message *reply =
+ dbus_error_not_supported(
+ peer->wsc.pending_connect);
+
+ dbus_pending_reply(&peer->wsc.pending_connect, reply);
+ }
+
+ p2p_connect_failed(dev);
+ status = P2P_STATUS_FAIL_INCOMPATIBLE_PARAMS;
+ goto p2p_free;
+ }
+
+ if (req_info.capability.group_caps & P2P_GROUP_CAP_PERSISTENT_GROUP) {
+ if (peer->wsc.pending_connect) {
+ struct l_dbus_message *reply =
+ dbus_error_not_supported(
+ peer->wsc.pending_connect);
+
+ dbus_pending_reply(&peer->wsc.pending_connect, reply);
+ }
+
+ p2p_connect_failed(dev);
+ l_error("Persistent groups not supported");
+ status = P2P_STATUS_FAIL_INCOMPATIBLE_PARAMS;
+ goto p2p_free;
+ }
+
+ if (req_info.device_password_id != dev->conn_password_id) {
+ p2p_connect_failed(dev);
+ l_error("Incompatible Password ID in the GO Negotiation Req");
+ status = P2P_STATUS_FAIL_INCOMPATIBLE_PROVISIONING;
+ goto p2p_free;
+ }
+
+ l_timeout_remove(dev->go_neg_req_timeout);
+ p2p_device_discovery_stop(dev);
+
+ dev->go_dialog_token = req_info.dialog_token;
+ dev->go_config_delay = req_info.config_timeout.go_config_timeout * 10;
+ memcpy(dev->go_interface_addr, req_info.intended_interface_addr, 6);
+
+p2p_free:
+ tie_breaker = !req_info.go_tie_breaker;
+ p2p_clear_go_negotiation_req(&req_info);
+
+respond:
+ /* Build and send the GO Negotiation Response */
+ resp_info.dialog_token = dev->go_dialog_token;
+ resp_info.status = status;
+ resp_info.capability.device_caps = dev->capability.device_caps;
+ resp_info.capability.group_caps = 0; /* Reserved */
+ resp_info.go_intent = 0; /* Don't want to be the GO */
+ resp_info.go_tie_breaker = tie_breaker;
+ resp_info.config_timeout.go_config_timeout = 50; /* 500ms */
+ resp_info.config_timeout.client_config_timeout = 50; /* 500ms */
+
+ if (dev->conn_peer)
+ memcpy(resp_info.intended_interface_addr, dev->conn_addr, 6);
+
+ p2p_device_fill_channel_list(dev, &resp_info.channel_list);
+ resp_info.device_info = dev->device_info;
+ resp_info.device_password_id = dev->conn_password_id;
+
+ resp_body = p2p_build_go_negotiation_resp(&resp_info, &resp_len);
+ p2p_clear_go_negotiation_resp(&resp_info);
+
+ if (!resp_body) {
+ p2p_connect_failed(dev);
+ return;
+ }
+
+ iov[iov_len].iov_base = resp_body;
+ iov[iov_len].iov_len = resp_len;
+ iov_len++;
+
+ /* WFD and other service IEs go here */
+
+ iov[iov_len].iov_base = NULL;
+
+ if (status == P2P_STATUS_SUCCESS)
+ p2p_peer_frame_xchg(peer, iov, dev->addr, 0, 600, 0, true,
+ FRAME_GROUP_CONNECT,
+ p2p_go_negotiation_resp_done,
+ &p2p_frame_go_neg_confirm,
+ p2p_go_negotiation_confirm_cb, NULL);
+ else
+ p2p_peer_frame_xchg(peer, iov, dev->addr, 0, 0, 0, true,
+ FRAME_GROUP_CONNECT,
+ p2p_go_negotiation_resp_err_done, NULL);
+
+ l_debug("GO Negotiation Response sent with status %i", status);
+}
+
static void p2p_go_negotiation_confirm_done(int error, void *user_data)
{
struct p2p_device *dev = user_data;
@@ -671,6 +942,25 @@ static void p2p_go_negotiation_confirm_done(int error, void *user_data)
p2p_config_timeout_destroy);
}
+static void p2p_go_neg_req_timeout_destroy(void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ dev->go_neg_req_timeout = NULL;
+}
+
+static void p2p_go_neg_req_timeout(struct l_timeout *timeout, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ l_debug("");
+
+ p2p_connect_failed(dev);
+
+ if (l_queue_isempty(dev->discovery_users))
+ p2p_device_discovery_stop(dev);
+}
+
static bool p2p_go_negotiation_resp_cb(const struct mmpdu_header *mpdu,
const void *body, size_t body_len,
int rssi, struct p2p_device *dev)
@@ -711,6 +1001,18 @@ static bool p2p_go_negotiation_resp_cb(const struct mmpdu_header *mpdu,
}
if (resp_info.status != P2P_STATUS_SUCCESS) {
+ if (resp_info.status == P2P_STATUS_FAIL_INFO_NOT_AVAIL) {
+ /* Give the peer 120s to restart the GO Negotiation */
+ l_error("P2P_STATUS_FAIL_INFO_NOT_AVAIL: Will wait for "
+ "a new GO Negotiation Request before declaring "
+ "failure");
+ dev->go_neg_req_timeout = l_timeout_create(120,
+ p2p_go_neg_req_timeout, dev,
+ p2p_go_neg_req_timeout_destroy);
+ p2p_device_discovery_start(dev);
+ return true;
+ }
+
l_error("GO Negotiation Response status %i", resp_info.status);
p2p_connect_failed(dev);
return true;
@@ -1163,6 +1465,60 @@ static void p2p_device_roc_start(struct p2p_device *dev)
if (duration > 1000)
duration = 1000;
+ /*
+ * Be on our listen channel, even if we're still in the 120s
+ * waiting period after a locally-initiated GO Negotiation and
+ * waiting for the peer's GO Negotiation Request. It's not
+ * totally clear that this is how the spec intended this
+ * mechanism to work. On one hand 3.1.4.1 says this:
+ * "A P2P Device may start Group Owner Negotiation by sending a
+ * GO Negotiation Request frame after receiving a Probe Request
+ * frame from the target P2P Device."
+ * and the Appendix D. scenarios also show GO Negotiation happening
+ * on the initiator's listen channel directly after the reception
+ * of the Probe Request from the target. But:
+ * 1. in 3.1.4.1 that is a MAY and doesn't exclude starting GO
+ * Negotiation also on the target's listen channel.
+ * 2. not all devices use the search state so we may never
+ * receive a Probe Request and may end up waiting indefinitely.
+ * 3. the time the peer spends on each channel in the scan state
+ * may be too short for the peer to receive the GO Negotiation
+ * Request after the Probe Request before moving to the next
+ * channel.
+ * 4. since we know the target is going to spend some time on
+ * their own listen channel, using that channel should work in
+ * every case.
+ *
+ * We also have this in 3.1.4.1:
+ * "When the P2P Devices arrive on a common channel and begin Group
+ * Owner Negotiation, they shall stay on that channel until Group
+ * Owner Negotiation completes."
+ * telling us that the whole negotiation should be happening on
+ * one channel seemingly supporting the new GO Negotiation being on
+ * the same channel as the original failed GO Negotiation.
+ * However the rest of the spec makes it clear they are not treated
+ * as a single GO Negotiation:
+ * 3.1.4.2:
+ * "Group Owner Negotiation is a three way frame exchange"
+ * 3.1.4.2.2:
+ * "Group Formation ends on transmission or reception of a GO
+ * Negotiation Response frame with the Status Code set to a value
+ * other than Success."
+ *
+ * 3.1.4.1 implies frame exchanges happen on the target device's
+ * Listen Channel, not our Listen Channel:
+ * "Prior to beginning the Group Formation Procedure the P2P Device
+ * shall arrive on a common channel with the target P2P Device.
+ * The Find Phase in In-band Device Discovery or Out-of-Band Device
+ * Discovery may be used for this purpose. In the former case, the
+ * P2P Device only needs to scan the Listen Channel of the target
+ * P2P Device, as opposed to all of the Social Channels."
+ *
+ * All in all we transmit our Negotiation Requests on the peer's
+ * listen channel since it is bound to spend more time on that
+ * channel than on any other channel and then we listen for a
+ * potential GO Negotiation restart on our listen channel.
+ */
listen_freq = scan_channel_to_freq(dev->listen_channel,
SCAN_BAND_2_4_GHZ);
@@ -1591,15 +1947,23 @@ static void p2p_device_discovery_start(struct p2p_device *dev)
* 3.1.2.1.1: "The Listen Channel shall be chosen at the beginning of
* the In-band Device Discovery"
*
- * (Unless we're waiting for a GO Negotiation Request from a peer on
- * a known channel)
+ * But keep the old channel if we're still waiting for the peer to
+ * restart the GO Negotiation because there may not be enough time
+ * for the peer to update our Listen Channel value before the user
+ * accepts the connection. In that case the GO Negotiation Request
+ * would be sent on the old channel.
*/
- dev->listen_channel = channels_social[l_getrandom_uint32() %
- L_ARRAY_SIZE(channels_social)];
- dev->oper_class = 81;
+ if (!(dev->listen_channel && dev->conn_peer)) {
+ dev->listen_channel = channels_social[l_getrandom_uint32() %
+ L_ARRAY_SIZE(channels_social)];
+ dev->oper_class = 81;
+ }
frame_watch_add(dev->wdev_id, FRAME_GROUP_LISTEN, 0x0040,
(uint8_t *) "", 0, p2p_device_probe_cb, dev, NULL);
+ frame_watch_add(dev->wdev_id, FRAME_GROUP_LISTEN, 0x00d0,
+ p2p_frame_go_neg_req.data, p2p_frame_go_neg_req.len,
+ p2p_device_go_negotiation_req_cb, dev, NULL);
p2p_device_scan_start(dev);
}
@@ -2177,7 +2541,13 @@ static struct l_dbus_message *p2p_device_release_discovery(struct l_dbus *dbus,
p2p_discovery_user_free(user);
- if (l_queue_isempty(dev->discovery_users))
+ /*
+ * If dev->conn_peer is non-NULL, we may be scanning as a way to
+ * listen for a GO Negotiation Request from the target peer. In
+ * that case we don't stop the device discovery when the list
+ * becomes empty.
+ */
+ if (l_queue_isempty(dev->discovery_users) && !dev->conn_peer)
p2p_device_discovery_stop(dev);
return l_dbus_message_new_method_return(message);
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 13/17] p2p: Respond to Probe Reqs when waiting for GO negotiation
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (10 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 12/17] p2p: Handle the Information Not Available response code Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 14/17] p2p: Add the Provision Discovery frame sequence Andrew Zaborowski
` (4 subsequent siblings)
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 6714 bytes --]
Some devices (a Wi-Fi Display dongle in my case) will send us Probe
Requests and wait for a response before they send us the GO
Negotiation Request that we're waiting for after the peer initially
replied with "Fail: Information Not Available" to our GO Negotiation
attempt. Curiously this specific device I tested would even accept
a Probe Response with a mangled body such that the IE sequence couldn't
be parsed.
---
src/p2p.c | 154 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 152 insertions(+), 2 deletions(-)
diff --git a/src/p2p.c b/src/p2p.c
index a9e26b5d..244ec1b9 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -1828,6 +1828,131 @@ static bool p2p_device_scan_start(struct p2p_device *dev)
return dev->scan_id != 0;
}
+static void p2p_probe_resp_done(int error, void *user_data)
+{
+ if (error)
+ l_error("Sending the Probe Response failed: %s (%i)",
+ strerror(-error), -error);
+}
+
+static void p2p_device_send_probe_resp(struct p2p_device *dev,
+ const uint8_t *dest_addr)
+{
+ uint8_t resp_buf[64] __attribute__ ((aligned));
+ size_t resp_len = 0;
+ struct p2p_probe_resp resp_info = {};
+ uint8_t *p2p_ie;
+ size_t p2p_ie_size;
+ struct wsc_probe_response wsc_info = {};
+ uint8_t *wsc_data;
+ size_t wsc_data_size;
+ uint8_t *wsc_ie;
+ size_t wsc_ie_size;
+ struct iovec iov[16];
+ int iov_len = 0;
+ /* TODO: extract some of these from wiphy features */
+ uint16_t capability = IE_BSS_CAP_PRIVACY | IE_BSS_CAP_SHORT_PREAMBLE;
+ struct mmpdu_header *header;
+ uint32_t freq;
+
+ /* Header */
+ memset(resp_buf, 0, sizeof(resp_buf));
+ header = (void *) resp_buf;
+ header->fc.protocol_version = 0;
+ header->fc.type = MPDU_TYPE_MANAGEMENT;
+ header->fc.subtype = MPDU_MANAGEMENT_SUBTYPE_PROBE_RESPONSE;
+ memcpy(header->address_1, dest_addr, 6); /* DA */
+ memcpy(header->address_2, dev->addr, 6); /* SA */
+ memcpy(header->address_3, dev->addr, 6); /* BSSID */
+
+ resp_len = (const uint8_t *) mmpdu_body(header) - resp_buf;
+
+ resp_len += 8; /* Timestamp */
+ resp_buf[resp_len++] = 0x64; /* Beacon Interval: 100 TUs */
+ resp_buf[resp_len++] = 0x00;
+ resp_buf[resp_len++] = capability >> 0;
+ resp_buf[resp_len++] = capability >> 8;
+ resp_buf[resp_len++] = IE_TYPE_SSID;
+ resp_buf[resp_len++] = 7;
+ resp_buf[resp_len++] = 'D';
+ resp_buf[resp_len++] = 'I';
+ resp_buf[resp_len++] = 'R';
+ resp_buf[resp_len++] = 'E';
+ resp_buf[resp_len++] = 'C';
+ resp_buf[resp_len++] = 'T';
+ resp_buf[resp_len++] = '-';
+ resp_buf[resp_len++] = IE_TYPE_SUPPORTED_RATES;
+ resp_buf[resp_len++] = 8;
+ resp_buf[resp_len++] = 0x8c;
+ resp_buf[resp_len++] = 0x12;
+ resp_buf[resp_len++] = 0x18;
+ resp_buf[resp_len++] = 0x24;
+ resp_buf[resp_len++] = 0x30;
+ resp_buf[resp_len++] = 0x48;
+ resp_buf[resp_len++] = 0x60;
+ resp_buf[resp_len++] = 0x6c;
+
+ resp_info.capability = dev->capability;
+ resp_info.device_info = dev->device_info;
+
+ p2p_ie = p2p_build_probe_resp(&resp_info, &p2p_ie_size);
+ if (!p2p_ie) {
+ l_error("Can't build our Probe Response P2P IE");
+ return;
+ }
+
+ wsc_info.state = WSC_STATE_CONFIGURED;
+ wsc_info.response_type = WSC_RESPONSE_TYPE_ENROLLEE_OPEN_8021X;
+ wsc_info.uuid_e[15] = 0x01;
+ wsc_info.serial_number[0] = '0';
+ wsc_info.primary_device_type = dev->device_info.primary_device_type;
+ l_strlcpy(wsc_info.device_name, dev->device_info.device_name,
+ sizeof(wsc_info.device_name));
+ wsc_info.config_methods = dev->device_info.wsc_config_methods;
+ wsc_info.rf_bands = 0x01; /* 2.4GHz */
+ wsc_info.version2 = true;
+
+ wsc_data = wsc_build_probe_response(&wsc_info, &wsc_data_size);
+ if (!wsc_data) {
+ l_free(p2p_ie);
+ l_error("Can't build our Probe Response WSC payload");
+ return;
+ }
+
+ wsc_ie = ie_tlv_encapsulate_wsc_payload(wsc_data, wsc_data_size,
+ &wsc_ie_size);
+ l_free(wsc_data);
+ if (!wsc_ie) {
+ l_free(p2p_ie);
+ l_error("Can't build our Probe Response WSC IE");
+ return;
+ }
+
+ iov[iov_len].iov_base = resp_buf;
+ iov[iov_len].iov_len = resp_len;
+ iov_len++;
+
+ iov[iov_len].iov_base = p2p_ie;
+ iov[iov_len].iov_len = p2p_ie_size;
+ iov_len++;
+
+ iov[iov_len].iov_base = wsc_ie;
+ iov[iov_len].iov_len = wsc_ie_size;
+ iov_len++;
+
+ /* WFD and other service IEs go here */
+
+ iov[iov_len].iov_base = NULL;
+
+ freq = scan_channel_to_freq(dev->listen_channel, SCAN_BAND_2_4_GHZ);
+ frame_xchg_start(dev->wdev_id, iov, freq, 0, 0, false, 0,
+ p2p_probe_resp_done, dev, NULL);
+ l_debug("Probe Response tx queued");
+
+ l_free(p2p_ie);
+ l_free(wsc_ie);
+}
+
static void p2p_device_probe_cb(const struct mmpdu_header *mpdu,
const void *body, size_t body_len,
int rssi, void *user_data)
@@ -1843,12 +1968,17 @@ static void p2p_device_probe_cb(const struct mmpdu_header *mpdu,
struct p2p_channel_attr *channel;
enum scan_band band;
uint32_t frequency;
+ bool from_conn_peer;
l_debug("");
if (!dev->scan_timeout && !dev->scan_id)
return;
+ from_conn_peer =
+ dev->go_neg_req_timeout && dev->conn_peer &&
+ !memcmp(mpdu->address_2, dev->conn_peer->bss->addr, 6);
+
wsc_payload = ie_tlv_extract_wsc_payload(body, body_len, &wsc_len);
if (!wsc_payload) /* Not a P2P Probe Req, ignore */
return;
@@ -1859,7 +1989,15 @@ static void p2p_device_probe_cb(const struct mmpdu_header *mpdu,
if (r < 0) {
l_error("Probe Request WSC IE parse error %s (%i)",
strerror(-r), -r);
- return;
+
+ /*
+ * Ignore requests with erroneous WSC IEs except if they
+ * come from the peer we're currently connecting to as a
+ * workaround for implementations sending invalid Probe
+ * Requests.
+ */
+ if (!from_conn_peer)
+ return;
}
r = p2p_parse_probe_req(body, body_len, &p2p_info);
@@ -1875,8 +2013,20 @@ static void p2p_device_probe_cb(const struct mmpdu_header *mpdu,
/*
* We don't currently have a use case for replying to Probe Requests
* except when waiting for a GO Negotiation Request from our target
- * peer.
+ * peer. Some of those peers (seemingly running ancient and/or
+ * hw-manufacturer-provided versions of wpa_s) will only send us GO
+ * Negotiation Requests each time they receive our Probe Response
+ * frame, even if that frame's body is unparsable.
*/
+ if (from_conn_peer) {
+ /*
+ * TODO: use ap.c code to check if we match the SSID, BSSID,
+ * DSSS Channel etc. in the Probe Request, and to build the
+ * Response body.
+ */
+ p2p_device_send_probe_resp(dev, mpdu->address_2);
+ goto p2p_free;
+ }
/*
* The peer's listen frequency may be different from ours.
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 14/17] p2p: Add the Provision Discovery frame sequence
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (11 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 13/17] p2p: Respond to Probe Reqs when waiting for GO negotiation Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 15/17] p2p: Scan for the provision BSS Andrew Zaborowski
` (3 subsequent siblings)
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 4770 bytes --]
When connecting to an existing group, use the Provision Discovery
Request/Response frame exchange before calling
p2p_start_client_provision().
---
src/p2p.c | 141 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 140 insertions(+), 1 deletion(-)
diff --git a/src/p2p.c b/src/p2p.c
index 244ec1b9..e1b7b526 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -557,6 +557,15 @@ static const struct frame_xchg_prefix p2p_frame_go_neg_confirm = {
.len = 7,
};
+static const struct frame_xchg_prefix p2p_frame_pd_resp = {
+ /* Management -> Public Action -> P2P -> Provision Discovery Response */
+ .data = (uint8_t []) {
+ 0x04, 0x09, 0x50, 0x6f, 0x9a, 0x09,
+ P2P_ACTION_PROVISION_DISCOVERY_RESP
+ },
+ .len = 7,
+};
+
static void p2p_scan_destroy(void *user_data)
{
struct p2p_device *dev = user_data;
@@ -1178,9 +1187,139 @@ static void p2p_start_go_negotiation(struct p2p_device *dev)
p2p_go_negotiation_resp_cb, NULL);
}
+static bool p2p_provision_disc_resp_cb(const struct mmpdu_header *mpdu,
+ const void *body, size_t body_len,
+ int rssi, struct p2p_device *dev)
+{
+ struct p2p_provision_discovery_resp info;
+ int r;
+
+ l_debug("");
+
+ if (!dev->conn_peer)
+ return true;
+
+ if (body_len < 8) {
+ l_error("Provision Discovery Response frame too short");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ r = p2p_parse_provision_disc_resp(body + 7, body_len - 7, &info);
+ if (r < 0) {
+ l_error("Provision Discovery Response parse error %s (%i)",
+ strerror(-r), -r);
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (info.dialog_token != 2) {
+ l_error("Provision Discovery Response dialog token doesn't "
+ "match");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ if (info.wsc_config_method != dev->conn_config_method) {
+ l_error("Provision Discovery Response WSC device password ID "
+ "wrong");
+ p2p_connect_failed(dev);
+ return true;
+ }
+
+ /*
+ * If we're not joining an existing group, continue with Group
+ * Formation now.
+ */
+ if (!dev->conn_peer->group) {
+ p2p_start_go_negotiation(dev);
+ return true;
+ }
+
+ /*
+ * Indended P2P Interface address is optional, we don't have the
+ * BSSID of the group here.
+ *
+ * We might want to make sure that Group Formation is false but the
+ * Capability attribute is also optional.
+ */
+ dev->go_oper_freq = dev->conn_peer->bss->frequency;
+ memset(dev->go_interface_addr, 0, 6);
+ memcpy(dev->go_group_id.device_addr, dev->conn_peer->device_addr, 6);
+ l_strlcpy(dev->go_group_id.ssid,
+ (const char *) dev->conn_peer->bss->ssid,
+ dev->conn_peer->bss->ssid_len + 1);
+
+ /* Ready to start WSC */
+ p2p_start_client_provision(dev);
+ return true;
+}
+
+static void p2p_provision_disc_req_done(int error, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ if (error)
+ l_error("Sending the Provision Discovery Req failed: %s (%i)",
+ strerror(-error), -error);
+ else
+ l_error("No Provision Discovery Response after Request ACKed");
+
+ p2p_connect_failed(dev);
+}
+
static void p2p_start_provision_discovery(struct p2p_device *dev)
{
- /* TODO: start Provision Discovery */
+ struct p2p_provision_discovery_req info = { .status = -1 };
+ uint8_t *req_body;
+ size_t req_len;
+ uint8_t wfd_ie[32];
+ size_t wfd_ie_size;
+ struct iovec iov[16];
+ int iov_len = 0;
+
+ /* This frame is pretty simple when P2Ps isn't supported */
+ info.dialog_token = 2;
+ info.capability = dev->capability;
+ info.device_info = dev->device_info;
+
+ if (dev->conn_peer->group) {
+ memcpy(info.group_id.device_addr, dev->conn_peer->bss->addr, 6);
+ memcpy(info.group_id.ssid, dev->conn_peer->bss->ssid,
+ dev->conn_peer->bss->ssid_len);
+ }
+
+ info.wsc_config_method = dev->conn_config_method;
+
+ req_body = p2p_build_provision_disc_req(&info, &req_len);
+ p2p_clear_provision_disc_req(&info);
+
+ if (!req_body) {
+ p2p_connect_failed(dev);
+ return;
+ }
+
+ wfd_ie_size = p2p_build_wfd_ie(dev, wfd_ie);
+
+ iov[iov_len].iov_base = req_body;
+ iov[iov_len].iov_len = req_len;
+ iov_len++;
+
+ iov[iov_len].iov_base = wfd_ie;
+ iov[iov_len].iov_len = wfd_ie_size;
+ iov_len++;
+
+ iov[iov_len].iov_base = NULL;
+
+ /*
+ * Section 3.2.3: "The Provision Discovery Request frame shall be
+ * sent to the P2P Device Address of the P2P Group Owner"
+ */
+ p2p_peer_frame_xchg(dev->conn_peer, iov, dev->conn_peer->device_addr,
+ 200, 600, 8, false, FRAME_GROUP_CONNECT,
+ p2p_provision_disc_req_done,
+ &p2p_frame_pd_resp, p2p_provision_disc_resp_cb,
+ NULL);
}
static bool p2p_peer_get_info(struct p2p_peer *peer,
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 15/17] p2p: Scan for the provision BSS
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (12 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 14/17] p2p: Add the Provision Discovery frame sequence Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 16/17] p2p: Create the P2P-Client interface Andrew Zaborowski
` (2 subsequent siblings)
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 8892 bytes --]
Add the next step after Provision Discovery or GO Negotiation that is
scanning for the WSC BSS that the GO has set up for client provisioning.
---
src/p2p.c | 231 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 223 insertions(+), 8 deletions(-)
diff --git a/src/p2p.c b/src/p2p.c
index e1b7b526..abf91fc2 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -87,11 +87,13 @@ struct p2p_device {
char *conn_pin;
uint8_t conn_addr[6];
uint16_t conn_password_id;
+ struct scan_bss *conn_wsc_bss;
struct l_timeout *config_timeout;
unsigned long go_config_delay;
struct l_timeout *go_neg_req_timeout;
uint8_t go_dialog_token;
+ unsigned int go_scan_retry;
uint32_t go_oper_freq;
struct p2p_group_id_attr go_group_id;
uint8_t go_interface_addr[6];
@@ -475,6 +477,10 @@ static void p2p_connect_failed(struct p2p_device *dev)
if (!peer)
return;
+ /* Are we in the scan for the WSC provision bss */
+ if (dev->scan_id)
+ scan_cancel(dev->wdev_id, dev->scan_id);
+
if (peer->wsc.pending_connect)
dbus_pending_reply(&peer->wsc.pending_connect,
dbus_error_failed(peer->wsc.pending_connect));
@@ -566,6 +572,11 @@ static const struct frame_xchg_prefix p2p_frame_pd_resp = {
.len = 7,
};
+static void p2p_device_interface_create(struct p2p_device *dev)
+{
+ /* TODO */
+}
+
static void p2p_scan_destroy(void *user_data)
{
struct p2p_device *dev = user_data;
@@ -573,6 +584,215 @@ static void p2p_scan_destroy(void *user_data)
dev->scan_id = 0;
}
+static void p2p_provision_scan_start(struct p2p_device *dev);
+
+static bool p2p_provision_scan_notify(int err, struct l_queue *bss_list,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ const struct l_queue_entry *entry;
+ static const uint8_t wildcard_addr[6] =
+ { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
+
+ l_debug("err=%i, len(bss_list)=%i", err, l_queue_length(bss_list));
+
+ if (err) {
+ l_error("P2P provision scan failed: %s (%i)", strerror(-err),
+ -err);
+ p2p_connect_failed(dev);
+ return false;
+ }
+
+ for (entry = l_queue_get_entries(bss_list); entry;
+ entry = entry->next) {
+ struct scan_bss *bss = entry->data;
+ const uint8_t *group_id;
+ bool selected_reg;
+ struct p2p_capability_attr *capability;
+ enum wsc_device_password_id device_password_id;
+ const uint8_t *amacs;
+
+ /*
+ * Check if we found our target GO, some of these checks may
+ * need to be gradually relaxed as we discover non-compliant
+ * implementations but at least print a debug statement when
+ * something doesn't match.
+ */
+
+ if (strncmp((const char *) bss->ssid, dev->go_group_id.ssid,
+ bss->ssid_len))
+ continue;
+
+ if (dev->go_group_id.ssid[bss->ssid_len] != '\0')
+ continue;
+
+ if (!util_mem_is_zero(dev->go_interface_addr, 6) &&
+ memcmp(bss->addr, dev->go_interface_addr, 6))
+ l_debug("SSID matched but BSSID didn't match the GO's "
+ "intended interface addr, proceeding anyway");
+
+ if (!bss->wsc) {
+ l_error("SSID matched but no valid WSC IE");
+ continue;
+ }
+
+ if (bss->source_frame == SCAN_BSS_PROBE_RESP) {
+ struct wsc_probe_response wsc_info;
+
+ if (!bss->p2p_probe_resp_info) {
+ l_error("SSID matched but no valid P2P IE");
+ continue;
+ }
+
+ if (wsc_parse_probe_response(bss->wsc, bss->wsc_size,
+ &wsc_info) < 0) {
+ l_error("SSID matched but can't parse WSC "
+ "Probe Response info");
+ continue;
+ }
+
+ group_id = bss->p2p_probe_resp_info->
+ device_info.device_addr;
+ selected_reg = wsc_info.selected_registrar;
+ capability = &bss->p2p_probe_resp_info->capability;
+ device_password_id = wsc_info.device_password_id;
+ amacs = wsc_info.authorized_macs;
+ } else if (bss->source_frame == SCAN_BSS_BEACON) {
+ struct wsc_beacon wsc_info;
+
+ if (!bss->p2p_beacon_info) {
+ l_error("SSID matched but no valid P2P IE");
+ continue;
+ }
+
+ if (wsc_parse_beacon(bss->wsc, bss->wsc_size,
+ &wsc_info) < 0) {
+ l_error("SSID matched but can't parse WSC "
+ "Beacon info");
+ continue;
+ }
+
+ group_id = bss->p2p_beacon_info->device_addr;
+ selected_reg = wsc_info.selected_registrar;
+ capability = &bss->p2p_beacon_info->capability;
+ device_password_id = wsc_info.device_password_id;
+ amacs = wsc_info.authorized_macs;
+ } else
+ continue;
+
+ if (memcmp(group_id, dev->go_group_id.device_addr, 6)) {
+ l_error("SSID matched but Group ID address didn't");
+ continue;
+ }
+
+ if (!selected_reg) {
+ /*
+ * Debug level because this will sometimes happen
+ * while the target is setting up the GO mode in the
+ * course of normal operation, and gets set to true
+ * in a few seconds, we just need to keep scanning.
+ */
+ l_debug("SSID matched but not a Selected Reg");
+ continue;
+ }
+
+ if (dev->conn_peer->group && (capability->group_caps &
+ P2P_GROUP_CAP_GROUP_FORMATION)) {
+ l_error("SSID matched but not in Group Formation");
+ continue;
+ }
+
+ if (!dev->conn_peer->group && !(capability->group_caps &
+ P2P_GROUP_CAP_GROUP_FORMATION))
+ /*
+ * We have to ignore this one for interoperability
+ * with some devices.
+ */
+ l_debug("SSID matched but GO not in Group Formation, "
+ "proceeding anyway");
+
+ if (capability->group_caps & P2P_GROUP_CAP_GROUP_LIMIT) {
+ l_error("SSID matched but group already full");
+ continue;
+ }
+
+ if (device_password_id != dev->conn_password_id) {
+ l_error("SSID matched wrong Password ID");
+ continue;
+ }
+
+ if (!util_mem_is_zero(amacs, 30)) {
+ bool amacs_match = false;
+ int i;
+
+ for (i = 0; i < 5; i++, amacs += 6)
+ if (!memcmp(amacs, dev->addr, 6) ||
+ !memcmp(amacs, wildcard_addr, 6))
+ amacs_match = true;
+
+ if (!amacs_match) {
+ l_error("SSID matched we're not in AMacs");
+ continue;
+ }
+ }
+
+ l_debug("GO found in the scan results");
+
+ dev->conn_wsc_bss = bss;
+ p2p_device_interface_create(dev);
+ l_queue_remove(bss_list, bss);
+ l_queue_destroy(bss_list,
+ (l_queue_destroy_func_t) scan_bss_free);
+ return true;
+ }
+
+ /* Retry a few times if the WSC AP not found or not ready */
+ dev->go_scan_retry++;
+
+ if (dev->go_scan_retry > 15) {
+ p2p_connect_failed(dev);
+ return false;
+ }
+
+ p2p_provision_scan_start(dev);
+ return false;
+}
+
+static void p2p_provision_scan_start(struct p2p_device *dev)
+{
+ struct scan_parameters params = {};
+ uint8_t buf[256];
+
+ params.flush = true;
+ params.no_cck_rates = true;
+ params.ssid = dev->go_group_id.ssid;
+ params.extra_ie = p2p_build_scan_ies(dev, buf, sizeof(buf),
+ ¶ms.extra_ie_size);
+ L_WARN_ON(!params.extra_ie);
+
+ /*
+ * Initially scan just the Operating Channel the GO reported
+ * during the negotiation. In theory there's no guarantee that
+ * it is going to be on that channel so we should fall back
+ * to scanning all the channels listed in the Channel List
+ * attribute. For simplicity we just do a full scan in that
+ * scenario -- for most target P2P devices we wouldn't be saving
+ * ourselves any work anyway as the Channel List is going to
+ * contain all of the 2.4 and 5G channels.
+ */
+ if (dev->go_scan_retry < 12) {
+ params.freqs = scan_freq_set_new();
+ scan_freq_set_add(params.freqs, dev->go_oper_freq);
+ }
+
+ dev->scan_id = scan_active_full(dev->wdev_id, ¶ms, NULL,
+ p2p_provision_scan_notify, dev,
+ p2p_scan_destroy);
+
+ if (params.freqs)
+ scan_freq_set_free(params.freqs);
+}
+
static void p2p_start_client_provision(struct p2p_device *dev)
{
char bssid_str[18];
@@ -583,7 +803,8 @@ static void p2p_start_client_provision(struct p2p_device *dev)
util_address_to_string(dev->go_group_id.device_addr),
bssid_str);
- /* TODO: start client provisioning */
+ dev->go_scan_retry = 0;
+ p2p_provision_scan_start(dev);
}
static void p2p_config_timeout_destroy(void *user_data)
@@ -1273,8 +1494,6 @@ static void p2p_start_provision_discovery(struct p2p_device *dev)
struct p2p_provision_discovery_req info = { .status = -1 };
uint8_t *req_body;
size_t req_len;
- uint8_t wfd_ie[32];
- size_t wfd_ie_size;
struct iovec iov[16];
int iov_len = 0;
@@ -1299,15 +1518,11 @@ static void p2p_start_provision_discovery(struct p2p_device *dev)
return;
}
- wfd_ie_size = p2p_build_wfd_ie(dev, wfd_ie);
-
iov[iov_len].iov_base = req_body;
iov[iov_len].iov_len = req_len;
iov_len++;
- iov[iov_len].iov_base = wfd_ie;
- iov[iov_len].iov_len = wfd_ie_size;
- iov_len++;
+ /* WFD and other service IEs go here */
iov[iov_len].iov_base = NULL;
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 16/17] p2p: Create the P2P-Client interface
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (13 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 15/17] p2p: Scan for the provision BSS Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-03 16:14 ` [PATCH 17/17] p2p: WSC client provisioning and connection Andrew Zaborowski
2020-04-17 15:16 ` [PATCH 01/17] dbus: Add P2P interface name defines Denis Kenzior
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 7514 bytes --]
Once we've found the provisioning BSS create the P2P-Client interface
that we're going to use for the actual provisioning and the final P2P
connection.
---
src/p2p.c | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 180 insertions(+), 5 deletions(-)
diff --git a/src/p2p.c b/src/p2p.c
index abf91fc2..79be15e8 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -87,7 +87,11 @@ struct p2p_device {
char *conn_pin;
uint8_t conn_addr[6];
uint16_t conn_password_id;
+ unsigned int conn_num;
struct scan_bss *conn_wsc_bss;
+ struct netdev *conn_netdev;
+ uint32_t conn_netdev_watch_id;
+ uint32_t conn_new_intf_cmd_id;
struct l_timeout *config_timeout;
unsigned long go_config_delay;
@@ -452,6 +456,47 @@ static void p2p_connection_reset(struct p2p_device *dev)
l_timeout_remove(dev->config_timeout);
l_timeout_remove(dev->go_neg_req_timeout);
+ if (dev->conn_new_intf_cmd_id)
+ /*
+ * Note this may result in the interface being created
+ * and unused, we don't have its ifindex or wdev_id here
+ * to be able to delete it. Could use a separate netlink
+ * socket for each connection or disallowing .Disconnect
+ * calls while this command runs.
+ */
+ l_genl_family_cancel(dev->nl80211, dev->conn_new_intf_cmd_id);
+
+ if (dev->conn_netdev) {
+ struct l_genl_msg *msg;
+ uint64_t wdev_id = netdev_get_wdev_id(dev->conn_netdev);
+
+ msg = l_genl_msg_new(NL80211_CMD_DEL_INTERFACE);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_WDEV, 8, &wdev_id);
+
+ if (!l_genl_family_send(dev->nl80211, msg, NULL, NULL, NULL)) {
+ l_genl_msg_unref(msg);
+ l_error("Sending DEL_INTERFACE for %s failed",
+ netdev_get_name(dev->conn_netdev));
+ }
+
+ netdev_destroy(dev->conn_netdev);
+ dev->conn_netdev = NULL;
+ }
+
+ /*
+ * Removing the netdev above makes sure that both the WSC connection
+ * and the final WPA2 connection (wsc.c and netdev.c) no longer need
+ * the bss so we can free it now -- if it wasn't freed as a result
+ * of wsc_enrollee_cancel or netdev_destroy triggering
+ * p2p_peer_provision_done in the first place.
+ */
+ if (dev->conn_wsc_bss) {
+ scan_bss_free(dev->conn_wsc_bss);
+ dev->conn_wsc_bss = NULL;
+ }
+
+ netdev_watch_remove(dev->conn_netdev_watch_id);
+
frame_watch_group_remove(dev->wdev_id, FRAME_GROUP_CONNECT);
frame_xchg_stop(dev->wdev_id);
@@ -572,11 +617,117 @@ static const struct frame_xchg_prefix p2p_frame_pd_resp = {
.len = 7,
};
-static void p2p_device_interface_create(struct p2p_device *dev)
+static void p2p_provision_connect(struct p2p_device *dev)
{
/* TODO */
}
+static void p2p_device_netdev_watch_destroy(void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ dev->conn_netdev_watch_id = 0;
+}
+
+static void p2p_device_netdev_notify(struct netdev *netdev,
+ enum netdev_watch_event event,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ if (dev->conn_netdev != netdev)
+ return;
+
+ switch (event) {
+ case NETDEV_WATCH_EVENT_UP:
+ case NETDEV_WATCH_EVENT_NEW:
+ if (!dev->conn_wsc_bss || !netdev_get_is_up(netdev))
+ break;
+
+ p2p_provision_connect(dev);
+ break;
+ case NETDEV_WATCH_EVENT_DEL:
+ dev->conn_netdev = NULL;
+ /* Fall through */
+ case NETDEV_WATCH_EVENT_DOWN:
+ case NETDEV_WATCH_EVENT_ADDRESS_CHANGE:
+ p2p_connect_failed(dev);
+ break;
+ default:
+ break;
+ }
+}
+
+static void p2p_device_new_interface_cb(struct l_genl_msg *msg,
+ void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ l_debug("");
+
+ if (l_genl_msg_get_error(msg) < 0) {
+ l_error("NEW_INTERFACE failed: %s",
+ strerror(-l_genl_msg_get_error(msg)));
+ p2p_connect_failed(dev);
+ return;
+ }
+
+ /* Create the netdev so we don't have to parse the message ourselves */
+ dev->conn_netdev = netdev_create_from_genl(msg, dev->conn_addr);
+ if (!dev->conn_netdev) {
+ p2p_connect_failed(dev);
+ return;
+ }
+
+ /*
+ * Register a watch for each connection rather than having one
+ * global watch. Each connection's watch will receive events
+ * related to all other connections too, and will check that its
+ * conn_netdev != netdev and exit immediately. This is not ideal
+ * but it's the same complexity (n^2) as that of one global watch
+ * that receives all events and iterates over p2p_device_list to
+ * find the connection.
+ */
+ dev->conn_netdev_watch_id = netdev_watch_add(p2p_device_netdev_notify,
+ dev, p2p_device_netdev_watch_destroy);
+}
+
+static void p2p_device_new_interface_destroy(void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ dev->conn_new_intf_cmd_id = 0;
+}
+
+static void p2p_device_interface_create(struct p2p_device *dev)
+{
+ uint32_t iftype = NL80211_IFTYPE_P2P_CLIENT;
+ char ifname[32];
+ uint32_t wiphy_id = dev->wdev_id >> 32;
+ struct l_genl_msg *msg;
+
+ snprintf(ifname, sizeof(ifname), "wlan%i-p2p-cl%i",
+ wiphy_id, dev->conn_num++);
+ l_debug("creating %s", ifname);
+
+ msg = l_genl_msg_new(NL80211_CMD_NEW_INTERFACE);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_WIPHY, 4, &wiphy_id);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_IFTYPE, 4, &iftype);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_IFNAME,
+ strlen(ifname) + 1, ifname);
+ l_genl_msg_append_attr(msg, NL80211_ATTR_4ADDR, 1, "\0");
+ l_genl_msg_append_attr(msg, NL80211_ATTR_SOCKET_OWNER, 0, "");
+
+ dev->conn_new_intf_cmd_id = l_genl_family_send(dev->nl80211, msg,
+ p2p_device_new_interface_cb, dev,
+ p2p_device_new_interface_destroy);
+ if (!dev->conn_new_intf_cmd_id) {
+ l_genl_msg_unref(msg);
+ l_error("Error sending NEW_INTERFACE for %s", ifname);
+ p2p_connect_failed(dev);
+ }
+}
+
static void p2p_scan_destroy(void *user_data)
{
struct p2p_device *dev = user_data;
@@ -2526,6 +2677,15 @@ static void p2p_device_enable_destroy(void *user_data)
dev->start_stop_cmd_id = 0;
}
+static bool p2p_peer_remove_disconnected(void *peer, void *conn_peer)
+{
+ if (peer == conn_peer)
+ return false;
+
+ p2p_peer_put(peer);
+ return true;
+}
+
static bool p2p_device_start_stop(struct p2p_device *dev,
l_dbus_property_complete_cb_t complete,
struct l_dbus_message *message)
@@ -2557,13 +2717,28 @@ static bool p2p_device_start_stop(struct p2p_device *dev,
if (dev->enabled) {
/*
* Stopping the P2P device, drop all peers as we can't start
- * new connections from now on.
+ * new connections from now on. Check if we have a connection
+ * being set up without a .conn_netdev and without
+ * .conn_wsc_bss -- this will mean the connection is still in
+ * the PD or GO Negotiation phase or inside the scan. Those
+ * phases happen on the device interface so the connection
+ * gets immediately aborted.
*/
- if (dev->conn_peer)
+ if (dev->conn_peer && !dev->conn_netdev && !dev->conn_wsc_bss)
p2p_connect_failed(dev);
- l_queue_destroy(dev->peer_list, p2p_peer_put);
- dev->peer_list = NULL;
+ if (!dev->conn_peer) {
+ l_queue_destroy(dev->peer_list, p2p_peer_put);
+ dev->peer_list = NULL;
+ } else
+ /*
+ * If the connection already depends on its own
+ * netdev only, we can let it continue until the user
+ * decides to disconnect.
+ */
+ l_queue_foreach_remove(dev->peer_list,
+ p2p_peer_remove_disconnected,
+ dev->conn_peer);
}
return true;
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* [PATCH 17/17] p2p: WSC client provisioning and connection
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (14 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 16/17] p2p: Create the P2P-Client interface Andrew Zaborowski
@ 2020-04-03 16:14 ` Andrew Zaborowski
2020-04-17 15:16 ` [PATCH 01/17] dbus: Add P2P interface name defines Denis Kenzior
16 siblings, 0 replies; 28+ messages in thread
From: Andrew Zaborowski @ 2020-04-03 16:14 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 12508 bytes --]
Add the final two steps of the connection setup, and corresponding
disconnect logic:
* the WSC connection to the GO to do the client provisioning,
* the netdev_connect call to use the provisioned credentials for the
final WPA2 connection.
---
src/p2p.c | 319 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 316 insertions(+), 3 deletions(-)
diff --git a/src/p2p.c b/src/p2p.c
index 79be15e8..ff1977ee 100644
--- a/src/p2p.c
+++ b/src/p2p.c
@@ -92,6 +92,7 @@ struct p2p_device {
struct netdev *conn_netdev;
uint32_t conn_netdev_watch_id;
uint32_t conn_new_intf_cmd_id;
+ struct wsc_enrollee *conn_enrollee;
struct l_timeout *config_timeout;
unsigned long go_config_delay;
@@ -103,6 +104,14 @@ struct p2p_device {
uint8_t go_interface_addr[6];
bool enabled : 1;
+ /*
+ * We need to track @disconnecting because while a connect action is
+ * always triggered by a DBus message, meaning that @pending_message
+ * is going to be non-NULL, a disconnect may also be a result of an
+ * error at a layer higher than netdev and may last until
+ * netdev_disconnect, or similar, finishes.
+ */
+ bool disconnecting : 1;
};
struct p2p_discovery_user {
@@ -319,6 +328,12 @@ static void p2p_discovery_user_free(void *data)
l_free(user);
}
+static inline bool p2p_peer_operational(struct p2p_peer *peer)
+{
+ return peer && peer->dev->conn_netdev && !peer->dev->conn_wsc_bss &&
+ !peer->wsc.pending_connect && !peer->dev->disconnecting;
+}
+
static bool p2p_peer_match(const void *a, const void *b)
{
const struct p2p_peer *peer = a;
@@ -442,6 +457,7 @@ static void p2p_connection_reset(struct p2p_device *dev)
* age will be checked on the next scan.
*/
dev->conn_peer = NULL;
+ dev->disconnecting = false;
dev->connections_left++;
if (dev->conn_pin) {
@@ -466,6 +482,9 @@ static void p2p_connection_reset(struct p2p_device *dev)
*/
l_genl_family_cancel(dev->nl80211, dev->conn_new_intf_cmd_id);
+ if (dev->conn_enrollee)
+ wsc_enrollee_cancel(dev->conn_enrollee, false);
+
if (dev->conn_netdev) {
struct l_genl_msg *msg;
uint64_t wdev_id = netdev_get_wdev_id(dev->conn_netdev);
@@ -617,9 +636,254 @@ static const struct frame_xchg_prefix p2p_frame_pd_resp = {
.len = 7,
};
+static void p2p_netdev_connect_cb(struct netdev *netdev,
+ enum netdev_result result,
+ void *event_data, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+ struct p2p_peer *peer = dev->conn_peer;
+
+ l_debug("result: %i", result);
+
+ if (!peer->wsc.pending_connect || dev->disconnecting) {
+ /* Shouldn't happen except maybe in the ABORTED case */
+ return;
+ }
+
+ switch (result) {
+ case NETDEV_RESULT_OK:
+ dbus_pending_reply(&peer->wsc.pending_connect,
+ l_dbus_message_new_method_return(
+ peer->wsc.pending_connect));
+ l_dbus_property_changed(dbus_get_bus(),
+ p2p_peer_get_path(dev->conn_peer),
+ IWD_P2P_PEER_INTERFACE, "Connected");
+ break;
+ case NETDEV_RESULT_AUTHENTICATION_FAILED:
+ case NETDEV_RESULT_ASSOCIATION_FAILED:
+ case NETDEV_RESULT_HANDSHAKE_FAILED:
+ case NETDEV_RESULT_KEY_SETTING_FAILED:
+ /*
+ * In the AUTHENTICATION_FAILED and ASSOCIATION_FAILED
+ * cases there's nothing to disconnect. In the
+ * HANDSHAKE_FAILED and KEY_SETTINGS failed cases
+ * netdev disconnects from the GO automatically and we are
+ * called already from within the disconnect callback,
+ * so we can directly free the netdev.
+ */
+ p2p_connect_failed(dev);
+ break;
+ case NETDEV_RESULT_ABORTED:
+ /*
+ * This case can only be triggered by netdev_disconnect so
+ * we'll wait for its callback before freeing the netdev.
+ * We will also have already replied to
+ * @peer->wsc.pending_connect so we have nothing to do here.
+ */
+ break;
+ }
+}
+
+static void p2p_netdev_event(struct netdev *netdev, enum netdev_event event,
+ void *event_data, void *user_data)
+{
+ struct p2p_device *dev = user_data;
+
+ switch (event) {
+ case NETDEV_EVENT_DISCONNECT_BY_AP:
+ case NETDEV_EVENT_DISCONNECT_BY_SME:
+ /*
+ * We may get a DISCONNECT_BY_SME as a result of a
+ * netdev_disconnect(). In that case let the callback handle
+ * that.
+ */
+ if (dev->disconnecting)
+ break;
+
+ /* If we're not connected, .Connected is already False */
+ if (!p2p_peer_operational(dev->conn_peer)) {
+ p2p_connect_failed(dev);
+ break;
+ }
+
+ l_dbus_property_changed(dbus_get_bus(),
+ p2p_peer_get_path(dev->conn_peer),
+ IWD_P2P_PEER_INTERFACE, "Connected");
+ p2p_connection_reset(dev);
+ break;
+ default:
+ break;
+ };
+}
+
+static void p2p_handshake_event(struct handshake_state *hs,
+ enum handshake_event event, void *user_data,
+ ...)
+{
+ va_list args;
+
+ va_start(args, user_data);
+
+ switch (event) {
+ case HANDSHAKE_EVENT_FAILED:
+ netdev_handshake_failed(hs, va_arg(args, int));
+ break;
+ default:
+ break;
+ }
+
+ va_end(args);
+}
+
+static void p2p_peer_provision_done(int err, struct wsc_credentials_info *creds,
+ unsigned int n_creds, void *user_data)
+{
+ struct p2p_peer *peer = user_data;
+ struct p2p_device *dev = peer->dev;
+ struct scan_bss *bss = dev->conn_wsc_bss;
+ struct handshake_state *hs = NULL;
+ struct iovec ie_iov = {};
+ int r = -EOPNOTSUPP;
+ struct p2p_association_req info = {};
+ struct ie_rsn_info bss_info = {};
+ struct ie_rsn_info rsn_info = {};
+ uint8_t rsne_buf[256];
+
+ l_debug("err=%i n_creds=%u", err, n_creds);
+
+ dev->conn_wsc_bss = NULL;
+ dev->conn_enrollee = NULL;
+
+ l_timeout_remove(dev->config_timeout);
+ l_timeout_remove(dev->go_neg_req_timeout);
+
+ if (err < 0) {
+ if (err == -ECANCELED && peer->wsc.pending_cancel) {
+ dbus_pending_reply(&peer->wsc.pending_cancel,
+ l_dbus_message_new_method_return(
+ peer->wsc.pending_cancel));
+
+ p2p_connection_reset(dev);
+ } else
+ p2p_connect_failed(dev);
+
+ goto done;
+ }
+
+ if (strlen(creds[0].ssid) != bss->ssid_len ||
+ memcmp(creds[0].ssid, bss->ssid, bss->ssid_len)) {
+ l_error("Unsupported: the SSID from the P2P peer's WSC "
+ "credentials doesn't match the SSID from the "
+ "Probe Response IEs");
+ goto not_supported;
+ }
+
+ /*
+ * Apparently some implementations send the intended client's address
+ * here (i.e. our), and some send the target BSS's (their own).
+ */
+ if (memcmp(creds[0].addr, netdev_get_address(dev->conn_netdev), 6) &&
+ memcmp(creds[0].addr, bss->addr, 6)) {
+ char addr1[32], addr2[32];
+
+ l_strlcpy(addr1, util_address_to_string(creds[0].addr),
+ sizeof(addr1));
+ l_strlcpy(addr2, util_address_to_string(
+ netdev_get_address(dev->conn_netdev)),
+ sizeof(addr2));
+ l_error("Error: WSC credentials are not for our client "
+ "interface (%s vs. %s)", addr1, addr2);
+ goto error;
+ }
+
+ if (!bss->rsne || creds[0].security != SECURITY_PSK)
+ goto not_supported;
+
+ info.capability = dev->capability;
+ info.device_info = dev->device_info;
+
+ ie_iov.iov_base = p2p_build_association_req(&info, &ie_iov.iov_len);
+ L_WARN_ON(!ie_iov.iov_base);
+
+ scan_bss_get_rsn_info(bss, &bss_info);
+
+ rsn_info.akm_suites = wiphy_select_akm(dev->wiphy, bss, false);
+ if (!rsn_info.akm_suites)
+ goto not_supported;
+
+ rsn_info.pairwise_ciphers = wiphy_select_cipher(dev->wiphy,
+ bss_info.pairwise_ciphers);
+ rsn_info.group_cipher = wiphy_select_cipher(dev->wiphy,
+ bss_info.group_cipher);
+ if (!rsn_info.pairwise_ciphers || !rsn_info.group_cipher)
+ goto not_supported;
+
+ rsn_info.group_management_cipher = wiphy_select_cipher(dev->wiphy,
+ bss_info.group_management_cipher);
+ rsn_info.mfpc = rsn_info.group_management_cipher != 0;
+ ie_build_rsne(&rsn_info, rsne_buf);
+
+ hs = netdev_handshake_state_new(dev->conn_netdev);
+
+ if (!handshake_state_set_authenticator_ie(hs, bss->rsne))
+ goto not_supported;
+
+ if (!handshake_state_set_supplicant_ie(hs, rsne_buf))
+ goto not_supported;
+
+ handshake_state_set_event_func(hs, p2p_handshake_event, dev);
+ handshake_state_set_ssid(hs, bss->ssid, bss->ssid_len);
+
+ if (creds[0].has_passphrase) {
+ uint8_t psk[32];
+
+ if (crypto_psk_from_passphrase(creds[0].passphrase, bss->ssid,
+ bss->ssid_len, psk) < 0)
+ goto error;
+
+ handshake_state_set_pmk(hs, psk, 32);
+ } else
+ handshake_state_set_pmk(hs, creds[0].psk, 32);
+
+ r = netdev_connect(dev->conn_netdev, bss, hs, &ie_iov, 1,
+ p2p_netdev_event, p2p_netdev_connect_cb, dev);
+ if (r == 0)
+ goto done;
+
+ l_error("netdev_connect error: %s (%i)", strerror(-err), -err);
+
+error:
+not_supported:
+ if (r < 0) {
+ if (hs)
+ handshake_state_free(hs);
+
+ p2p_connect_failed(dev);
+ }
+
+done:
+ l_free(ie_iov.iov_base);
+ scan_bss_free(bss);
+}
+
static void p2p_provision_connect(struct p2p_device *dev)
{
- /* TODO */
+ struct iovec iov;
+ struct p2p_association_req info = {};
+
+ /* Ready to start the provisioning */
+ info.capability = dev->capability;
+ info.device_info = dev->device_info;
+
+ iov.iov_base = p2p_build_association_req(&info, &iov.iov_len);
+ L_WARN_ON(!iov.iov_base);
+
+ dev->conn_enrollee = wsc_enrollee_new(dev->conn_netdev,
+ dev->conn_wsc_bss,
+ dev->conn_pin, &iov, 1,
+ p2p_peer_provision_done,
+ dev->conn_peer);
+ l_free(iov.iov_base);
}
static void p2p_device_netdev_watch_destroy(void *user_data)
@@ -641,7 +905,8 @@ static void p2p_device_netdev_notify(struct netdev *netdev,
switch (event) {
case NETDEV_WATCH_EVENT_UP:
case NETDEV_WATCH_EVENT_NEW:
- if (!dev->conn_wsc_bss || !netdev_get_is_up(netdev))
+ if (!dev->conn_wsc_bss || dev->conn_enrollee ||
+ !netdev_get_is_up(netdev))
break;
p2p_provision_connect(dev);
@@ -1815,6 +2080,23 @@ send_error:
dbus_pending_reply(&peer->wsc.pending_connect, reply);
}
+static void p2p_peer_disconnect_cb(struct netdev *netdev, bool result,
+ void *user_data)
+{
+ struct p2p_peer *peer = user_data;
+ struct p2p_device *dev = peer->dev;
+
+ if (!peer->wsc.pending_cancel || !dev->disconnecting)
+ return;
+
+ dbus_pending_reply(&peer->wsc.pending_cancel,
+ l_dbus_message_new_method_return(
+ peer->wsc.pending_cancel));
+
+ /* Independent of the result this will just drop the whole netdev */
+ p2p_connection_reset(dev);
+}
+
static void p2p_peer_disconnect(struct p2p_peer *peer)
{
struct p2p_device *dev = peer->dev;
@@ -1826,10 +2108,35 @@ static void p2p_peer_disconnect(struct p2p_peer *peer)
goto send_reply;
}
+ if (dev->disconnecting) {
+ reply = dbus_error_busy(message);
+ goto send_reply;
+ }
+
if (peer->wsc.pending_connect)
dbus_pending_reply(&peer->wsc.pending_connect,
dbus_error_aborted(peer->wsc.pending_connect));
+ if (p2p_peer_operational(peer))
+ l_dbus_property_changed(dbus_get_bus(), p2p_peer_get_path(peer),
+ IWD_P2P_PEER_INTERFACE, "Connected");
+
+ dev->disconnecting = true;
+
+ if (dev->conn_enrollee) {
+ wsc_enrollee_cancel(dev->conn_enrollee, true);
+ return;
+ }
+
+ if (dev->conn_netdev && !dev->conn_wsc_bss) {
+ /* Note: in theory we need to add the P2P IEs here too */
+ if (netdev_disconnect(dev->conn_netdev, p2p_peer_disconnect_cb,
+ peer) == 0)
+ return;
+
+ l_error("netdev_disconnect failed");
+ }
+
p2p_connection_reset(dev);
reply = l_dbus_message_new_method_return(message);
@@ -2154,6 +2461,10 @@ static bool p2p_peer_update_existing(struct scan_bss *bss,
/*
* We've seen this peer already, only update the scan_bss object.
+ * We can do this even if peer == peer->dev->conn_peer because
+ * its .bss is not used by .conn_netdev or .conn_enrollee.
+ * .conn_wsc_bss is used for both connections and it doesn't come
+ * from the discovery scan results.
* Do we need to update DBus properties?
*/
scan_bss_free(peer->bss);
@@ -3324,7 +3635,9 @@ static bool p2p_peer_get_connected(struct l_dbus *dbus,
struct l_dbus_message_builder *builder,
void *user_data)
{
- bool connected = false;
+ struct p2p_peer *peer = user_data;
+ bool connected = p2p_peer_operational(peer) &&
+ peer->dev->conn_peer == peer;
l_dbus_message_builder_append_basic(builder, 'b', &connected);
return true;
--
2.20.1
^ permalink raw reply related [flat|nested] 28+ messages in thread* Re: [PATCH 01/17] dbus: Add P2P interface name defines
2020-04-03 16:14 [PATCH 01/17] dbus: Add P2P interface name defines Andrew Zaborowski
` (15 preceding siblings ...)
2020-04-03 16:14 ` [PATCH 17/17] p2p: WSC client provisioning and connection Andrew Zaborowski
@ 2020-04-17 15:16 ` Denis Kenzior
16 siblings, 0 replies; 28+ messages in thread
From: Denis Kenzior @ 2020-04-17 15:16 UTC (permalink / raw)
To: iwd
[-- Attachment #1: Type: text/plain, Size: 171 bytes --]
Hi Andrew,
On 4/3/20 11:14 AM, Andrew Zaborowski wrote:
> ---
> src/dbus.h | 2 ++
> 1 file changed, 2 insertions(+)
>
Applied, thanks.
Regards,
-Denis
^ permalink raw reply [flat|nested] 28+ messages in thread