2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License.
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9 * GNU General Public License for more details.
11 * You should have received a copy of the GNU General Public License
12 * along with this program; if not, write to the Free Software
13 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
15 * Copyright (C) 2020 embedd.ch
16 * Copyright (C) 2020 Felix Fietkau <nbd@nbd.name>
17 * Copyright (C) 2020 John Crispin <john@phrozen.org>
20 #include <sys/types.h>
21 #include <sys/socket.h>
22 #include <net/ethernet.h>
24 #include <netinet/ether.h>
31 static struct blob_buf b
;
32 static KVLIST(host_info
, kvlist_blob_len
);
35 blobmsg_open_table_mac(struct blob_buf
*buf
, uint8_t *addr
)
38 sprintf(str
, MAC_ADDR_FMT
, MAC_ADDR_DATA(addr
));
39 return blobmsg_open_table(buf
, str
);
43 usteer_ubus_get_clients(struct ubus_context
*ctx
, struct ubus_object
*obj
,
44 struct ubus_request_data
*req
, const char *method
,
45 struct blob_attr
*msg
)
52 avl_for_each_element(&stations
, sta
, avl
) {
53 _s
= blobmsg_open_table_mac(&b
, sta
->addr
);
54 list_for_each_entry(si
, &sta
->nodes
, list
) {
55 _cur_n
= blobmsg_open_table(&b
, usteer_node_name(si
->node
));
56 blobmsg_add_u8(&b
, "connected", si
->connected
);
57 blobmsg_add_u32(&b
, "signal", si
->signal
);
58 blobmsg_close_table(&b
, _cur_n
);
60 blobmsg_close_table(&b
, _s
);
62 ubus_send_reply(ctx
, req
, b
.head
);
66 static struct blobmsg_policy client_arg
[] = {
67 { .name
= "address", .type
= BLOBMSG_TYPE_STRING
, },
71 usteer_ubus_add_stats(struct sta_info_stats
*stats
, const char *name
)
75 s
= blobmsg_open_table(&b
, name
);
76 blobmsg_add_u32(&b
, "requests", stats
->requests
);
77 blobmsg_add_u32(&b
, "blocked_cur", stats
->blocked_cur
);
78 blobmsg_add_u32(&b
, "blocked_total", stats
->blocked_total
);
79 blobmsg_close_table(&b
, s
);
83 usteer_ubus_get_client_info(struct ubus_context
*ctx
, struct ubus_object
*obj
,
84 struct ubus_request_data
*req
, const char *method
,
85 struct blob_attr
*msg
)
89 struct blob_attr
*mac_str
;
91 void *_n
, *_cur_n
, *_s
;
94 blobmsg_parse(client_arg
, 1, &mac_str
, blob_data(msg
), blob_len(msg
));
96 return UBUS_STATUS_INVALID_ARGUMENT
;
98 mac
= (uint8_t *) ether_aton(blobmsg_data(mac_str
));
100 return UBUS_STATUS_INVALID_ARGUMENT
;
102 sta
= usteer_sta_get(mac
, false);
104 return UBUS_STATUS_NOT_FOUND
;
106 blob_buf_init(&b
, 0);
107 blobmsg_add_u8(&b
, "2ghz", sta
->seen_2ghz
);
108 blobmsg_add_u8(&b
, "5ghz", sta
->seen_5ghz
);
109 _n
= blobmsg_open_table(&b
, "nodes");
110 list_for_each_entry(si
, &sta
->nodes
, list
) {
111 _cur_n
= blobmsg_open_table(&b
, usteer_node_name(si
->node
));
112 blobmsg_add_u8(&b
, "connected", si
->connected
);
113 blobmsg_add_u32(&b
, "signal", si
->signal
);
114 _s
= blobmsg_open_table(&b
, "stats");
115 for (i
= 0; i
< __EVENT_TYPE_MAX
; i
++)
116 usteer_ubus_add_stats(&si
->stats
[EVENT_TYPE_PROBE
], event_types
[i
]);
117 blobmsg_close_table(&b
, _s
);
118 blobmsg_close_table(&b
, _cur_n
);
120 blobmsg_close_table(&b
, _n
);
122 ubus_send_reply(ctx
, req
, b
.head
);
142 void (*set
)(struct blob_attr
*data
);
143 void (*get
)(struct blob_buf
*buf
);
148 #define __config_items \
149 _cfg(BOOL, syslog), \
150 _cfg(U32, debug_level), \
152 _cfg(BOOL, local_mode), \
153 _cfg(U32, sta_block_timeout), \
154 _cfg(U32, local_sta_timeout), \
155 _cfg(U32, local_sta_update), \
156 _cfg(U32, max_neighbor_reports), \
157 _cfg(U32, max_retry_band), \
158 _cfg(U32, seen_policy_timeout), \
159 _cfg(U32, measurement_report_timeout), \
160 _cfg(U32, load_balancing_threshold), \
161 _cfg(U32, band_steering_threshold), \
162 _cfg(U32, remote_update_interval), \
163 _cfg(U32, remote_node_timeout), \
164 _cfg(BOOL, assoc_steering), \
165 _cfg(I32, min_connect_snr), \
166 _cfg(I32, min_snr), \
167 _cfg(U32, min_snr_kick_delay), \
168 _cfg(U32, steer_reject_timeout), \
169 _cfg(U32, roam_process_timeout), \
170 _cfg(I32, roam_scan_snr), \
171 _cfg(U32, roam_scan_tries), \
172 _cfg(U32, roam_scan_timeout), \
173 _cfg(U32, roam_scan_interval), \
174 _cfg(I32, roam_trigger_snr), \
175 _cfg(U32, roam_trigger_interval), \
176 _cfg(U32, roam_kick_delay), \
177 _cfg(U32, signal_diff_threshold), \
178 _cfg(U32, initial_connect_delay), \
179 _cfg(BOOL, load_kick_enabled), \
180 _cfg(U32, load_kick_threshold), \
181 _cfg(U32, load_kick_delay), \
182 _cfg(U32, load_kick_min_clients), \
183 _cfg(U32, load_kick_reason_code), \
184 _cfg(U32, band_steering_interval), \
185 _cfg(I32, band_steering_min_snr), \
186 _cfg(U32, link_measurement_interval), \
187 _cfg(ARRAY_CB, interfaces), \
188 _cfg(STRING_CB, node_up_script), \
189 _cfg(ARRAY_CB, event_log_types), \
190 _cfg(ARRAY_CB, ssid_list)
193 #define _cfg(_type, _name) CFG_##_name
199 static const struct blobmsg_policy config_policy
[__CFG_MAX
] = {
200 #define _cfg_policy(_type, _name) [CFG_##_name] = { .name = #_name, .type = BLOBMSG_TYPE_ ## _type }
201 #define _cfg_policy_BOOL(_name) _cfg_policy(BOOL, _name)
202 #define _cfg_policy_U32(_name) _cfg_policy(INT32, _name)
203 #define _cfg_policy_I32(_name) _cfg_policy(INT32, _name)
204 #define _cfg_policy_ARRAY_CB(_name) _cfg_policy(ARRAY, _name)
205 #define _cfg_policy_STRING_CB(_name) _cfg_policy(STRING, _name)
206 #define _cfg(_type, _name) _cfg_policy_##_type(_name)
211 static const struct cfg_item config_data
[__CFG_MAX
] = {
212 #define _cfg_data_BOOL(_name) .ptr.BOOL = &config._name
213 #define _cfg_data_U32(_name) .ptr.U32 = &config._name
214 #define _cfg_data_I32(_name) .ptr.I32 = &config._name
215 #define _cfg_data_ARRAY_CB(_name) .ptr.CB = { .set = config_set_##_name, .get = config_get_##_name }
216 #define _cfg_data_STRING_CB(_name) .ptr.CB = { .set = config_set_##_name, .get = config_get_##_name }
217 #define _cfg(_type, _name) [CFG_##_name] = { .type = CFG_##_type, _cfg_data_##_type(_name) }
223 usteer_ubus_get_config(struct ubus_context
*ctx
, struct ubus_object
*obj
,
224 struct ubus_request_data
*req
, const char *method
,
225 struct blob_attr
*msg
)
229 blob_buf_init(&b
, 0);
230 for (i
= 0; i
< __CFG_MAX
; i
++) {
231 switch(config_data
[i
].type
) {
233 blobmsg_add_u8(&b
, config_policy
[i
].name
,
234 *config_data
[i
].ptr
.BOOL
);
238 blobmsg_add_u32(&b
, config_policy
[i
].name
,
239 *config_data
[i
].ptr
.U32
);
243 config_data
[i
].ptr
.CB
.get(&b
);
247 ubus_send_reply(ctx
, req
, b
.head
);
252 usteer_ubus_set_config(struct ubus_context
*ctx
, struct ubus_object
*obj
,
253 struct ubus_request_data
*req
, const char *method
,
254 struct blob_attr
*msg
)
256 struct blob_attr
*tb
[__CFG_MAX
];
259 if (!strcmp(method
, "set_config"))
260 usteer_init_defaults();
262 blobmsg_parse(config_policy
, __CFG_MAX
, tb
, blob_data(msg
), blob_len(msg
));
263 for (i
= 0; i
< __CFG_MAX
; i
++) {
264 switch(config_data
[i
].type
) {
269 *config_data
[i
].ptr
.BOOL
= blobmsg_get_u8(tb
[i
]);
276 *config_data
[i
].ptr
.U32
= blobmsg_get_u32(tb
[i
]);
280 config_data
[i
].ptr
.CB
.set(tb
[i
]);
285 usteer_interface_init();
290 void usteer_dump_node(struct blob_buf
*buf
, struct usteer_node
*node
)
292 void *c
, *roam_events
;
294 c
= blobmsg_open_table(buf
, usteer_node_name(node
));
295 blobmsg_printf(buf
, "bssid", MAC_ADDR_FMT
, MAC_ADDR_DATA(node
->bssid
));
296 blobmsg_add_string(buf
, "ssid", node
->ssid
);
297 blobmsg_add_u32(buf
, "freq", node
->freq
);
298 blobmsg_add_u32(buf
, "n_assoc", node
->n_assoc
);
299 blobmsg_add_u32(buf
, "noise", node
->noise
);
300 blobmsg_add_u32(buf
, "load", node
->load
);
301 blobmsg_add_u32(buf
, "max_assoc", node
->max_assoc
);
303 roam_events
= blobmsg_open_table(buf
, "roam_events");
304 blobmsg_add_u32(buf
, "source", node
->roam_events
.source
);
305 blobmsg_add_u32(buf
, "target", node
->roam_events
.target
);
306 blobmsg_close_table(buf
, roam_events
);
309 blobmsg_add_field(buf
, BLOBMSG_TYPE_ARRAY
, "rrm_nr",
310 blobmsg_data(node
->rrm_nr
),
311 blobmsg_data_len(node
->rrm_nr
));
313 blobmsg_add_field(buf
, BLOBMSG_TYPE_TABLE
, "node_info",
314 blob_data(node
->node_info
),
315 blob_len(node
->node_info
));
317 blobmsg_close_table(buf
, c
);
320 void usteer_dump_host(struct blob_buf
*buf
, struct usteer_remote_host
*host
)
324 c
= blobmsg_open_table(buf
, host
->addr
);
325 blobmsg_add_u32(buf
, "id", (uint32_t)(uintptr_t)host
->avl
.key
);
327 blobmsg_add_field(buf
, BLOBMSG_TYPE_TABLE
, "host_info",
328 blobmsg_data(host
->host_info
),
329 blobmsg_len(host
->host_info
));
330 blobmsg_close_table(buf
, c
);
334 usteer_ubus_local_info(struct ubus_context
*ctx
, struct ubus_object
*obj
,
335 struct ubus_request_data
*req
, const char *method
,
336 struct blob_attr
*msg
)
338 struct usteer_node
*node
;
340 blob_buf_init(&b
, 0);
342 for_each_local_node(node
)
343 usteer_dump_node(&b
, node
);
345 ubus_send_reply(ctx
, req
, b
.head
);
351 usteer_ubus_remote_hosts(struct ubus_context
*ctx
, struct ubus_object
*obj
,
352 struct ubus_request_data
*req
, const char *method
,
353 struct blob_attr
*msg
)
355 struct usteer_remote_host
*host
;
357 blob_buf_init(&b
, 0);
359 avl_for_each_element(&remote_hosts
, host
, avl
)
360 usteer_dump_host(&b
, host
);
362 ubus_send_reply(ctx
, req
, b
.head
);
368 usteer_ubus_remote_info(struct ubus_context
*ctx
, struct ubus_object
*obj
,
369 struct ubus_request_data
*req
, const char *method
,
370 struct blob_attr
*msg
)
372 struct usteer_remote_node
*rn
;
374 blob_buf_init(&b
, 0);
376 for_each_remote_node(rn
)
377 usteer_dump_node(&b
, &rn
->node
);
379 ubus_send_reply(ctx
, req
, b
.head
);
384 static const char *usteer_get_roam_sm_name(enum roam_trigger_state state
)
387 case ROAM_TRIGGER_IDLE
:
388 return "ROAM_TRIGGER_IDLE";
389 case ROAM_TRIGGER_SCAN
:
390 return "ROAM_TRIGGER_SCAN";
391 case ROAM_TRIGGER_SCAN_DONE
:
392 return "ROAM_TRIGGER_SCAN_DONE";
398 usteer_ubus_get_connected_clients(struct ubus_context
*ctx
, struct ubus_object
*obj
,
399 struct ubus_request_data
*req
, const char *method
,
400 struct blob_attr
*msg
)
402 struct usteer_measurement_report
*mr
;
403 struct usteer_node
*node
;
407 blob_buf_init(&b
, 0);
409 for_each_local_node(node
) {
410 n
= blobmsg_open_table(&b
, usteer_node_name(node
));
412 list_for_each_entry(si
, &node
->sta_info
, node_list
) {
413 if (si
->connected
!= STA_CONNECTED
)
416 s
= blobmsg_open_table_mac(&b
, si
->sta
->addr
);
417 blobmsg_add_u32(&b
, "signal", si
->signal
);
418 blobmsg_add_u64(&b
, "created", current_time
- si
->created
);
419 blobmsg_add_u64(&b
, "connected", current_time
- si
->connected_since
);
421 t
= blobmsg_open_table(&b
, "snr-kick");
422 blobmsg_add_u32(&b
, "seen-below", si
->below_min_snr
);
423 blobmsg_close_table(&b
, t
);
425 t
= blobmsg_open_table(&b
, "roam-state-machine");
426 blobmsg_add_string(&b
, "state",usteer_get_roam_sm_name(si
->roam_state
));
427 blobmsg_add_u32(&b
, "tries", si
->roam_tries
);
428 blobmsg_add_u64(&b
, "event", si
->roam_event
? current_time
- si
->roam_event
: 0);
429 blobmsg_add_u32(&b
, "kick-count", si
->kick_count
);
430 blobmsg_add_u64(&b
, "last-kick", si
->roam_kick
? current_time
- si
->roam_kick
: 0);
431 blobmsg_add_u64(&b
, "scan_start", si
->roam_scan_start
? current_time
- si
->roam_scan_start
: 0);
432 blobmsg_add_u64(&b
, "scan_timeout_start", si
->roam_scan_timeout_start
? current_time
- si
->roam_scan_timeout_start
: 0);
433 blobmsg_close_table(&b
, t
);
435 t
= blobmsg_open_table(&b
, "bss-transition-response");
436 blobmsg_add_u32(&b
, "status-code", si
->bss_transition_response
.status_code
);
437 blobmsg_add_u64(&b
, "age", si
->bss_transition_response
.timestamp
? current_time
- si
->bss_transition_response
.timestamp
: 0);
438 blobmsg_close_table(&b
, t
);
440 /* Beacon measurement modes */
441 a
= blobmsg_open_array(&b
, "beacon-measurement-modes");
442 if (usteer_sta_supports_beacon_measurement_mode(si
, BEACON_MEASUREMENT_PASSIVE
))
443 blobmsg_add_string(&b
, "", "PASSIVE");
444 if (usteer_sta_supports_beacon_measurement_mode(si
, BEACON_MEASUREMENT_ACTIVE
))
445 blobmsg_add_string(&b
, "", "ACTIVE");
446 if (usteer_sta_supports_beacon_measurement_mode(si
, BEACON_MEASUREMENT_TABLE
))
447 blobmsg_add_string(&b
, "", "TABLE");
448 blobmsg_close_array(&b
, a
);
450 /* Link-Measurement support */
451 blobmsg_add_u8(&b
, "link-measurement", usteer_sta_supports_link_measurement(si
));
453 /* BSS-Transition support */
454 blobmsg_add_u8(&b
, "bss-transition-management", si
->bss_transition
);
457 blobmsg_add_u8(&b
, "multi-band-operation", si
->mbo
);
460 a
= blobmsg_open_array(&b
, "measurements");
461 list_for_each_entry(mr
, &si
->sta
->measurements
, sta_list
) {
462 t
= blobmsg_open_table(&b
, "");
463 blobmsg_add_string(&b
, "node", usteer_node_name(mr
->node
));
464 blobmsg_add_u32(&b
, "rcpi", mr
->rcpi
);
465 blobmsg_add_u32(&b
, "rsni", mr
->rsni
);
466 blobmsg_add_u32(&b
, "rssi", usteer_measurement_get_rssi(mr
));
467 blobmsg_add_u64(&b
, "age", current_time
- mr
->timestamp
);
468 blobmsg_close_table(&b
, t
);
470 blobmsg_close_array(&b
, a
);
472 blobmsg_close_table(&b
, s
);
475 blobmsg_close_table(&b
, n
);
478 ubus_send_reply(ctx
, req
, b
.head
);
489 static const struct blobmsg_policy set_node_data_policy
[] = {
490 [NODE_DATA_NODE
] = { "node", BLOBMSG_TYPE_STRING
},
491 [NODE_DATA_VALUES
] = { "data", BLOBMSG_TYPE_TABLE
},
494 static const struct blobmsg_policy del_node_data_policy
[] = {
495 [NODE_DATA_NODE
] = { "node", BLOBMSG_TYPE_STRING
},
496 [NODE_DATA_VALUES
] = { "names", BLOBMSG_TYPE_ARRAY
},
500 usteer_update_kvlist_data(struct kvlist
*kv
, struct blob_attr
*data
,
503 struct blob_attr
*cur
;
506 blobmsg_for_each_attr(cur
, data
, rem
) {
508 kvlist_delete(kv
, blobmsg_get_string(cur
));
510 kvlist_set(kv
, blobmsg_name(cur
), cur
);
515 usteer_update_kvlist_blob(struct blob_attr
**dest
, struct kvlist
*kv
)
517 struct blob_attr
*val
;
520 blob_buf_init(&b
, 0);
521 kvlist_for_each(kv
, name
, val
)
522 blobmsg_add_field(&b
, blobmsg_type(val
), name
,
523 blobmsg_data(val
), blobmsg_len(val
));
526 if (!blobmsg_len(val
))
529 usteer_node_set_blob(dest
, val
);
533 usteer_ubus_update_node_data(struct ubus_context
*ctx
, struct ubus_object
*obj
,
534 struct ubus_request_data
*req
, const char *method
,
535 struct blob_attr
*msg
)
537 const struct blobmsg_policy
*policy
;
538 struct blob_attr
*tb
[__NODE_DATA_MAX
];
539 struct usteer_local_node
*ln
;
540 struct blob_attr
*val
;
544 delete = !strncmp(method
, "del", 3);
545 policy
= delete ? del_node_data_policy
: set_node_data_policy
;
547 blobmsg_parse(policy
, __NODE_DATA_MAX
, tb
, blob_data(msg
), blob_len(msg
));
548 if (!tb
[NODE_DATA_NODE
] || !tb
[NODE_DATA_VALUES
])
549 return UBUS_STATUS_INVALID_ARGUMENT
;
551 name
= blobmsg_get_string(tb
[NODE_DATA_NODE
]);
552 val
= tb
[NODE_DATA_VALUES
];
553 if (delete && blobmsg_check_array(val
, BLOBMSG_TYPE_STRING
) < 0)
554 return UBUS_STATUS_INVALID_ARGUMENT
;
556 if (strcmp(name
, "*") != 0) {
557 ln
= avl_find_element(&local_nodes
, name
, ln
, node
.avl
);
559 return UBUS_STATUS_NOT_FOUND
;
561 usteer_update_kvlist_data(&ln
->node_info
, val
, delete);
562 usteer_update_kvlist_blob(&ln
->node
.node_info
, &ln
->node_info
);
567 usteer_update_kvlist_data(&host_info
, val
, delete);
568 usteer_update_kvlist_blob(&host_info_blob
, &host_info
);
573 static const struct ubus_method usteer_methods
[] = {
574 UBUS_METHOD_NOARG("local_info", usteer_ubus_local_info
),
575 UBUS_METHOD_NOARG("remote_hosts", usteer_ubus_remote_hosts
),
576 UBUS_METHOD_NOARG("remote_info", usteer_ubus_remote_info
),
577 UBUS_METHOD_NOARG("connected_clients", usteer_ubus_get_connected_clients
),
578 UBUS_METHOD_NOARG("get_clients", usteer_ubus_get_clients
),
579 UBUS_METHOD("get_client_info", usteer_ubus_get_client_info
, client_arg
),
580 UBUS_METHOD_NOARG("get_config", usteer_ubus_get_config
),
581 UBUS_METHOD("set_config", usteer_ubus_set_config
, config_policy
),
582 UBUS_METHOD("update_config", usteer_ubus_set_config
, config_policy
),
583 UBUS_METHOD("set_node_data", usteer_ubus_update_node_data
, set_node_data_policy
),
584 UBUS_METHOD("delete_node_data", usteer_ubus_update_node_data
, del_node_data_policy
),
587 static struct ubus_object_type usteer_obj_type
=
588 UBUS_OBJECT_TYPE("usteer", usteer_methods
);
590 struct ubus_object usteer_obj
= {
592 .type
= &usteer_obj_type
,
593 .methods
= usteer_methods
,
594 .n_methods
= ARRAY_SIZE(usteer_methods
),
598 usteer_add_nr_entry(struct usteer_node
*ln
, struct usteer_node
*node
)
600 struct blobmsg_policy policy
[3] = {
601 { .type
= BLOBMSG_TYPE_STRING
},
602 { .type
= BLOBMSG_TYPE_STRING
},
603 { .type
= BLOBMSG_TYPE_STRING
},
605 struct blob_attr
*tb
[3];
610 if (strcmp(ln
->ssid
, node
->ssid
) != 0)
613 if (!usteer_policy_node_below_max_assoc(node
))
616 blobmsg_parse_array(policy
, ARRAY_SIZE(tb
), tb
,
617 blobmsg_data(node
->rrm_nr
),
618 blobmsg_data_len(node
->rrm_nr
));
622 blobmsg_add_field(&b
, BLOBMSG_TYPE_STRING
, "",
624 blobmsg_data_len(tb
[2]));
630 usteer_ubus_disassoc_add_neighbor(struct sta_info
*si
, struct usteer_node
*node
)
634 c
= blobmsg_open_array(&b
, "neighbors");
635 usteer_add_nr_entry(si
->node
, node
);
636 blobmsg_close_array(&b
, c
);
640 usteer_ubus_disassoc_add_neighbors(struct sta_info
*si
)
642 struct usteer_node
*node
, *last_remote_neighbor
= NULL
;
646 c
= blobmsg_open_array(&b
, "neighbors");
647 for_each_local_node(node
) {
648 if (i
>= config
.max_neighbor_reports
)
650 if (si
->node
== node
)
652 if (usteer_add_nr_entry(si
->node
, node
))
656 while (i
< config
.max_neighbor_reports
) {
657 node
= usteer_node_get_next_neighbor(si
->node
, last_remote_neighbor
);
659 /* No more nodes available */
663 last_remote_neighbor
= node
;
664 if (usteer_add_nr_entry(si
->node
, node
))
667 blobmsg_close_array(&b
, c
);
670 int usteer_ubus_bss_transition_request(struct sta_info
*si
,
671 uint8_t dialog_token
,
672 bool disassoc_imminent
,
674 uint8_t validity_period
,
675 struct usteer_node
*target_node
)
677 struct usteer_local_node
*ln
= container_of(si
->node
, struct usteer_local_node
, node
);
679 blob_buf_init(&b
, 0);
680 blobmsg_printf(&b
, "addr", MAC_ADDR_FMT
, MAC_ADDR_DATA(si
->sta
->addr
));
681 blobmsg_add_u32(&b
, "dialog_token", dialog_token
);
682 blobmsg_add_u8(&b
, "disassociation_imminent", disassoc_imminent
);
683 blobmsg_add_u8(&b
, "abridged", abridged
);
684 blobmsg_add_u32(&b
, "validity_period", validity_period
);
686 usteer_ubus_disassoc_add_neighbors(si
);
688 usteer_ubus_disassoc_add_neighbor(si
, target_node
);
690 return ubus_invoke(ubus_ctx
, ln
->obj_id
, "bss_transition_request", b
.head
, NULL
, 0, 100);
693 int usteer_ubus_band_steering_request(struct sta_info
*si
)
695 struct usteer_local_node
*ln
= container_of(si
->node
, struct usteer_local_node
, node
);
696 struct usteer_node
*node
;
699 blob_buf_init(&b
, 0);
700 blobmsg_printf(&b
, "addr", MAC_ADDR_FMT
, MAC_ADDR_DATA(si
->sta
->addr
));
701 blobmsg_add_u32(&b
, "dialog_token", 0);
702 blobmsg_add_u8(&b
, "disassociation_imminent", false);
703 blobmsg_add_u8(&b
, "abridged", false);
704 blobmsg_add_u32(&b
, "validity_period", 100);
706 c
= blobmsg_open_array(&b
, "neighbors");
707 for_each_local_node(node
) {
708 if (!usteer_band_steering_is_target(ln
, node
))
711 usteer_add_nr_entry(si
->node
, node
);
713 blobmsg_close_array(&b
, c
);
715 return ubus_invoke(ubus_ctx
, ln
->obj_id
, "bss_transition_request", b
.head
, NULL
, 0, 100);
718 int usteer_ubus_trigger_link_measurement(struct sta_info
*si
)
720 struct usteer_local_node
*ln
= container_of(si
->node
, struct usteer_local_node
, node
);
722 if (!usteer_sta_supports_link_measurement(si
))
725 blob_buf_init(&b
, 0);
726 blobmsg_printf(&b
, "addr", MAC_ADDR_FMT
, MAC_ADDR_DATA(si
->sta
->addr
));
727 blobmsg_add_u32(&b
, "tx-power-used", 5);
728 blobmsg_add_u32(&b
, "tx-power-max", 10);
729 return ubus_invoke(ubus_ctx
, ln
->obj_id
, "link_measurement_req", b
.head
, NULL
, 0, 100);
732 int usteer_ubus_trigger_client_scan(struct sta_info
*si
)
734 struct usteer_local_node
*ln
= container_of(si
->node
, struct usteer_local_node
, node
);
736 if (!usteer_sta_supports_beacon_measurement_mode(si
, BEACON_MEASUREMENT_ACTIVE
)) {
737 MSG(DEBUG
, "STA does not support beacon measurement sta=" MAC_ADDR_FMT
"\n", MAC_ADDR_DATA(si
->sta
->addr
));
741 si
->scan_band
= !si
->scan_band
;
743 blob_buf_init(&b
, 0);
744 blobmsg_printf(&b
, "addr", MAC_ADDR_FMT
, MAC_ADDR_DATA(si
->sta
->addr
));
745 blobmsg_add_string(&b
, "ssid", si
->node
->ssid
);
746 blobmsg_add_u32(&b
, "mode", BEACON_MEASUREMENT_ACTIVE
);
747 blobmsg_add_u32(&b
, "duration", config
.roam_scan_interval
/ 100);
748 blobmsg_add_u32(&b
, "channel", 0);
749 blobmsg_add_u32(&b
, "op_class", si
->scan_band
? 1 : 12);
750 return ubus_invoke(ubus_ctx
, ln
->obj_id
, "rrm_beacon_req", b
.head
, NULL
, 0, 100);
753 void usteer_ubus_kick_client(struct sta_info
*si
)
755 struct usteer_local_node
*ln
= container_of(si
->node
, struct usteer_local_node
, node
);
757 blob_buf_init(&b
, 0);
758 blobmsg_printf(&b
, "addr", MAC_ADDR_FMT
, MAC_ADDR_DATA(si
->sta
->addr
));
759 blobmsg_add_u32(&b
, "reason", config
.load_kick_reason_code
);
760 blobmsg_add_u8(&b
, "deauth", 1);
761 ubus_invoke(ubus_ctx
, ln
->obj_id
, "del_client", b
.head
, NULL
, 0, 100);
762 usteer_sta_disconnected(si
);
764 si
->roam_kick
= current_time
;
767 void usteer_ubus_init(struct ubus_context
*ctx
)
769 ubus_add_object(ctx
, &usteer_obj
);