#include "event.h"
static struct blob_buf b;
+static KVLIST(host_info, kvlist_blob_len);
+
+static void *
+blobmsg_open_table_mac(struct blob_buf *buf, uint8_t *addr)
+{
+ char str[20];
+ sprintf(str, MAC_ADDR_FMT, MAC_ADDR_DATA(addr));
+ return blobmsg_open_table(buf, str);
+}
static int
usteer_ubus_get_clients(struct ubus_context *ctx, struct ubus_object *obj,
{
struct sta_info *si;
struct sta *sta;
- char str[20];
void *_s, *_cur_n;
blob_buf_init(&b, 0);
avl_for_each_element(&stations, sta, avl) {
- sprintf(str, MAC_ADDR_FMT, MAC_ADDR_DATA(sta->addr));
- _s = blobmsg_open_table(&b, str);
+ _s = blobmsg_open_table_mac(&b, sta->addr);
list_for_each_entry(si, &sta->nodes, list) {
_cur_n = blobmsg_open_table(&b, usteer_node_name(si->node));
blobmsg_add_u8(&b, "connected", si->connected);
#define __config_items \
_cfg(BOOL, syslog), \
_cfg(U32, debug_level), \
+ _cfg(BOOL, ipv6), \
+ _cfg(BOOL, local_mode), \
_cfg(U32, sta_block_timeout), \
_cfg(U32, local_sta_timeout), \
_cfg(U32, local_sta_update), \
+ _cfg(U32, max_neighbor_reports), \
_cfg(U32, max_retry_band), \
_cfg(U32, seen_policy_timeout), \
+ _cfg(U32, measurement_report_timeout), \
_cfg(U32, load_balancing_threshold), \
_cfg(U32, band_steering_threshold), \
_cfg(U32, remote_update_interval), \
+ _cfg(U32, remote_node_timeout), \
_cfg(BOOL, assoc_steering), \
_cfg(I32, min_connect_snr), \
_cfg(I32, min_snr), \
+ _cfg(U32, min_snr_kick_delay), \
+ _cfg(U32, steer_reject_timeout), \
+ _cfg(U32, roam_process_timeout), \
_cfg(I32, roam_scan_snr), \
_cfg(U32, roam_scan_tries), \
+ _cfg(U32, roam_scan_timeout), \
_cfg(U32, roam_scan_interval), \
_cfg(I32, roam_trigger_snr), \
_cfg(U32, roam_trigger_interval), \
_cfg(U32, load_kick_delay), \
_cfg(U32, load_kick_min_clients), \
_cfg(U32, load_kick_reason_code), \
+ _cfg(U32, band_steering_interval), \
+ _cfg(I32, band_steering_min_snr), \
+ _cfg(U32, link_measurement_interval), \
_cfg(ARRAY_CB, interfaces), \
_cfg(STRING_CB, node_up_script), \
_cfg(ARRAY_CB, event_log_types), \
}
}
+ usteer_interface_init();
+
return 0;
}
-static void
-usteer_dump_node(struct usteer_node *node)
+void usteer_dump_node(struct blob_buf *buf, struct usteer_node *node)
{
- void *c;
+ void *c, *roam_events;
+
+ c = blobmsg_open_table(buf, usteer_node_name(node));
+ blobmsg_printf(buf, "bssid", MAC_ADDR_FMT, MAC_ADDR_DATA(node->bssid));
+ blobmsg_add_string(buf, "ssid", node->ssid);
+ blobmsg_add_u32(buf, "freq", node->freq);
+ blobmsg_add_u32(buf, "n_assoc", node->n_assoc);
+ blobmsg_add_u32(buf, "noise", node->noise);
+ blobmsg_add_u32(buf, "load", node->load);
+ blobmsg_add_u32(buf, "max_assoc", node->max_assoc);
+
+ roam_events = blobmsg_open_table(buf, "roam_events");
+ blobmsg_add_u32(buf, "source", node->roam_events.source);
+ blobmsg_add_u32(buf, "target", node->roam_events.target);
+ blobmsg_close_table(buf, roam_events);
- c = blobmsg_open_table(&b, usteer_node_name(node));
- blobmsg_add_u32(&b, "freq", node->freq);
- blobmsg_add_u32(&b, "n_assoc", node->n_assoc);
- blobmsg_add_u32(&b, "noise", node->noise);
- blobmsg_add_u32(&b, "load", node->load);
- blobmsg_add_u32(&b, "max_assoc", node->max_assoc);
if (node->rrm_nr)
- blobmsg_add_field(&b, BLOBMSG_TYPE_ARRAY, "rrm_nr",
+ blobmsg_add_field(buf, BLOBMSG_TYPE_ARRAY, "rrm_nr",
blobmsg_data(node->rrm_nr),
blobmsg_data_len(node->rrm_nr));
if (node->node_info)
- blobmsg_add_field(&b, BLOBMSG_TYPE_TABLE, "node_info",
+ blobmsg_add_field(buf, BLOBMSG_TYPE_TABLE, "node_info",
blob_data(node->node_info),
blob_len(node->node_info));
- blobmsg_close_table(&b, c);
+ blobmsg_close_table(buf, c);
+}
+
+void usteer_dump_host(struct blob_buf *buf, struct usteer_remote_host *host)
+{
+ void *c;
+
+ c = blobmsg_open_table(buf, host->addr);
+ blobmsg_add_u32(buf, "id", (uint32_t)(uintptr_t)host->avl.key);
+ if (host->host_info)
+ blobmsg_add_field(buf, BLOBMSG_TYPE_TABLE, "host_info",
+ blobmsg_data(host->host_info),
+ blobmsg_len(host->host_info));
+ blobmsg_close_table(buf, c);
}
static int
blob_buf_init(&b, 0);
for_each_local_node(node)
- usteer_dump_node(node);
+ usteer_dump_node(&b, node);
ubus_send_reply(ctx, req, b.head);
struct blob_attr *msg)
{
struct usteer_remote_host *host;
- void *c;
blob_buf_init(&b, 0);
- avl_for_each_element(&remote_hosts, host, avl) {
- c = blobmsg_open_table(&b, host->addr);
- blobmsg_add_u32(&b, "id", (uint32_t)(uintptr_t)host->avl.key);
- blobmsg_close_table(&b, c);
- }
+ avl_for_each_element(&remote_hosts, host, avl)
+ usteer_dump_host(&b, host);
ubus_send_reply(ctx, req, b.head);
blob_buf_init(&b, 0);
for_each_remote_node(rn)
- usteer_dump_node(&rn->node);
+ usteer_dump_node(&b, &rn->node);
+
+ ubus_send_reply(ctx, req, b.head);
+
+ return 0;
+}
+
+static int
+usteer_ubus_get_connected_clients(struct ubus_context *ctx, struct ubus_object *obj,
+ struct ubus_request_data *req, const char *method,
+ struct blob_attr *msg)
+{
+ struct usteer_measurement_report *mr;
+ struct usteer_node *node;
+ struct sta_info *si;
+ void *n, *s, *t, *a;
+
+ blob_buf_init(&b, 0);
+
+ for_each_local_node(node) {
+ n = blobmsg_open_table(&b, usteer_node_name(node));
+
+ list_for_each_entry(si, &node->sta_info, node_list) {
+ if (si->connected != STA_CONNECTED)
+ continue;
+
+ s = blobmsg_open_table_mac(&b, si->sta->addr);
+ blobmsg_add_u32(&b, "signal", si->signal);
+ blobmsg_add_u64(&b, "created", si->created);
+ blobmsg_add_u64(&b, "seen", si->seen);
+ blobmsg_add_u64(&b, "connected_since", si->connected_since);
+ blobmsg_add_u64(&b, "last_connected", si->last_connected);
+
+ t = blobmsg_open_table(&b, "snr-kick");
+ blobmsg_add_u32(&b, "seen-below", si->below_min_snr);
+ blobmsg_close_table(&b, t);
+
+ t = blobmsg_open_table(&b, "load-kick");
+ blobmsg_add_u32(&b, "count", si->kick_count);
+ blobmsg_close_table(&b, t);
+
+ t = blobmsg_open_table(&b, "roam-state-machine");
+ blobmsg_add_u32(&b, "tries", si->roam_tries);
+ blobmsg_add_u64(&b, "event", si->roam_event);
+ blobmsg_add_u64(&b, "kick", si->roam_kick);
+ blobmsg_add_u64(&b, "scan_start", si->roam_scan_start);
+ blobmsg_add_u64(&b, "scan_timeout_start", si->roam_scan_timeout_start);
+ blobmsg_close_table(&b, t);
+
+ t = blobmsg_open_table(&b, "bss-transition-response");
+ blobmsg_add_u32(&b, "status-code", si->bss_transition_response.status_code);
+ blobmsg_add_u64(&b, "timestamp", si->bss_transition_response.timestamp);
+ blobmsg_close_table(&b, t);
+
+ /* Beacon measurement modes */
+ a = blobmsg_open_array(&b, "beacon-measurement-modes");
+ if (usteer_sta_supports_beacon_measurement_mode(si, BEACON_MEASUREMENT_PASSIVE))
+ blobmsg_add_string(&b, "", "PASSIVE");
+ if (usteer_sta_supports_beacon_measurement_mode(si, BEACON_MEASUREMENT_ACTIVE))
+ blobmsg_add_string(&b, "", "ACTIVE");
+ if (usteer_sta_supports_beacon_measurement_mode(si, BEACON_MEASUREMENT_TABLE))
+ blobmsg_add_string(&b, "", "TABLE");
+ blobmsg_close_array(&b, a);
+
+ /* Link-Measurement support */
+ blobmsg_add_u8(&b, "link-measurement", usteer_sta_supports_link_measurement(si));
+
+ /* BSS-Transition support */
+ blobmsg_add_u8(&b, "bss-transition-management", si->bss_transition);
+
+ /* MBO support */
+ blobmsg_add_u8(&b, "multi-band-operation", si->mbo);
+
+ /* Measurements */
+ a = blobmsg_open_array(&b, "measurements");
+ list_for_each_entry(mr, &si->sta->measurements, sta_list) {
+ t = blobmsg_open_table(&b, "");
+ blobmsg_add_string(&b, "node", usteer_node_name(mr->node));
+ blobmsg_add_u32(&b, "rcpi", mr->rcpi);
+ blobmsg_add_u32(&b, "rsni", mr->rsni);
+ blobmsg_add_u32(&b, "rssi", usteer_measurement_get_rssi(mr));
+ blobmsg_add_u64(&b, "timestamp", mr->timestamp);
+ blobmsg_close_table(&b, t);
+ }
+ blobmsg_close_array(&b, a);
+
+ blobmsg_close_table(&b, s);
+ }
+
+ blobmsg_close_table(&b, n);
+ }
ubus_send_reply(ctx, req, b.head);
};
static void
-__usteer_ubus_update_node_data(struct usteer_local_node *ln, struct blob_attr *data,
- bool delete)
+usteer_update_kvlist_data(struct kvlist *kv, struct blob_attr *data,
+ bool delete)
{
struct blob_attr *cur;
int rem;
blobmsg_for_each_attr(cur, data, rem) {
if (delete)
- kvlist_delete(&ln->node_info, blobmsg_get_string(cur));
+ kvlist_delete(kv, blobmsg_get_string(cur));
else
- kvlist_set(&ln->node_info, blobmsg_name(cur), cur);
+ kvlist_set(kv, blobmsg_name(cur), cur);
}
+}
- usteer_local_node_update_node_info(ln);
+static void
+usteer_update_kvlist_blob(struct blob_attr **dest, struct kvlist *kv)
+{
+ struct blob_attr *val;
+ const char *name;
+
+ blob_buf_init(&b, 0);
+ kvlist_for_each(kv, name, val)
+ blobmsg_add_field(&b, blobmsg_type(val), name,
+ blobmsg_data(val), blobmsg_len(val));
+
+ val = b.head;
+ if (!blobmsg_len(val))
+ val = NULL;
+
+ usteer_node_set_blob(dest, val);
}
static int
if (!ln)
return UBUS_STATUS_NOT_FOUND;
- __usteer_ubus_update_node_data(ln, val, delete);
+ usteer_update_kvlist_data(&ln->node_info, val, delete);
+ usteer_update_kvlist_blob(&ln->node.node_info, &ln->node_info);
return 0;
}
- avl_for_each_element(&local_nodes, ln, node.avl)
- __usteer_ubus_update_node_data(ln, val, delete);
+ usteer_update_kvlist_data(&host_info, val, delete);
+ usteer_update_kvlist_blob(&host_info_blob, &host_info);
return 0;
}
UBUS_METHOD_NOARG("local_info", usteer_ubus_local_info),
UBUS_METHOD_NOARG("remote_hosts", usteer_ubus_remote_hosts),
UBUS_METHOD_NOARG("remote_info", usteer_ubus_remote_info),
+ UBUS_METHOD_NOARG("connected_clients", usteer_ubus_get_connected_clients),
UBUS_METHOD_NOARG("get_clients", usteer_ubus_get_clients),
UBUS_METHOD("get_client_info", usteer_ubus_get_client_info, client_arg),
UBUS_METHOD_NOARG("get_config", usteer_ubus_get_config),
.n_methods = ARRAY_SIZE(usteer_methods),
};
-static void
+static bool
usteer_add_nr_entry(struct usteer_node *ln, struct usteer_node *node)
{
struct blobmsg_policy policy[3] = {
struct blob_attr *tb[3];
if (!node->rrm_nr)
- return;
+ return false;
if (strcmp(ln->ssid, node->ssid) != 0)
- return;
+ return false;
+
+ if (!usteer_policy_node_below_max_assoc(node))
+ return false;
blobmsg_parse_array(policy, ARRAY_SIZE(tb), tb,
blobmsg_data(node->rrm_nr),
blobmsg_data_len(node->rrm_nr));
if (!tb[2])
- return;
+ return false;
blobmsg_add_field(&b, BLOBMSG_TYPE_STRING, "",
blobmsg_data(tb[2]),
blobmsg_data_len(tb[2]));
+
+ return true;
}
-int usteer_ubus_notify_client_disassoc(struct sta_info *si)
+static void
+usteer_ubus_disassoc_add_neighbor(struct sta_info *si, struct usteer_node *node)
+{
+ void *c;
+
+ c = blobmsg_open_array(&b, "neighbors");
+ usteer_add_nr_entry(si->node, node);
+ blobmsg_close_array(&b, c);
+}
+
+static void
+usteer_ubus_disassoc_add_neighbors(struct sta_info *si)
+{
+ struct usteer_node *node, *last_remote_neighbor = NULL;
+ int i = 0;
+ void *c;
+
+ c = blobmsg_open_array(&b, "neighbors");
+ for_each_local_node(node) {
+ if (i >= config.max_neighbor_reports)
+ break;
+ if (si->node == node)
+ continue;
+ if (usteer_add_nr_entry(si->node, node))
+ i++;
+ }
+
+ while (i < config.max_neighbor_reports) {
+ node = usteer_node_get_next_neighbor(si->node, last_remote_neighbor);
+ if (!node) {
+ /* No more nodes available */
+ break;
+ }
+
+ last_remote_neighbor = node;
+ if (usteer_add_nr_entry(si->node, node))
+ i++;
+ }
+ blobmsg_close_array(&b, c);
+}
+
+int usteer_ubus_bss_transition_request(struct sta_info *si,
+ uint8_t dialog_token,
+ bool disassoc_imminent,
+ bool abridged,
+ uint8_t validity_period,
+ struct usteer_node *target_node)
+{
+ struct usteer_local_node *ln = container_of(si->node, struct usteer_local_node, node);
+
+ blob_buf_init(&b, 0);
+ blobmsg_printf(&b, "addr", MAC_ADDR_FMT, MAC_ADDR_DATA(si->sta->addr));
+ blobmsg_add_u32(&b, "dialog_token", dialog_token);
+ blobmsg_add_u8(&b, "disassociation_imminent", disassoc_imminent);
+ blobmsg_add_u8(&b, "abridged", abridged);
+ blobmsg_add_u32(&b, "validity_period", validity_period);
+ if (!target_node) {
+ usteer_ubus_disassoc_add_neighbors(si);
+ } else {
+ usteer_ubus_disassoc_add_neighbor(si, target_node);
+ }
+ return ubus_invoke(ubus_ctx, ln->obj_id, "bss_transition_request", b.head, NULL, 0, 100);
+}
+
+int usteer_ubus_band_steering_request(struct sta_info *si)
{
struct usteer_local_node *ln = container_of(si->node, struct usteer_local_node, node);
- struct usteer_remote_node *rn;
struct usteer_node *node;
void *c;
blob_buf_init(&b, 0);
blobmsg_printf(&b, "addr", MAC_ADDR_FMT, MAC_ADDR_DATA(si->sta->addr));
- blobmsg_add_u32(&b, "duration", config.roam_kick_delay);
+ blobmsg_add_u32(&b, "dialog_token", 0);
+ blobmsg_add_u8(&b, "disassociation_imminent", false);
+ blobmsg_add_u8(&b, "abridged", false);
+ blobmsg_add_u32(&b, "validity_period", 100);
+
c = blobmsg_open_array(&b, "neighbors");
- for_each_local_node(node)
+ for_each_local_node(node) {
+ if (!usteer_band_steering_is_target(ln, node))
+ continue;
+
usteer_add_nr_entry(si->node, node);
- for_each_remote_node(rn)
- usteer_add_nr_entry(si->node, &rn->node);
+ }
blobmsg_close_array(&b, c);
- return ubus_invoke(ubus_ctx, ln->obj_id, "wnm_disassoc_imminent", b.head, NULL, 0, 100);
+
+ return ubus_invoke(ubus_ctx, ln->obj_id, "bss_transition_request", b.head, NULL, 0, 100);
+}
+
+int usteer_ubus_trigger_link_measurement(struct sta_info *si)
+{
+ struct usteer_local_node *ln = container_of(si->node, struct usteer_local_node, node);
+
+ if (!usteer_sta_supports_link_measurement(si))
+ return 0;
+
+ blob_buf_init(&b, 0);
+ blobmsg_printf(&b, "addr", MAC_ADDR_FMT, MAC_ADDR_DATA(si->sta->addr));
+ blobmsg_add_u32(&b, "tx-power-used", 5);
+ blobmsg_add_u32(&b, "tx-power-max", 10);
+ return ubus_invoke(ubus_ctx, ln->obj_id, "link_measurement_req", b.head, NULL, 0, 100);
}
int usteer_ubus_trigger_client_scan(struct sta_info *si)
{
struct usteer_local_node *ln = container_of(si->node, struct usteer_local_node, node);
+ if (!usteer_sta_supports_beacon_measurement_mode(si, BEACON_MEASUREMENT_ACTIVE)) {
+ MSG(DEBUG, "STA does not support beacon measurement sta=" MAC_ADDR_FMT "\n", MAC_ADDR_DATA(si->sta->addr));
+ return 0;
+ }
+
si->scan_band = !si->scan_band;
blob_buf_init(&b, 0);
blobmsg_printf(&b, "addr", MAC_ADDR_FMT, MAC_ADDR_DATA(si->sta->addr));
- blobmsg_add_u32(&b, "mode", 1);
- blobmsg_add_u32(&b, "duration", 65535);
- blobmsg_add_u32(&b, "channel", 255);
+ blobmsg_add_string(&b, "ssid", si->node->ssid);
+ blobmsg_add_u32(&b, "mode", BEACON_MEASUREMENT_ACTIVE);
+ blobmsg_add_u32(&b, "duration", config.roam_scan_interval / 100);
+ blobmsg_add_u32(&b, "channel", 0);
blobmsg_add_u32(&b, "op_class", si->scan_band ? 1 : 12);
return ubus_invoke(ubus_ctx, ln->obj_id, "rrm_beacon_req", b.head, NULL, 0, 100);
}
blobmsg_add_u32(&b, "reason", config.load_kick_reason_code);
blobmsg_add_u8(&b, "deauth", 1);
ubus_invoke(ubus_ctx, ln->obj_id, "del_client", b.head, NULL, 0, 100);
- si->connected = 0;
+ usteer_sta_disconnected(si);
si->roam_kick = current_time;
}
projects / project / usteer.git / blobdiff