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>
29 #include <libubox/avl-cmp.h>
30 #include <libubox/blobmsg_json.h>
34 AVL_TREE(local_nodes
, avl_strcmp
, false, NULL
);
35 static struct blob_buf b
;
36 static char *node_up_script
;
39 usteer_local_node_state_reset(struct usteer_local_node
*ln
)
41 if (ln
->req_state
== REQ_IDLE
)
44 ubus_abort_request(ubus_ctx
, &ln
->req
);
45 uloop_timeout_cancel(&ln
->req_timer
);
46 ln
->req_state
= REQ_IDLE
;
50 usteer_free_node(struct ubus_context
*ctx
, struct usteer_local_node
*ln
)
52 struct usteer_node_handler
*h
;
54 list_for_each_entry(h
, &node_handlers
, list
) {
57 h
->free_node(&ln
->node
);
60 usteer_local_node_state_reset(ln
);
61 usteer_sta_node_cleanup(&ln
->node
);
62 uloop_timeout_cancel(&ln
->update
);
63 avl_delete(&local_nodes
, &ln
->node
.avl
);
64 ubus_unregister_subscriber(ctx
, &ln
->ev
);
65 kvlist_free(&ln
->node_info
);
70 usteer_handle_remove(struct ubus_context
*ctx
, struct ubus_subscriber
*s
,
73 struct usteer_local_node
*ln
= container_of(s
, struct usteer_local_node
, ev
);
75 usteer_free_node(ctx
, ln
);
79 usteer_handle_event(struct ubus_context
*ctx
, struct ubus_object
*obj
,
80 struct ubus_request_data
*req
, const char *method
,
81 struct blob_attr
*msg
)
90 struct blobmsg_policy policy
[__EVENT_MAX
] = {
91 [EVENT_ADDR
] = { .name
= "address", .type
= BLOBMSG_TYPE_STRING
},
92 [EVENT_SIGNAL
] = { .name
= "signal", .type
= BLOBMSG_TYPE_INT32
},
93 [EVENT_TARGET
] = { .name
= "target", .type
= BLOBMSG_TYPE_STRING
},
94 [EVENT_FREQ
] = { .name
= "freq", .type
= BLOBMSG_TYPE_INT32
},
96 enum usteer_event_type ev_type
= __EVENT_TYPE_MAX
;
97 struct blob_attr
*tb
[__EVENT_MAX
];
98 struct usteer_local_node
*ln
;
99 struct usteer_node
*node
;
100 int signal
= NO_SIGNAL
;
102 const char *addr_str
;
107 usteer_update_time();
109 for (i
= 0; i
< ARRAY_SIZE(event_types
); i
++) {
110 if (strcmp(method
, event_types
[i
]) != 0)
117 ln
= container_of(obj
, struct usteer_local_node
, ev
.obj
);
119 blobmsg_parse(policy
, __EVENT_MAX
, tb
, blob_data(msg
), blob_len(msg
));
120 if (!tb
[EVENT_ADDR
] || !tb
[EVENT_FREQ
])
121 return UBUS_STATUS_INVALID_ARGUMENT
;
123 if (tb
[EVENT_SIGNAL
])
124 signal
= (int32_t) blobmsg_get_u32(tb
[EVENT_SIGNAL
]);
127 freq
= blobmsg_get_u32(tb
[EVENT_FREQ
]);
129 addr_str
= blobmsg_data(tb
[EVENT_ADDR
]);
130 addr
= (uint8_t *) ether_aton(addr_str
);
132 return UBUS_STATUS_INVALID_ARGUMENT
;
134 ret
= usteer_handle_sta_event(node
, addr
, ev_type
, freq
, signal
);
136 MSG(DEBUG
, "received %s event from %s, signal=%d, freq=%d, handled:%s\n",
137 method
, addr_str
, signal
, freq
, ret
? "true" : "false");
139 return ret
? 0 : 17 /* WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA */;
143 usteer_local_node_assoc_update(struct sta_info
*si
, struct blob_attr
*data
)
149 static struct blobmsg_policy policy
[__MSG_MAX
] = {
150 [MSG_ASSOC
] = { "assoc", BLOBMSG_TYPE_BOOL
},
152 struct blob_attr
*tb
[__MSG_MAX
];
153 struct usteer_remote_node
*rn
;
154 struct sta_info
*remote_si
;
156 blobmsg_parse(policy
, __MSG_MAX
, tb
, blobmsg_data(data
), blobmsg_data_len(data
));
157 if (tb
[MSG_ASSOC
] && blobmsg_get_u8(tb
[MSG_ASSOC
])) {
158 if (si
->connected
== STA_NOT_CONNECTED
) {
159 /* New connection. Check if STA roamed. */
160 for_each_remote_node(rn
) {
161 remote_si
= usteer_sta_info_get(si
->sta
, &rn
->node
, NULL
);
165 if (current_time
- remote_si
->last_connected
< config
.roam_process_timeout
) {
166 rn
->node
.roam_source
++;
167 /* Don't abort looking for roam sources here.
168 * The client might have roamed via another node
169 * within the roam-timeout.
174 si
->connected
= STA_CONNECTED
;
177 if (si
->node
->freq
< 4000)
178 si
->sta
->seen_2ghz
= 1;
180 si
->sta
->seen_5ghz
= 1;
184 usteer_local_node_set_assoc(struct usteer_local_node
*ln
, struct blob_attr
*cl
)
186 struct usteer_node
*node
= &ln
->node
;
187 struct usteer_node_handler
*h
;
188 struct blob_attr
*cur
;
194 usteer_update_time();
196 list_for_each_entry(si
, &node
->sta_info
, node_list
) {
198 si
->connected
= STA_DISCONNECTED
;
201 blobmsg_for_each_attr(cur
, cl
, rem
) {
202 uint8_t *addr
= (uint8_t *) ether_aton(blobmsg_name(cur
));
208 sta
= usteer_sta_get(addr
, true);
209 si
= usteer_sta_info_get(sta
, node
, &create
);
210 list_for_each_entry(h
, &node_handlers
, list
) {
214 h
->update_sta(node
, si
);
216 usteer_local_node_assoc_update(si
, cur
);
217 if (si
->connected
== STA_CONNECTED
) {
218 si
->last_connected
= current_time
;
223 node
->n_assoc
= n_assoc
;
225 list_for_each_entry(si
, &node
->sta_info
, node_list
) {
226 if (si
->connected
!= STA_DISCONNECTED
)
229 si
->connected
= STA_NOT_CONNECTED
;
230 usteer_sta_info_update_timeout(si
, config
.local_sta_timeout
);
231 MSG(VERBOSE
, "station "MAC_ADDR_FMT
" disconnected from node %s\n",
232 MAC_ADDR_DATA(si
->sta
->addr
), usteer_node_name(node
));
237 usteer_local_node_list_cb(struct ubus_request
*req
, int type
, struct blob_attr
*msg
)
244 static struct blobmsg_policy policy
[__MSG_MAX
] = {
245 [MSG_FREQ
] = { "freq", BLOBMSG_TYPE_INT32
},
246 [MSG_CLIENTS
] = { "clients", BLOBMSG_TYPE_TABLE
},
248 struct blob_attr
*tb
[__MSG_MAX
];
249 struct usteer_local_node
*ln
;
250 struct usteer_node
*node
;
252 ln
= container_of(req
, struct usteer_local_node
, req
);
255 blobmsg_parse(policy
, __MSG_MAX
, tb
, blob_data(msg
), blob_len(msg
));
256 if (!tb
[MSG_FREQ
] || !tb
[MSG_CLIENTS
])
259 node
->freq
= blobmsg_get_u32(tb
[MSG_FREQ
]);
260 usteer_local_node_set_assoc(ln
, tb
[MSG_CLIENTS
]);
264 usteer_local_node_rrm_nr_cb(struct ubus_request
*req
, int type
, struct blob_attr
*msg
)
266 static const struct blobmsg_policy policy
= {
267 "value", BLOBMSG_TYPE_ARRAY
269 struct usteer_local_node
*ln
;
270 struct blob_attr
*tb
;
272 ln
= container_of(req
, struct usteer_local_node
, req
);
274 blobmsg_parse(&policy
, 1, &tb
, blob_data(msg
), blob_len(msg
));
278 usteer_node_set_blob(&ln
->node
.rrm_nr
, tb
);
282 usteer_local_node_req_cb(struct ubus_request
*req
, int ret
)
284 struct usteer_local_node
*ln
;
286 ln
= container_of(req
, struct usteer_local_node
, req
);
287 uloop_timeout_set(&ln
->req_timer
, 1);
291 usteer_add_rrm_data(struct usteer_local_node
*ln
, struct usteer_node
*node
)
293 if (node
== &ln
->node
)
299 if (strcmp(ln
->node
.ssid
, node
->ssid
) != 0)
302 blobmsg_add_field(&b
, BLOBMSG_TYPE_ARRAY
, "",
303 blobmsg_data(node
->rrm_nr
),
304 blobmsg_data_len(node
->rrm_nr
));
308 usteer_local_node_prepare_rrm_set(struct usteer_local_node
*ln
)
310 struct usteer_remote_node
*rn
;
311 struct usteer_node
*node
;
314 c
= blobmsg_open_array(&b
, "list");
315 for_each_local_node(node
)
316 usteer_add_rrm_data(ln
, node
);
317 for_each_remote_node(rn
)
318 usteer_add_rrm_data(ln
, &rn
->node
);
319 blobmsg_close_array(&b
, c
);
323 usteer_local_node_state_next(struct uloop_timeout
*timeout
)
325 struct usteer_local_node
*ln
;
327 ln
= container_of(timeout
, struct usteer_local_node
, req_timer
);
330 if (ln
->req_state
>= __REQ_MAX
) {
331 ln
->req_state
= REQ_IDLE
;
335 blob_buf_init(&b
, 0);
336 switch (ln
->req_state
) {
338 ubus_invoke_async(ubus_ctx
, ln
->obj_id
, "get_clients", b
.head
, &ln
->req
);
339 ln
->req
.data_cb
= usteer_local_node_list_cb
;
341 case REQ_RRM_SET_LIST
:
342 usteer_local_node_prepare_rrm_set(ln
);
343 ubus_invoke_async(ubus_ctx
, ln
->obj_id
, "rrm_nr_set", b
.head
, &ln
->req
);
344 ln
->req
.data_cb
= NULL
;
346 case REQ_RRM_GET_OWN
:
347 ubus_invoke_async(ubus_ctx
, ln
->obj_id
, "rrm_nr_get_own", b
.head
, &ln
->req
);
348 ln
->req
.data_cb
= usteer_local_node_rrm_nr_cb
;
353 ln
->req
.complete_cb
= usteer_local_node_req_cb
;
354 ubus_complete_request_async(ubus_ctx
, &ln
->req
);
358 usteer_local_node_update(struct uloop_timeout
*timeout
)
360 struct usteer_local_node
*ln
;
361 struct usteer_node_handler
*h
;
362 struct usteer_node
*node
;
364 ln
= container_of(timeout
, struct usteer_local_node
, update
);
367 list_for_each_entry(h
, &node_handlers
, list
) {
371 h
->update_node(node
);
374 usteer_local_node_state_reset(ln
);
375 uloop_timeout_set(&ln
->req_timer
, 1);
376 usteer_local_node_kick(ln
);
377 uloop_timeout_set(timeout
, config
.local_sta_update
);
380 static struct usteer_local_node
*
381 usteer_get_node(struct ubus_context
*ctx
, const char *name
)
383 struct usteer_local_node
*ln
;
384 struct usteer_node
*node
;
387 ln
= avl_find_element(&local_nodes
, name
, ln
, node
.avl
);
391 ln
= calloc_a(sizeof(*ln
), &str
, strlen(name
) + 1);
393 node
->type
= NODE_TYPE_LOCAL
;
394 node
->avl
.key
= strcpy(str
, name
);
395 ln
->ev
.remove_cb
= usteer_handle_remove
;
396 ln
->ev
.cb
= usteer_handle_event
;
397 ln
->update
.cb
= usteer_local_node_update
;
398 ln
->req_timer
.cb
= usteer_local_node_state_next
;
399 ubus_register_subscriber(ctx
, &ln
->ev
);
400 avl_insert(&local_nodes
, &node
->avl
);
401 kvlist_init(&ln
->node_info
, kvlist_blob_len
);
402 INIT_LIST_HEAD(&node
->sta_info
);
408 usteer_node_run_update_script(struct usteer_node
*node
)
410 struct usteer_local_node
*ln
= container_of(node
, struct usteer_local_node
, node
);
416 val
= alloca(strlen(node_up_script
) + strlen(ln
->iface
) + 8);
417 sprintf(val
, "%s '%s'", node_up_script
, ln
->iface
);
419 MSG(INFO
, "failed to execute %s\n", val
);
423 usteer_check_node_enabled(struct usteer_local_node
*ln
)
425 bool ssid_disabled
= config
.ssid_list
;
426 struct blob_attr
*cur
;
429 blobmsg_for_each_attr(cur
, config
.ssid_list
, rem
) {
430 if (strcmp(blobmsg_get_string(cur
), ln
->node
.ssid
) != 0)
433 ssid_disabled
= false;
437 if (ln
->node
.disabled
== ssid_disabled
)
440 ln
->node
.disabled
= ssid_disabled
;
443 MSG(INFO
, "Disconnecting from local node %s\n", usteer_node_name(&ln
->node
));
444 usteer_local_node_state_reset(ln
);
445 usteer_sta_node_cleanup(&ln
->node
);
446 uloop_timeout_cancel(&ln
->update
);
447 ubus_unsubscribe(ubus_ctx
, &ln
->ev
, ln
->obj_id
);
451 MSG(INFO
, "Connecting to local node %s\n", usteer_node_name(&ln
->node
));
452 ubus_subscribe(ubus_ctx
, &ln
->ev
, ln
->obj_id
);
453 uloop_timeout_set(&ln
->update
, 1);
454 usteer_node_run_update_script(&ln
->node
);
458 usteer_register_node(struct ubus_context
*ctx
, const char *name
, uint32_t id
)
460 struct usteer_local_node
*ln
;
461 struct usteer_node_handler
*h
;
463 int offset
= sizeof("hostapd.") - 1;
465 iface
= name
+ offset
;
466 if (strncmp(name
, "hostapd.", iface
- name
) != 0)
469 MSG(INFO
, "Creating local node %s\n", name
);
470 ln
= usteer_get_node(ctx
, name
);
472 ln
->iface
= usteer_node_name(&ln
->node
) + offset
;
473 ln
->ifindex
= if_nametoindex(ln
->iface
);
475 blob_buf_init(&b
, 0);
476 blobmsg_add_u32(&b
, "notify_response", 1);
477 ubus_invoke(ctx
, id
, "notify_response", b
.head
, NULL
, NULL
, 1000);
479 blob_buf_init(&b
, 0);
480 blobmsg_add_u8(&b
, "neighbor_report", 1);
481 blobmsg_add_u8(&b
, "beacon_report", 1);
482 blobmsg_add_u8(&b
, "bss_transition", 1);
483 ubus_invoke(ctx
, id
, "bss_mgmt_enable", b
.head
, NULL
, NULL
, 1000);
485 list_for_each_entry(h
, &node_handlers
, list
) {
489 h
->init_node(&ln
->node
);
492 ln
->node
.disabled
= true;
493 usteer_check_node_enabled(ln
);
497 usteer_event_handler(struct ubus_context
*ctx
, struct ubus_event_handler
*ev
,
498 const char *type
, struct blob_attr
*msg
)
500 static const struct blobmsg_policy policy
[2] = {
501 { .name
= "id", .type
= BLOBMSG_TYPE_INT32
},
502 { .name
= "path", .type
= BLOBMSG_TYPE_STRING
},
504 struct blob_attr
*tb
[2];
507 blobmsg_parse(policy
, 2, tb
, blob_data(msg
), blob_len(msg
));
509 if (!tb
[0] || !tb
[1])
512 path
= blobmsg_data(tb
[1]);
513 usteer_register_node(ctx
, path
, blobmsg_get_u32(tb
[0]));
517 usteer_register_events(struct ubus_context
*ctx
)
519 static struct ubus_event_handler handler
= {
520 .cb
= usteer_event_handler
523 ubus_register_event_handler(ctx
, &handler
, "ubus.object.add");
527 node_list_cb(struct ubus_context
*ctx
, struct ubus_object_data
*obj
, void *priv
)
529 usteer_register_node(ctx
, obj
->path
, obj
->id
);
532 void config_set_node_up_script(struct blob_attr
*data
)
535 struct usteer_node
*node
;
540 val
= blobmsg_get_string(data
);
541 if (node_up_script
&& !strcmp(val
, node_up_script
))
544 free(node_up_script
);
547 node_up_script
= NULL
;
551 node_up_script
= strdup(val
);
553 for_each_local_node(node
)
554 usteer_node_run_update_script(node
);
557 void config_get_node_up_script(struct blob_buf
*buf
)
562 blobmsg_add_string(buf
, "node_up_script", node_up_script
);
565 void config_set_ssid_list(struct blob_attr
*data
)
567 struct usteer_local_node
*ln
;
569 free(config
.ssid_list
);
571 if (data
&& blobmsg_len(data
))
572 config
.ssid_list
= blob_memdup(data
);
574 config
.ssid_list
= NULL
;
576 avl_for_each_element(&local_nodes
, ln
, node
.avl
)
577 usteer_check_node_enabled(ln
);
580 void config_get_ssid_list(struct blob_buf
*buf
)
582 if (config
.ssid_list
)
583 blobmsg_add_blob(buf
, config
.ssid_list
);
587 usteer_local_nodes_init(struct ubus_context
*ctx
)
589 usteer_register_events(ctx
);
590 ubus_lookup(ctx
, "hostapd.*", node_list_cb
, NULL
);