Roam blacklisting and scan BSS groups
v2 cover Roam blacklisting and scan BSS groups
Version 2 combines the main patch set and another fix that was sent individually. In addition there were some changes made to the overall set of patches:
- Renamed the blacklist reasons BLACKLIST_REASON_PERMANENT -> BLACKLIST_REASON_CONNECT_FAILED BLACKLIST_REASON_TEMPORARY -> BLACKLIST_REASON_TRANSIENT_ERROR
- Added documentation for the two new main.conf options added
- Added more autotests
- OptimalSignalThreshold was moved from [Scan] -> [General] as it fits a lot better there along with the other roaming thresholds.
James Prestwood (13):
station: always network (temp) blacklist on failure
auto-t: add test for disabling the timeout blacklist
blacklist: include a blacklist reason when adding/finding
blacklist: fix pruning to remove the entry if its expired
blacklist: add BLACKLIST_REASON_TRANSIENT_ERROR
network: update to use blacklist's new temporary type
blacklist: add new blacklist reason, ROAM_REQUESTED
scan: Introduce higher level scan BSS groups
station: roam blacklist BSS when a roam is requested
station: roam blacklist AP even mid-roam
station: adapt roam scan logic to look at the bss group
auto-t: add tests for AP roam blacklisting
doc: document OptimalSignalThreshold and InitialRoamRequestedTimeout
autotests/testAPRoam/connection_test.py | 2 +-
autotests/testAPRoam/hw.conf | 2 +
autotests/testAPRoam/main.conf.roaming | 6 +
autotests/testAPRoam/roam_blacklist_test.py | 183 ++++++++++++++++++
autotests/testBSSBlacklist/TestBlacklist.psk | 2 +
autotests/testBSSBlacklist/connection_test.py | 57 ++++++
.../{main.conf => main.conf.default} | 0
autotests/testBSSBlacklist/main.conf.disabled | 2 +
src/blacklist.c | 124 +++++++++---
src/blacklist.h | 33 +++-
src/iwd.config.rst | 21 ++
src/network.c | 37 ++--
src/network.h | 2 -
src/scan.c | 42 +++-
src/scan.h | 41 ++++
src/station.c | 87 +++++++--
16 files changed, 560 insertions(+), 81 deletions(-)
create mode 100644 autotests/testAPRoam/main.conf.roaming
create mode 100644 autotests/testAPRoam/roam_blacklist_test.py
create mode 100644 autotests/testBSSBlacklist/TestBlacklist.psk
rename autotests/testBSSBlacklist/{main.conf => main.conf.default} (100%)
create mode 100644 autotests/testBSSBlacklist/main.conf.disabledSignature · 1 line
2.34.1
PATCH v2 1/13 station: always network (temp) blacklist on failure
Allowing the timeout blacklist to be disabled has introduced a bug where a failed connection will not result in the BSS list to be traversed. This causes IWD to retry the same BSS over and over which be either a) have some issue preventing a connection or b) may simply be unreachable/out of range.
This is because IWD was inherently relying on the timeout blacklist to flag BSS's on failures. With it disabled there was nothing to tell network_bss_select that we should skip the BSS and it would return the same BSS indefinitely.
To fix this some of the blacklisting logic was re-worked in station. Now, a BSS will always get network blacklisted upon a failure. This allows network.c to traverse to the next BSS upon failure.
For auth/assoc failures we will then only timeout blacklist under certain conditions, i.e. the status code was not in the temporary list.
--- src/station.c | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-)
src/station.c +21 -4
@@ -3402,6 +3402,13 @@ static bool station_retry_with_reason(struct station *station,blacklist_add_bss (station->connected_bss->addr); +/* +* Network blacklist the BSS as well, since the timeout blacklist could +* be disabled +*/ +network_blacklist_add (station->connected_network, + station->connected_bss); + try_next:return station_try_next_bss (station); }
@@ -3449,6 +3456,10 @@ static bool station_pmksa_fallback(struct station *station, uint16_t status)static bool station_retry_with_status (struct station *station,uint16_t status_code) { +/* If PMKSA failed don't blacklist so we can retry this BSS */ +if (station_pmksa_fallback (station, status_code)) + goto try_next; +/* * Certain Auth/Assoc failures should not cause a timeout blacklist. * In these cases we want to only temporarily blacklist the BSS until
@@ -3459,12 +3470,18 @@ static bool station_retry_with_status(struct station *station,* specific BSS on our next attempt. There is currently no way to * obtain that IE, but this should be done in the future. */ -if (IS_TEMPORARY_STATUS (status_code)) -network_blacklist_add (station->connected_network, - station->connected_bss); -else if (!station_pmksa_fallback (station, status_code)) +if (!IS_TEMPORARY_STATUS (status_code))blacklist_add_bss (station->connected_bss->addr); +/* +* Unconditionally network blacklist the BSS if we are retrying. This +* will allow network_bss_select to traverse the BSS list and ignore +* BSS's which have previously failed +*/ +network_blacklist_add (station->connected_network, + station->connected_bss); + +try_next:iwd_notice (IWD_NOTICE_CONNECT_FAILED ,"status: %u" , status_code);return station_try_next_bss (station);
Signature · 1 line
2.34.1
PATCH v2 2/13 auto-t: add test for disabling the timeout blacklist
In reply to James Prestwood---
autotests/testBSSBlacklist/TestBlacklist.psk | 2 +
autotests/testBSSBlacklist/connection_test.py | 57 +++++++++++++++++++
.../{main.conf => main.conf.default} | 0
autotests/testBSSBlacklist/main.conf.disabled | 2 +
4 files changed, 61 insertions(+)
create mode 100644 autotests/testBSSBlacklist/TestBlacklist.psk
rename autotests/testBSSBlacklist/{main.conf => main.conf.default} (100%)
create mode 100644 autotests/testBSSBlacklist/main.conf.disabledautotests/testBSSBlacklist/TestBlacklist.psk new file +2 -0
@@ -0,0 +1,2 @@ +[Security] +Passphrase=secret123
autotests/testBSSBlacklist/connection_test.py +57 -0
69 lines not on this page · raw message
autotests/testBSSBlacklist/main.conf.default renamed from autotests/testBSSBlacklist/main.conf +0 -0
autotests/testBSSBlacklist/main.conf.disabled new file +2 -0
@@ -0,0 +1,2 @@ +[Blacklist] +InitialTimeout=0
Signature · 1 line
2.34.1
PATCH v2 3/13 blacklist: include a blacklist reason when adding/finding
In reply to James PrestwoodTo both prepare for some new blacklisting behavior and allow for easier consolidation of the network-specific blacklist include a reason enum for each entry. This allows IWD to differentiate between multiple blacklist types. For now only the existing "permanent" type is being added which prevents connections to that BSS via autoconnect until it expires.
By including a type into each entry we now have additional search criteria and can have multiple entires of the same BSS with different reasons. This was done versus a bitmask because each blacklist reason may have a different expiration time. We want to maintain individual expirations to have the best "memory" of past events rather than overwriting them.
Future patches will lump in the temporary network blacklist as well as a new roaming blacklist type.
--- src/blacklist.c | 81 +++++++++++++++++++++++++++++++++++++------------ src/blacklist.h | 14 +++++++-- src/network.c | 3 +- src/station.c | 12 +++++--- 4 files changed, 83 insertions(+), 27 deletions(-)
src/blacklist.c +62 -19
@@ -51,10 +51,46 @@ struct blacklist_entry {uint8_t addr[6 ];uint64_t added_time;uint64_t expire_time; +enum blacklist_reason reason; +}; + +struct blacklist_search { +const uint8_t *addr; +enum blacklist_reason reason; };static struct l_queue *blacklist; +static struct blacklist_entry *blacklist_entry_new (const uint8_t *addr, +enum blacklist_reason reason) +{ +struct blacklist_entry *entry; +uint64_t added; +uint64_t expires; + +switch (reason) { +case BLACKLIST_REASON_CONNECT_FAILED : +if (!blacklist_initial_timeout) +return NULL ; + + added =l_time_now (); + expires =l_time_offset (added, blacklist_initial_timeout); +break ; +default : +l_warn ("Unhandled blacklist reason: %u" , reason); +return NULL ; + } + + entry = l_new(struct blacklist_entry, 1); + + entry->added_time = added; + entry->expire_time = expires; + entry->reason = reason; +memcpy (entry->addr, addr,6 ); + +return entry; +} +static bool check_if_expired (void *data,void *user_data) {struct blacklist_entry *entry = data;
@@ -79,24 +115,28 @@ static void blacklist_prune(void)static bool match_addr (const void *a,const void *b) {const struct blacklist_entry *entry = a; -const uint8_t *addr = b; +const struct blacklist_search *search = b; + +if (entry->reason != search->reason) +return false; -if (!memcmp (entry->addr, addr,6 )) +if (!memcmp (entry->addr, search->addr,6 ))return true;return false; } -void blacklist_add_bss (const uint8_t *addr) +void blacklist_add_bss (const uint8_t *addr,enum blacklist_reason reason) {struct blacklist_entry *entry; - -if (!blacklist_initial_timeout) -return ; +struct blacklist_search search = { + .addr = addr, + .reason = reason + };blacklist_prune (); - entry =l_queue_find (blacklist, match_addr, addr); + entry =l_queue_find (blacklist, match_addr, &search);if (entry) { uint64_t offset = l_time_diff(entry->added_time,
@@ -112,25 +152,24 @@ void blacklist_add_bss(const uint8_t *addr)return ; } - entry = l_new(struct blacklist_entry, 1); - - entry->added_time =l_time_now (); - entry->expire_time =l_time_offset (entry->added_time, - blacklist_initial_timeout); -memcpy (entry->addr, addr,6 ); - -l_queue_push_tail (blacklist, entry); + entry =blacklist_entry_new (addr, reason); +if (entry) +l_queue_push_tail (blacklist, entry); } -bool blacklist_contains_bss (const uint8_t *addr) +bool blacklist_contains_bss (const uint8_t *addr,enum blacklist_reason reason) {bool ret;uint64_t time_now;struct blacklist_entry *entry; +struct blacklist_search search = { + .addr = addr, + .reason = reason + };blacklist_prune (); - entry =l_queue_find (blacklist, match_addr, addr); + entry =l_queue_find (blacklist, match_addr, &search);if (!entry)return false;
@@ -142,13 +181,17 @@ bool blacklist_contains_bss(const uint8_t *addr)return ret; } -void blacklist_remove_bss (const uint8_t *addr) +void blacklist_remove_bss (const uint8_t *addr,enum blacklist_reason reason) {struct blacklist_entry *entry; +struct blacklist_search search = { + .addr = addr, + .reason = reason + };blacklist_prune (); - entry =l_queue_remove_if (blacklist, match_addr, addr); + entry =l_queue_remove_if (blacklist, match_addr, &search);if (!entry)return ;
src/blacklist.h +11 -3
@@ -20,6 +20,14 @@* */ -void blacklist_add_bss (const uint8_t *addr); -bool blacklist_contains_bss (const uint8_t *addr); -void blacklist_remove_bss (const uint8_t *addr); +enum blacklist_reason { +/* +* When a BSS is blacklisted using this reason IWD will refuse to +* connect to it via autoconnect +*/ +BLACKLIST_REASON_CONNECT_FAILED , +}; + +void blacklist_add_bss (const uint8_t *addr,enum blacklist_reason reason); +bool blacklist_contains_bss (const uint8_t *addr,enum blacklist_reason reason); +void blacklist_remove_bss (const uint8_t *addr,enum blacklist_reason reason);
src/network.c +2 -1
@@ -1280,7 +1280,8 @@ struct scan_bss *network_bss_select(struct network *network,if (l_queue_find (network->blacklist, match_bss, bss))continue ; -if (blacklist_contains_bss (bss->addr)) +if (blacklist_contains_bss (bss->addr, +BLACKLIST_REASON_CONNECT_FAILED ))continue ;/* OWE Transition BSS */
src/station.c +8 -4
@@ -2880,7 +2880,8 @@ static bool station_roam_scan_notify(int err, struct l_queue *bss_list,if (network_can_connect_bss (network, bss) <0 ) goto next; -if (blacklist_contains_bss (bss->addr)) +if (blacklist_contains_bss (bss->addr, +BLACKLIST_REASON_CONNECT_FAILED )) goto next; rank = bss->rank;
@@ -3400,7 +3401,8 @@ static bool station_retry_with_reason(struct station *station,break ; } -blacklist_add_bss (station->connected_bss->addr); +blacklist_add_bss (station->connected_bss->addr, +BLACKLIST_REASON_CONNECT_FAILED );/* * Network blacklist the BSS as well, since the timeout blacklist could
@@ -3471,7 +3473,8 @@ static bool station_retry_with_status(struct station *station,* obtain that IE, but this should be done in the future. */ if (!IS_TEMPORARY_STATUS (status_code)) -blacklist_add_bss (station->connected_bss->addr); +blacklist_add_bss (station->connected_bss->addr, +BLACKLIST_REASON_CONNECT_FAILED );/* * Unconditionally network blacklist the BSS if we are retrying. This
@@ -3566,7 +3569,8 @@ static void station_connect_cb(struct netdev *netdev, enum netdev_result result,switch (result) {case NETDEV_RESULT_OK : -blacklist_remove_bss (station->connected_bss->addr); +blacklist_remove_bss (station->connected_bss->addr, +BLACKLIST_REASON_CONNECT_FAILED );station_connect_ok (station);return ;case NETDEV_RESULT_DISCONNECTED :
Signature · 1 line
2.34.1
PATCH v2 4/13 blacklist: fix pruning to remove the entry if its expired
In reply to James PrestwoodWhen pruning the list check_if_expired was comparing to the maximum amount of time a BSS can be blacklisted, not if the current time had exceeded the expirationt time. This results in blacklist entries hanging around longer than they should, which would result in them poentially being blacklisted even longer if there was another reason to blacklist in the future.
Instead on prune check the actual expiration and remove the entry if its expired. Doing this removes the need to check any of the times in blacklist_contains_bss since prune will remove any expired entries correctly.
--- src/blacklist.c | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-)
src/blacklist.c +2 -14
@@ -96,7 +96,7 @@ static bool check_if_expired(void *data, void *user_data)struct blacklist_entry *entry = data;uint64_t now =l_get_u64 (user_data); -if (l_time_diff (now, entry->added_time) > blacklist_max_timeout) { +if (l_time_after (now, entry->expire_time)) {l_debug ("Removing entry " MAC " on prune" ,MAC_STR (entry->addr));l_free (entry);return true;
@@ -159,9 +159,6 @@ void blacklist_add_bss(const uint8_t *addr, enum blacklist_reason reason)bool blacklist_contains_bss (const uint8_t *addr,enum blacklist_reason reason) { -bool ret; -uint64_t time_now; -struct blacklist_entry *entry;struct blacklist_search search = { .addr = addr, .reason = reason
@@ -169,16 +166,7 @@ bool blacklist_contains_bss(const uint8_t *addr, enum blacklist_reason reason)blacklist_prune (); - entry =l_queue_find (blacklist, match_addr, &search); - -if (!entry) -return false; - - time_now =l_time_now (); - - ret =l_time_after (time_now, entry->expire_time) ? false : true; - -return ret; +return l_queue_find (blacklist, match_addr, &search) !=NULL ; }void blacklist_remove_bss (const uint8_t *addr,enum blacklist_reason reason)
Signature · 1 line
2.34.1
PATCH v2 5/13 blacklist: add BLACKLIST_REASON_TRANSIENT_ERROR
In reply to James PrestwoodThis is meant to replace the blacklist held in network objects, known as the temporary blacklist. For these entires there is no expiration as it will be up to network.c to remove them as it does now internally.
--- src/blacklist.c | 13 +++++++++++++ src/blacklist.h | 12 ++++++++++++ 2 files changed, 25 insertions(+)
src/blacklist.c +13 -0
@@ -76,6 +76,16 @@ static struct blacklist_entry *blacklist_entry_new(const uint8_t *addr, added =l_time_now (); expires =l_time_offset (added, blacklist_initial_timeout);break ; +case BLACKLIST_REASON_TRANSIENT_ERROR : +/* +* The temporary blacklist is a special case where entries are +* required to be removed manually. This type of blacklist is +* only used for an ongoing connection attempt to iterate BSS's +* and not retry until all have been exhausted. +*/ + added =0 ; + expires =0 ; +break ;default :l_warn ("Unhandled blacklist reason: %u" , reason);return NULL ;
@@ -96,6 +106,9 @@ static bool check_if_expired(void *data, void *user_data)struct blacklist_entry *entry = data;uint64_t now =l_get_u64 (user_data); +if (entry->reason ==BLACKLIST_REASON_TRANSIENT_ERROR ) +return false; +if (l_time_after (now, entry->expire_time)) {l_debug ("Removing entry " MAC " on prune" ,MAC_STR (entry->addr));l_free (entry);
src/blacklist.h +12 -0
@@ -26,6 +26,18 @@ enum blacklist_reason {* connect to it via autoconnect */ BLACKLIST_REASON_CONNECT_FAILED , +/* +* Used to blacklist a BSS under certain failure conditions that don't +* warrant a full ban from connecting. This can include an invalid +* password, or an auth/assoc failure with a subset of status codes that +* indicate the BSS is overloaded or cannot accept new connections. +* +* This is used to mark the last BSS as having failed, and to continue +* iterating BSS's. Once the list has been exhausted or a connection has +* succeeded all blacklist entries with this reason code should be +* cleared. +*/ + BLACKLIST_REASON_TRANSIENT_ERROR, };void blacklist_add_bss (const uint8_t *addr,enum blacklist_reason reason);
Signature · 1 line
2.34.1
PATCH v2 6/13 network: update to use blacklist's new temporary type
In reply to James PrestwoodRemove the temporary blacklist from network.c and use the new BLACKLIST_REASON_TRANSIENT_ERROR reason.
--- src/network.c | 34 +++++++++++++++++----------------- src/network.h | 2 -- src/station.c | 12 ++++++------ 3 files changed, 23 insertions(+), 25 deletions(-)
src/network.c +17 -17
@@ -78,7 +78,6 @@ struct network {struct l_queue *bss_list;struct l_settings *settings;struct l_queue *secrets; -struct l_queue *blacklist;/* temporary blacklist for BSS's */ uint8_t hessid[6 ];char **nai_realms;uint8_t *rc_ie;
@@ -168,6 +167,18 @@ static bool network_secret_check_cacheable(void *data, void *user_data)return false; } +static void remove_temporary_blacklist (void *user_data) +{ +struct scan_bss *bss = user_data; + +blacklist_remove_bss (bss->addr,BLACKLIST_REASON_TRANSIENT_ERROR ); +} + +static void remove_blacklist_foreach (void *data,void *user_data) +{ +remove_temporary_blacklist (data); +} +void network_connected (struct network *network) {enum security security =network_get_security (network);
@@ -198,7 +209,7 @@ void network_connected(struct network *network)l_queue_foreach_remove (network->secrets, network_secret_check_cacheable, network); -l_queue_clear (network->blacklist,NULL ); +l_queue_foreach (network->bss_list, remove_blacklist_foreach,NULL ); network->provisioning_hidden = false; }
@@ -207,7 +218,7 @@ void network_disconnected(struct network *network) {network_settings_close (network); -l_queue_clear (network->blacklist,NULL ); +l_queue_foreach (network->bss_list, remove_blacklist_foreach,NULL );if (network->provisioning_hidden)station_hide_network (network->station, network);
@@ -254,7 +265,6 @@ struct network *network_create(struct station *station, const char *ssid, } network->bss_list =l_queue_new (); - network->blacklist =l_queue_new ();return network; }
@@ -1197,11 +1207,6 @@ struct scan_bss *network_bss_find_by_addr(struct network *network,return l_queue_find (network->bss_list, match_addr, addr); } -static bool match_bss (const void *a,const void *b) -{ -return a == b; -} -struct erp_cache_entry *network_get_erp_cache (struct network *network) {struct erp_cache_entry *cache;
@@ -1277,7 +1282,8 @@ struct scan_bss *network_bss_select(struct network *network, candidate = bss;/* check if temporarily blacklisted */ -if (l_queue_find (network->blacklist, match_bss, bss)) +if (blacklist_contains_bss (bss->addr, +BLACKLIST_REASON_TRANSIENT_ERROR ))continue ; if (blacklist_contains_bss(bss->addr,
@@ -1784,11 +1790,6 @@ struct l_dbus_message *network_connect_new_hidden_network(return dbus_error_not_supported (message); } -void network_blacklist_add (struct network *network,struct scan_bss *bss) -{ -l_queue_push_head (network->blacklist, bss); -} - static bool network_property_get_name(struct l_dbus *dbus, struct l_dbus_message *message, struct l_dbus_message_builder *builder,
@@ -1934,8 +1935,7 @@ void network_remove(struct network *network, int reason)if (network->info) network->info->seen_count -=1 ; -l_queue_destroy (network->bss_list,NULL ); -l_queue_destroy (network->blacklist,NULL ); +l_queue_destroy (network->bss_list, remove_temporary_blacklist);if (network->nai_realms)l_strv_free (network->nai_realms);
src/network.h +0 -2
@@ -95,8 +95,6 @@ struct l_dbus_message *network_connect_new_hidden_network(struct network *network, struct l_dbus_message *message); -void network_blacklist_add (struct network *network,struct scan_bss *bss); -struct erp_cache_entry *network_get_erp_cache (struct network *network); const struct l_queue_entry *network_bss_list_get_entries(
src/station.c +6 -6
@@ -3408,8 +3408,8 @@ static bool station_retry_with_reason(struct station *station,* Network blacklist the BSS as well, since the timeout blacklist could * be disabled */ -network_blacklist_add (station->connected_network, - station->connected_bss); +blacklist_add_bss (station->connected_bss->addr, +BLACKLIST_REASON_TRANSIENT_ERROR ); try_next:return station_try_next_bss (station);
@@ -3481,8 +3481,8 @@ static bool station_retry_with_status(struct station *station,* will allow network_bss_select to traverse the BSS list and ignore * BSS's which have previously failed */ -network_blacklist_add (station->connected_network, - station->connected_bss); +blacklist_add_bss (station->connected_bss->addr, +BLACKLIST_REASON_TRANSIENT_ERROR ); try_next:iwd_notice (IWD_NOTICE_CONNECT_FAILED ,"status: %u" , status_code);
@@ -3579,8 +3579,8 @@ static void station_connect_cb(struct netdev *netdev, enum netdev_result result,iwd_notice (IWD_NOTICE_DISCONNECT_INFO ,"reason: %u" , reason);/* Disconnected while connecting */ -network_blacklist_add (station->connected_network, - station->connected_bss); +blacklist_add_bss (station->connected_bss->addr, +BLACKLIST_REASON_TRANSIENT_ERROR );if (station_try_next_bss (station))return ;
Signature · 1 line
2.34.1
PATCH v2 7/13 blacklist: add new blacklist reason, ROAM_REQUESTED
In reply to James PrestwoodThis adds a new blacklist reason as well as an option to configure the timeout. This blacklist reason will be used in cases where a BSS has requested IWD roam elsewhere. At that time a new blacklist entry will be added which will be used along with some other criteria to determine if IWD should connect/roam to that BSS again.
--- src/blacklist.c | 16 ++++++++++++++++ src/blacklist.h | 7 +++++++ 2 files changed, 23 insertions(+)
src/blacklist.c +16 -0
@@ -45,6 +45,7 @@static uint64_t blacklist_multiplier;static uint64_t blacklist_initial_timeout; +static uint64_t blacklist_roam_initial_timeout;static uint64_t blacklist_max_timeout;struct blacklist_entry {
@@ -86,6 +87,13 @@ static struct blacklist_entry *blacklist_entry_new(const uint8_t *addr, added =0 ; expires =0 ;break ; +case BLACKLIST_REASON_ROAM_REQUESTED : +if (!blacklist_roam_initial_timeout) +return NULL ; + + added =l_time_now (); + expires =l_time_offset (added, blacklist_roam_initial_timeout); +break ;default :l_warn ("Unhandled blacklist reason: %u" , reason);return NULL ;
@@ -211,6 +219,14 @@ static int blacklist_init(void)/* For easier user configuration the timeout values are in seconds */ blacklist_initial_timeout *=L_USEC_PER_SEC ; +if (!l_settings_get_uint64 (config,"Blacklist" , +"InitialRoamRequestedTimeout" , + &blacklist_roam_initial_timeout)) + blacklist_roam_initial_timeout =BLACKLIST_DEFAULT_TIMEOUT ; + +/* For easier user configuration the timeout values are in seconds */ + blacklist_roam_initial_timeout *=L_USEC_PER_SEC ; +if (!l_settings_get_uint64 (config,"Blacklist" ,"Multiplier" , &blacklist_multiplier))
src/blacklist.h +7 -0
@@ -38,6 +38,13 @@ enum blacklist_reason {* cleared. */ BLACKLIST_REASON_TRANSIENT_ERROR , +/* +* This type of blacklist is added when a BSS requests IWD roams +* elsewhere. This is to aid in preventing IWD from roaming/connecting +* back to that BSS in the future unless there are no other "good" +* candidates to connect to. +*/ + BLACKLIST_REASON_ROAM_REQUESTED, };void blacklist_add_bss (const uint8_t *addr,enum blacklist_reason reason);
Signature · 1 line
2.34.1
PATCH v2 8/13 scan: Introduce higher level scan BSS groups
In reply to James PrestwoodThis introduces a higher level grouping to BSS's to improve sorting as opposed to purely rank based sorting. The reason for this is to handle roam request-based blacklisting where we want to encourage IWD to avoid BSS's that have requested we roam elsewhere, but also not fully ban these BSS's (i.e. BLACKLIST_REASON_CONNECT_FAILED).
This new concept introduces 4 group types, in order of worse to best:
- Blacklisted - the BSS has a permanent timeout blacklist
- Under threshold - the BSS is under the set RSSI threshold
- Above threshold - the BSS is above the set RSSI threshold
- Optimal - The BSS is not "roam blacklisted" and is above the set RSSI threshold.
When sorting the BSS group will be considered before rank. This means we will still prefer roam blacklisted BSS's above those that are under the set RSSI threshold. BSS's within the same group are still compared by their rank/signal.
The new group sorting logic was added via a macro __scan_bss_rank_compare. This was done since station uses a separate roam_bss structure to sort roam candidates which can also take advantage of this new sorting. The macro is agnostic to the type as long as the structure member names match.
--- src/scan.c | 42 +++++++++++++++++++++++++++++++++++++----- src/scan.h | 41 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 78 insertions(+), 5 deletions(-)
src/scan.c +37 -5
@@ -51,6 +51,7 @@#include "src/mpdu.h" #include "src/band.h" #include "src/scan.h" +#include "src/blacklist.h" /* User configurable options */ static double RANK_2G_FACTOR ;
@@ -58,6 +59,7 @@ static double RANK_5G_FACTOR;static double RANK_6G_FACTOR ;static uint32_t RANK_HIGH_UTILIZATION ;static uint32_t RANK_HIGH_STATION_COUNT ; +static int RANK_OPTIMAL_SIGNAL_THRESHOLD ;static uint32_t SCAN_MAX_INTERVAL ;static uint32_t SCAN_INIT_INTERVAL ;
@@ -1910,15 +1912,41 @@ int scan_bss_get_security(const struct scan_bss *bss, enum security *security)return 0 ; } +/* +* Evaluate the BSS's grouping based on its signal strength and blacklist +* status. From best to worst the groupings are: +* +* Optimal: Not blacklisted in any form, and above the RSSI threshold +* Above Threshold: Above the RSSI threshold (may be roam blacklisted) +* Below Threshold: Below the RSSI threshold (may be roam blacklisted) +* Blacklisted: Permanently blacklisted +*/ +enum scan_bss_group scan_bss_evaluate_group (const uint8_t *addr, +int16_t signal_strength) +{ +int rssi = signal_strength /100 ; + +if (RANK_OPTIMAL_SIGNAL_THRESHOLD ==0 ) +return SCAN_BSS_GROUP_OPTIMAL ; + +if (blacklist_contains_bss (addr,BLACKLIST_REASON_CONNECT_FAILED )) +return SCAN_BSS_GROUP_BLACKLISTED ; + +if (!blacklist_contains_bss (addr,BLACKLIST_REASON_ROAM_REQUESTED ) && + rssi >=RANK_OPTIMAL_SIGNAL_THRESHOLD ) +return SCAN_BSS_GROUP_OPTIMAL ; + +if (rssi >=RANK_OPTIMAL_SIGNAL_THRESHOLD ) +return SCAN_BSS_GROUP_ABOVE_THRESHOLD ; + +return SCAN_BSS_GROUP_UNDER_THRESHOLD ; +} +int scan_bss_rank_compare (const void *a,const void *b,void *user_data) {const struct scan_bss *new_bss = a, *bss = b; -if (bss->rank == new_bss->rank) -return (bss->signal_strength > - new_bss->signal_strength) ?1 :-1 ; - -return (bss->rank > new_bss->rank) ?1 :-1 ; +return __scan_bss_rank_compare (new_bss, bss); } static bool scan_survey_get_snr(struct scan_results *results,
@@ -2678,6 +2706,10 @@ static int scan_init(void)if (L_WARN_ON (RANK_HIGH_STATION_COUNT >255 ))RANK_HIGH_STATION_COUNT =255 ; +if (!l_settings_get_int (config,"General" ,"OptimalSignalThreshold" , + &RANK_OPTIMAL_SIGNAL_THRESHOLD )) +RANK_OPTIMAL_SIGNAL_THRESHOLD =0 ; +return 0 ; }
src/scan.h +41 -0
53 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v2 9/13 station: roam blacklist BSS when a roam is requested
In reply to James PrestwoodIf the BSS is requesting IWD roam elsewhere add this BSS to the blacklist using BLACKLIST_REASON_ROAM_REQUESTED. This will lower the chances of IWD roaming/connecting back to this BSS in the future.
In addition we also needed to update the roam_bss sorting to use __scan_bss_rank_compare so we sort based on the new groupings rather than only rank/rssi.
--- src/station.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
src/station.c +5 -5
@@ -184,11 +184,7 @@ static int roam_bss_rank_compare(const void *a, const void *b, void *user_data) {const struct roam_bss *new_bss = a, *bss = b; -if (bss->rank == new_bss->rank) -return (bss->signal_strength > - new_bss->signal_strength) ?1 :-1 ; - -return (bss->rank > new_bss->rank) ?1 :-1 ; +return __scan_bss_rank_compare (new_bss, bss); }struct wiphy *station_get_wiphy (struct station *station)
@@ -3268,6 +3264,10 @@ static void station_ap_directed_roam(struct station *station,l_timeout_remove (station->roam_trigger_timeout); station->roam_trigger_timeout =NULL ; +blacklist_add_bss (station->connected_bss->addr, +BLACKLIST_REASON_ROAM_REQUESTED ); +station_debug_event (station,"ap-roam-blacklist-added" ); +if (req_mode &WNM_REQUEST_MODE_PREFERRED_CANDIDATE_LIST ) {l_debug ("roam: AP sent a preferred candidate list" ); station_neighbor_report_cb(station->netdev, 0, body + pos,
Signature · 1 line
2.34.1
PATCH v2 10/13 station: roam blacklist AP even mid-roam
In reply to James PrestwoodIf an AP directed roam frame comes in while IWD is roaming its still valuable to parse that frame and blacklist the BSS that sent it.
This can happen most frequently during a roam scan while connected to an overloaded BSS that is requesting IWD roams elsewhere.
--- src/station.c | 28 ++++++++++++++++++++-------- 1 file changed, 20 insertions(+), 8 deletions(-)
src/station.c +20 -8
@@ -3162,12 +3162,10 @@ static void station_ap_directed_roam(struct station *station,uint8_t req_mode;uint16_t dtimer;uint8_t valid_interval; +bool can_roam = !station_cannot_roam (station);l_debug ("ifindex: %u" ,netdev_get_ifindex (station->netdev)); -if (station_cannot_roam (station)) -return ; -if (station->state !=STATION_STATE_CONNECTED ) {l_debug ("roam: unexpected AP directed roam -- ignore" );return ;
@@ -3231,8 +3229,13 @@ static void station_ap_directed_roam(struct station *station,* disassociating us. If either of these bits are set, set the * ap_directed_roaming flag. Otherwise still try roaming but don't * treat it any different than a normal roam. +* +* The only exception here is if we are in the middle of roaming +* (can_roam == false) since we cannot reliably know if the roam scan +* included frequencies from potential candidates in this request, +* forcing a roam in this case might result in unintended behavior. */ -if (req_mode & (WNM_REQUEST_MODE_DISASSOCIATION_IMMINENT | +if (can_roam && req_mode & (WNM_REQUEST_MODE_DISASSOCIATION_IMMINENT |WNM_REQUEST_MODE_TERMINATION_IMMINENT |WNM_REQUEST_MODE_ESS_DISASSOCIATION_IMMINENT )) station->ap_directed_roaming = true;
@@ -3259,15 +3262,24 @@ static void station_ap_directed_roam(struct station *station, pos += url_len; } +blacklist_add_bss (station->connected_bss->addr, +BLACKLIST_REASON_ROAM_REQUESTED ); +station_debug_event (station,"ap-roam-blacklist-added" ); + +/* +* Validating the frame and blacklisting should still be done even if +* we are mid-roam. Its important to track the BSS requesting the +* transition so when the current roam completes IWD will be less likely +* to roam back to the current BSS. +*/ +if (!can_roam) +return ; + station->preparing_roam = true;l_timeout_remove (station->roam_trigger_timeout); station->roam_trigger_timeout =NULL ; -blacklist_add_bss (station->connected_bss->addr, -BLACKLIST_REASON_ROAM_REQUESTED ); -station_debug_event (station,"ap-roam-blacklist-added" ); -if (req_mode &WNM_REQUEST_MODE_PREFERRED_CANDIDATE_LIST ) {l_debug ("roam: AP sent a preferred candidate list" ); station_neighbor_report_cb(station->netdev, 0, body + pos,
Signature · 1 line
2.34.1
PATCH v2 11/13 station: adapt roam scan logic to look at the bss group
In reply to James PrestwoodIn station_roam_scan_notify BSS candidates were being ignored if their rank was not better than the current AP. This check needed to be changed to first check the BSS group, then the rank (only if the groups were equal). This takes into account the current BSS roam blacklisting status rather than only rank.
--- src/station.c | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-)
src/station.c +17 -3
@@ -2801,6 +2801,7 @@ static bool station_roam_scan_notify(int err, struct l_queue *bss_list,struct handshake_state *hs =netdev_get_handshake (station->netdev);struct scan_bss *current_bss = station->connected_bss;struct scan_bss *bss; +enum scan_bss_group cur_bss_group =SCAN_BSS_GROUP_BLACKLISTED ;double cur_bss_rank =0.0 ;static const double RANK_FT_FACTOR =1.3 ;uint16_t mdid;
@@ -2831,6 +2832,9 @@ static bool station_roam_scan_notify(int err, struct l_queue *bss_list, bss =l_queue_find (bss_list, bss_match_bssid, current_bss->addr);if (bss && !station->ap_directed_roaming) { cur_bss_rank = bss->rank; + cur_bss_group =scan_bss_evaluate_group ( + current_bss->addr, + current_bss->signal_strength);if (hs->mde && bss->mde_present &&l_get_le16 (bss->mde) == mdid) cur_bss_rank *=RANK_FT_FACTOR ;
@@ -2855,6 +2859,9 @@ static bool station_roam_scan_notify(int err, struct l_queue *bss_list,while ((bss =l_queue_pop_head (bss_list))) {double rank;struct roam_bss *rbss; +enum scan_bss_group group =scan_bss_evaluate_group ( + bss->addr, + bss->signal_strength);station_print_scan_bss (bss);
@@ -2876,8 +2883,7 @@ static bool station_roam_scan_notify(int err, struct l_queue *bss_list,if (network_can_connect_bss (network, bss) <0 ) goto next; -if (blacklist_contains_bss (bss->addr, -BLACKLIST_REASON_CONNECT_FAILED )) +if (group ==SCAN_BSS_GROUP_BLACKLISTED ) goto next; rank = bss->rank;
@@ -2885,7 +2891,15 @@ static bool station_roam_scan_notify(int err, struct l_queue *bss_list,if (hs->mde && bss->mde_present &&l_get_le16 (bss->mde) == mdid) rank *=RANK_FT_FACTOR ; -if (rank <= cur_bss_rank) +/* +* First check the group: +* - If worse, disregard BSS candidate +* - If better, keep BSS candidate +* - If equal, compare based on rank +*/ +if (group < cur_bss_group) + goto next; +else if (group == cur_bss_group && rank <= cur_bss_rank) goto next;/*
Signature · 1 line
2.34.1
PATCH v2 12/13 auto-t: add tests for AP roam blacklisting
In reply to James Prestwood--- autotests/testAPRoam/connection_test.py | 2 +- autotests/testAPRoam/hw.conf | 2 + autotests/testAPRoam/main.conf.roaming | 6 + autotests/testAPRoam/roam_blacklist_test.py | 183 ++++++++++++++++++++ 4 files changed, 192 insertions(+), 1 deletion(-) create mode 100644 autotests/testAPRoam/main.conf.roaming create mode 100644 autotests/testAPRoam/roam_blacklist_test.py
autotests/testAPRoam/connection_test.py +1 -1
@@ -13,7 +13,7 @@ from hostapd import HostapdCLI class Test(unittest.TestCase): def validate(self, expect_roam=True): - wd = IWD() + wd = IWD(True) devices = wd.list_devices(1) device = devices[0]
autotests/testAPRoam/hw.conf +2 -0
@@ -1,5 +1,7 @@ [SETUP] num_radios=4 +hwsim_medium=true +start_iwd=false [HOSTAPD] rad0=ssid1.conf
autotests/testAPRoam/main.conf.roaming new file +6 -0
@@ -0,0 +1,6 @@ +[General] +RoamThreshold=-66 +OptimalSignalThreshold=-72 + +[Blacklist] +InitialRoamRequestedTimeout=20
autotests/testAPRoam/roam_blacklist_test.py new file +183 -0
183 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v2 13/13 doc: document OptimalSignalThreshold and InitialRoamRequestedTimeout
In reply to James Prestwood--- src/iwd.config.rst | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+)
src/iwd.config.rst +21 -0
@@ -149,6 +149,21 @@ The group ``[General]`` contains general settings. This has the same effect as ``CriticalRoamThreshold``, but for the 5GHz band. + * - OptimalSignalThreshold + - Value: rssi dBm value, from -100 to -1, default: **0** (disabled) + + When set to a non-zero value, this enables BSS grouping which is a + sorts BSS's first based on this optimal signal threshold, then by rank. + In addition the BSS's blacklisting status is also taken into account. + IWD will order its connection preference first based on the following + groupings, then followed by rank: + + 1. "Optimal" is the most preferred group. The BSS is both above the + **OptimalSignalThreshold** and not roam blacklisted + 2. "Above Threshold" means the BSS is roam blacklisted, but still above + the **OptimalSignalThreshold** + 3. "Below Threshold" means the BSS is below **OptimalSignalThreshold** + * - RoamRetryInterval - Value: unsigned int value in seconds (default: **60**)
@@ -292,6 +307,12 @@ control how long a misbehaved BSS spends on the blacklist. The initial time that a BSS spends on the blacklist. Setting this to zero will disable blacklisting functionality in IWD. + * - InitialRoamRequestedTimeout + - Values: uint64 value in seconds (default: **30**) + + The initial time that a BSS will be marked after a BSS requests a roam. + This is to aid in avoiding roaming back to BSS's which are likely + overloaded. Setting this to zero will disabled this form of blacklisting. * - Multiplier - Values: unsigned int value greater than zero, in seconds (default: **30**)
Signature · 1 line
2.34.1