Line data    Source code

       1             : /*
       2             :  * wpa_supplicant - Temporary BSSID blacklist
       3             :  * Copyright (c) 2003-2007, Jouni Malinen <j@w1.fi>
       4             :  *
       5             :  * This software may be distributed under the terms of the BSD license.
       6             :  * See README for more details.
       7             :  */
       8             : 
       9             : #include "includes.h"
      10             : 
      11             : #include "common.h"
      12             : #include "wpa_supplicant_i.h"
      13             : #include "blacklist.h"
      14             : 
      15             : /**
      16             :  * wpa_blacklist_get - Get the blacklist entry for a BSSID
      17             :  * @wpa_s: Pointer to wpa_supplicant data
      18             :  * @bssid: BSSID
      19             :  * Returns: Matching blacklist entry for the BSSID or %NULL if not found
      20             :  */
      21        6514 : struct wpa_blacklist * wpa_blacklist_get(struct wpa_supplicant *wpa_s,
      22             :                                          const u8 *bssid)
      23             : {
      24             :         struct wpa_blacklist *e;
      25             : 
      26        6514 :         if (wpa_s == NULL || bssid == NULL)
      27           3 :                 return NULL;
      28             : 
      29        6511 :         e = wpa_s->blacklist;
      30       13256 :         while (e) {
      31        1429 :                 if (os_memcmp(e->bssid, bssid, ETH_ALEN) == 0)
      32        1195 :                         return e;
      33         234 :                 e = e->next;
      34             :         }
      35             : 
      36        5316 :         return NULL;
      37             : }
      38             : 
      39             : 
      40             : /**
      41             :  * wpa_blacklist_add - Add an BSSID to the blacklist
      42             :  * @wpa_s: Pointer to wpa_supplicant data
      43             :  * @bssid: BSSID to be added to the blacklist
      44             :  * Returns: Current blacklist count on success, -1 on failure
      45             :  *
      46             :  * This function adds the specified BSSID to the blacklist or increases the
      47             :  * blacklist count if the BSSID was already listed. It should be called when
      48             :  * an association attempt fails either due to the selected BSS rejecting
      49             :  * association or due to timeout.
      50             :  *
      51             :  * This blacklist is used to force %wpa_supplicant to go through all available
      52             :  * BSSes before retrying to associate with an BSS that rejected or timed out
      53             :  * association. It does not prevent the listed BSS from being used; it only
      54             :  * changes the order in which they are tried.
      55             :  */
      56        1812 : int wpa_blacklist_add(struct wpa_supplicant *wpa_s, const u8 *bssid)
      57             : {
      58             :         struct wpa_blacklist *e;
      59             : 
      60        1812 :         if (wpa_s == NULL || bssid == NULL)
      61           3 :                 return -1;
      62             : 
      63        1809 :         e = wpa_blacklist_get(wpa_s, bssid);
      64        1809 :         if (e) {
      65          88 :                 e->count++;
      66         616 :                 wpa_printf(MSG_DEBUG, "BSSID " MACSTR " blacklist count "
      67             :                            "incremented to %d",
      68         528 :                            MAC2STR(bssid), e->count);
      69          88 :                 return e->count;
      70             :         }
      71             : 
      72        1721 :         e = os_zalloc(sizeof(*e));
      73        1721 :         if (e == NULL)
      74           1 :                 return -1;
      75        1720 :         os_memcpy(e->bssid, bssid, ETH_ALEN);
      76        1720 :         e->count = 1;
      77        1720 :         e->next = wpa_s->blacklist;
      78        1720 :         wpa_s->blacklist = e;
      79       10320 :         wpa_printf(MSG_DEBUG, "Added BSSID " MACSTR " into blacklist",
      80       10320 :                    MAC2STR(bssid));
      81             : 
      82        1720 :         return e->count;
      83             : }
      84             : 
      85             : 
      86             : /**
      87             :  * wpa_blacklist_del - Remove an BSSID from the blacklist
      88             :  * @wpa_s: Pointer to wpa_supplicant data
      89             :  * @bssid: BSSID to be removed from the blacklist
      90             :  * Returns: 0 on success, -1 on failure
      91             :  */
      92        2312 : int wpa_blacklist_del(struct wpa_supplicant *wpa_s, const u8 *bssid)
      93             : {
      94        2312 :         struct wpa_blacklist *e, *prev = NULL;
      95             : 
      96        2312 :         if (wpa_s == NULL || bssid == NULL)
      97           3 :                 return -1;
      98             : 
      99        2309 :         e = wpa_s->blacklist;
     100        4650 :         while (e) {
     101          45 :                 if (os_memcmp(e->bssid, bssid, ETH_ALEN) == 0) {
     102          13 :                         if (prev == NULL) {
     103          10 :                                 wpa_s->blacklist = e->next;
     104             :                         } else {
     105           3 :                                 prev->next = e->next;
     106             :                         }
     107          78 :                         wpa_printf(MSG_DEBUG, "Removed BSSID " MACSTR " from "
     108          78 :                                    "blacklist", MAC2STR(bssid));
     109          13 :                         os_free(e);
     110          13 :                         return 0;
     111             :                 }
     112          32 :                 prev = e;
     113          32 :                 e = e->next;
     114             :         }
     115        2296 :         return -1;
     116             : }
     117             : 
     118             : 
     119             : /**
     120             :  * wpa_blacklist_clear - Clear the blacklist of all entries
     121             :  * @wpa_s: Pointer to wpa_supplicant data
     122             :  */
     123        4396 : void wpa_blacklist_clear(struct wpa_supplicant *wpa_s)
     124             : {
     125             :         struct wpa_blacklist *e, *prev;
     126        4396 :         int max_count = 0;
     127             : 
     128        4396 :         e = wpa_s->blacklist;
     129        4396 :         wpa_s->blacklist = NULL;
     130       10499 :         while (e) {
     131        1707 :                 if (e->count > max_count)
     132        1685 :                         max_count = e->count;
     133        1707 :                 prev = e;
     134        1707 :                 e = e->next;
     135       10242 :                 wpa_printf(MSG_DEBUG, "Removed BSSID " MACSTR " from "
     136       10242 :                            "blacklist (clear)", MAC2STR(prev->bssid));
     137        1707 :                 os_free(prev);
     138             :         }
     139             : 
     140        4396 :         wpa_s->extra_blacklist_count += max_count;
     141        4396 : }