Kernel
/
iwd
mirror of https://git.kernel.org/pub/scm/network/wireless/iwd.git
3
0
Fork 0
Code Releases Activity

client: Move properties from Device to Station

This commit is contained in:
Denis Kenzior 2018-09-14 09:56:59 -05:00
parent 247b2ccc5c
commit 6b46beef45
5 changed files with 271 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile.am
View File

@ -171,7 +171,7 @@ client_iwctl_SOURCES = client/main.c \
client/known-networks.c \
client/network.h client/network.c \
client/properties.h client/properties.c \
client/wsc.c
client/wsc.c client/station.c
client_iwctl_LDADD = ell/libell-internal.la -lreadline
endif

1
client/dbus-proxy.h
View File

@ -32,6 +32,7 @@ struct property_value_options;
#define IWD_KNOWN_NETWORK_INTREFACE "net.connman.iwd.KnownNetwork"
#define IWD_NETWORK_INTERFACE "net.connman.iwd.Network"
#define IWD_WSC_INTERFACE "net.connman.iwd.WiFiSimpleConfiguration"
#define IWD_STATION_INTERFACE "net.connman.iwd.Station"
typedef bool (*proxy_property_match_func_t) (const void *a, const void *b);

90
client/device.c
View File

@ -35,14 +35,11 @@
struct device {
bool powered;
bool scanning;
bool wds;
char *address;
char *name;
char *state;
char *mode;
const struct proxy_interface *adapter;
const struct proxy_interface *connected_network;
};
static struct proxy_interface *default_device;
@ -56,13 +53,6 @@ static void display_device(const struct proxy_interface *proxy)
l_free(caption);
if (device->connected_network) {
display("%s%*s %-*s%-*s\n", MARGIN, 8, "",
20, "Connected network",
47, proxy_interface_get_identity_str(
device->connected_network) ? : "");
}
if (device->adapter) {
display("%s%*s %-*s%-*s\n", MARGIN, 8, "", 20, "Adapter", 47,
proxy_interface_get_identity_str(
@ -155,45 +145,6 @@ static void update_address(void *data, struct l_dbus_message_iter *variant)
device->address = l_strdup(value);
}
static const char *get_state(const void *data)
{
const struct device *device = data;
return device->state;
}
static void update_state(void *data, struct l_dbus_message_iter *variant)
{
struct device *device = data;
const char *value;
l_free(device->state);
if (!l_dbus_message_iter_get_variant(variant, "s", &value)) {
device->state = NULL;
return;
}
device->state = l_strdup(value);
}
static void update_connected_network(void *data,
struct l_dbus_message_iter *variant)
{
struct device *device = data;
const char *path;
if (!l_dbus_message_iter_get_variant(variant, "o", &path)) {
device->connected_network = NULL;
return;
}
device->connected_network = proxy_interface_find(IWD_NETWORK_INTERFACE,
path);
}
static const char *get_powered_tostr(const void *data)
{
const struct device *device = data;
@ -236,27 +187,6 @@ static void update_wds(void *data, struct l_dbus_message_iter *variant)
device->wds = value;
}
static const char *get_scanning_tostr(const void *data)
{
const struct device *device = data;
return device->scanning ? "yes" : "no";
}
static void update_scanning(void *data, struct l_dbus_message_iter *variant)
{
struct device *device = data;
bool value;
if (!l_dbus_message_iter_get_variant(variant, "b", &value)) {
device->scanning = false;
return;
}
device->scanning = value;
}
static void update_adapter(void *data, struct l_dbus_message_iter *variant)
{
struct device *device = data;
@ -283,10 +213,6 @@ static const struct proxy_interface_property device_properties[] = {
{ "WDS", "b", update_wds, get_wds_tostr, true,
properties_builder_append_on_off_variant,
properties_on_off_opts },
{ "Scanning", "b", update_scanning, get_scanning_tostr },
{ "State", "s", update_state, get_state },
{ "ConnectedNetwork",
"o", update_connected_network },
{ }
};
@ -432,11 +358,9 @@ static void device_destroy(void *data)
l_free(device->address);
l_free(device->name);
l_free(device->state);
l_free(device->mode);
device->adapter = NULL;
device->connected_network = NULL;
l_free(device);
}
@ -452,12 +376,10 @@ static void display_device_inline(const char *margin, const void *data)
else
adapter_str = "-";
display("%s%-*s%-*s%-*s%-*s%-*s\n", margin,
display("%s%-*s%-*s%-*s\n", margin,
20, device->name ? : "",
20, device->address ? : "",
15, device->state ? : "",
10, adapter_str,
8, device->scanning ? "scanning" : "");
10, adapter_str);
}
static const char *device_identity(void *data)
@ -831,6 +753,14 @@ char *device_ad_hoc_family_arg_completion(const char *text, int state)
IWD_AD_HOC_INTERFACE);
}
char *device_station_family_arg_completion(const char *text, int state)
{
return proxy_property_str_completion(&device_interface_type,
match_by_partial_name,
"Name", text, state,
IWD_STATION_INTERFACE);
}
static char *family_arg_completion(const char *text, int state)
{
static bool first_pass;

4
client/device.h
View File

@ -23,9 +23,9 @@
struct proxy_interface;
char *device_wsc_family_arg_completion(const char *text, int state);
char *device_ap_family_arg_completion(const char *text, int state);
char *device_ad_hoc_family_arg_completion(const char *text, int state);
char *device_station_family_arg_completion(const char *text, int state);
const struct proxy_interface *device_proxy_find(const char *device_name,
const char *interface);

257
client/station.c Normal file
View File

@ -0,0 +1,257 @@
/*
*
* Wireless daemon for Linux
*
* Copyright (C) 2018 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 <ell/ell.h>
#include "command.h"
#include "dbus-proxy.h"
#include "device.h"
#include "display.h"
struct station {
bool scanning;
char *state;
const struct proxy_interface *connected_network;
};
static void *station_create(void)
{
return l_new(struct station, 1);
}
static void station_destroy(void *data)
{
struct station *station = data;
l_free(station->state);
station->connected_network = NULL;
l_free(station);
}
static const struct proxy_interface_type_ops station_ops = {
.create = station_create,
.destroy = station_destroy,
};
static const char *get_scanning_tostr(const void *data)
{
const struct station *station = data;
return station->scanning ? "yes" : "no";
}
static void update_scanning(void *data, struct l_dbus_message_iter *variant)
{
struct station *station = data;
bool value;
if (!l_dbus_message_iter_get_variant(variant, "b", &value)) {
station->scanning = false;
return;
}
station->scanning = value;
}
static const char *get_state(const void *data)
{
const struct station *station = data;
return station->state;
}
static void update_state(void *data, struct l_dbus_message_iter *variant)
{
struct station *station = data;
const char *value;
l_free(station->state);
if (!l_dbus_message_iter_get_variant(variant, "s", &value)) {
station->state = NULL;
return;
}
station->state = l_strdup(value);
}
static void update_connected_network(void *data,
struct l_dbus_message_iter *variant)
{
struct station *station = data;
const char *path;
if (!l_dbus_message_iter_get_variant(variant, "o", &path)) {
station->connected_network = NULL;
return;
}
station->connected_network = proxy_interface_find(IWD_NETWORK_INTERFACE,
path);
}
static const struct proxy_interface_property station_properties[] = {
{ "Scanning", "b", update_scanning, get_scanning_tostr },
{ "State", "s", update_state, get_state },
{ "ConnectedNetwork",
"o", update_connected_network },
{ }
};
static struct proxy_interface_type station_interface_type = {
.interface = IWD_STATION_INTERFACE,
.properties = station_properties,
.ops = &station_ops,
};
static void display_station_inline(const char *margin, const void *data)
{
const struct proxy_interface *station_i = data;
const struct station *station = proxy_interface_get_data(station_i);
struct proxy_interface *device_i =
proxy_interface_find(IWD_DEVICE_INTERFACE,
proxy_interface_get_path(station_i));
const char *identity;
if (!device_i)
return;
identity = proxy_interface_get_identity_str(device_i);
if (!identity)
return;
display("%s%-*s%-*s%-*s\n", margin,
20, identity,
15, station->state ? : "",
8, station->scanning ? "scanning" : "");
}
static enum cmd_status cmd_list(const char *device_name, char **argv, int argc)
{
const struct l_queue_entry *entry;
struct l_queue *match =
proxy_interface_find_all(IWD_STATION_INTERFACE, NULL, NULL);
display_table_header("Devices in Station Mode", MARGIN "%-*s%-*s%-*s",
20, "Name", 15, "State", 8, "Scanning");
if (!match) {
display("No devices in Station mode available.\n");
display_table_footer();
return CMD_STATUS_DONE;
}
for (entry = l_queue_get_entries(match); entry; entry = entry->next) {
const struct proxy_interface *station = entry->data;
display_station_inline(MARGIN, station);
}
display_table_footer();
l_queue_destroy(match, NULL);
return CMD_STATUS_DONE;
}
static const struct command station_commands[] = {
{ NULL, "list", NULL, cmd_list, "List Ad-Hoc devices", true },
{ }
};
static char *family_arg_completion(const char *text, int state)
{
static bool first_pass;
static size_t index;
static size_t len;
const char *cmd;
if (!state) {
index = 0;
len = strlen(text);
first_pass = true;
}
while ((cmd = station_commands[index].cmd)) {
if (station_commands[index++].entity)
continue;
if (!strncmp(cmd, text, len))
return l_strdup(cmd);
}
if (first_pass) {
state = 0;
first_pass = false;
}
return device_station_family_arg_completion(text, state);
}
static char *entity_arg_completion(const char *text, int state)
{
return command_entity_arg_completion(text, state, station_commands);
}
static struct command_family station_command_family = {
.caption = "Station",
.name = "station",
.command_list = station_commands,
.family_arg_completion = family_arg_completion,
.entity_arg_completion = entity_arg_completion,
};
static int station_command_family_init(void)
{
command_family_register(&station_command_family);
return 0;
}
static void station_command_family_exit(void)
{
command_family_unregister(&station_command_family);
}
COMMAND_FAMILY(station_command_family, station_command_family_init,
station_command_family_exit)
static int station_interface_init(void)
{
proxy_interface_type_register(&station_interface_type);
return 0;
}
static void station_interface_exit(void)
{
proxy_interface_type_unregister(&station_interface_type);
}
INTERFACE_TYPE(station_interface_type,
station_interface_init, station_interface_exit)