• source navigation  • diff markup  • identifier search  • freetext search  • 

Sources/usteer/sta.c

  1 /*
  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.
  5  *
  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.
 10  *
 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.
 14  *
 15  *   Copyright (C) 2020 embedd.ch 
 16  *   Copyright (C) 2020 Felix Fietkau <nbd@nbd.name> 
 17  *   Copyright (C) 2020 John Crispin <john@phrozen.org> 
 18  */
 19 
 20 #include "usteer.h"
 21 
 22 static int
 23 avl_macaddr_cmp(const void *k1, const void *k2, void *ptr)
 24 {
 25         return memcmp(k1, k2, 6);
 26 }
 27 
 28 AVL_TREE(stations, avl_macaddr_cmp, false, NULL);
 29 static struct usteer_timeout_queue tq;
 30 
 31 static void
 32 usteer_sta_del(struct sta *sta)
 33 {
 34         MSG(DEBUG, "Delete station " MAC_ADDR_FMT "\n",
 35             MAC_ADDR_DATA(sta->addr));
 36 
 37         avl_delete(&stations, &sta->avl);
 38         usteer_measurement_report_sta_cleanup(sta);
 39         free(sta);
 40 }
 41 
 42 static void
 43 usteer_sta_info_del(struct sta_info *si)
 44 {
 45         struct sta *sta = si->sta;
 46 
 47         MSG(DEBUG, "Delete station " MAC_ADDR_FMT " entry for node %s\n",
 48             MAC_ADDR_DATA(sta->addr), usteer_node_name(si->node));
 49 
 50         usteer_timeout_cancel(&tq, &si->timeout);
 51         list_del(&si->list);
 52         list_del(&si->node_list);
 53         free(si);
 54 
 55         if (list_empty(&sta->nodes))
 56                 usteer_sta_del(sta);
 57 }
 58 
 59 void
 60 usteer_sta_node_cleanup(struct usteer_node *node)
 61 {
 62         struct sta_info *si, *tmp;
 63 
 64         free(node->rrm_nr);
 65         node->rrm_nr = NULL;
 66 
 67         list_for_each_entry_safe(si, tmp, &node->sta_info, node_list)
 68                 usteer_sta_info_del(si);
 69 }
 70 
 71 static void
 72 usteer_sta_info_timeout(struct usteer_timeout_queue *q, struct usteer_timeout *t)
 73 {
 74         struct sta_info *si = container_of(t, struct sta_info, timeout);
 75 
 76         usteer_sta_info_del(si);
 77 }
 78 
 79 struct sta_info *
 80 usteer_sta_info_get(struct sta *sta, struct usteer_node *node, bool *create)
 81 {
 82         struct sta_info *si;
 83 
 84         list_for_each_entry(si, &sta->nodes, list) {
 85                 if (si->node != node)
 86                         continue;
 87 
 88                 if (create)
 89                         *create = false;
 90 
 91                 return si;
 92         }
 93 
 94         if (!create)
 95                 return NULL;
 96 
 97         MSG(DEBUG, "Create station " MAC_ADDR_FMT " entry for node %s\n",
 98             MAC_ADDR_DATA(sta->addr), usteer_node_name(node));
 99 
100         si = calloc(1, sizeof(*si));
101         si->node = node;
102         si->sta = sta;
103         list_add(&si->list, &sta->nodes);
104         list_add(&si->node_list, &node->sta_info);
105         si->created = current_time;
106         *create = true;
107 
108         /* Node is by default not connected. */
109         usteer_sta_disconnected(si);
110 
111         return si;
112 }
113 
114 
115 void
116 usteer_sta_info_update_timeout(struct sta_info *si, int timeout)
117 {
118         if (si->connected == STA_CONNECTED)
119                 usteer_timeout_cancel(&tq, &si->timeout);
120         else if (timeout > 0)
121                 usteer_timeout_set(&tq, &si->timeout, timeout);
122         else
123                 usteer_sta_info_del(si);
124 }
125 
126 struct sta *
127 usteer_sta_get(const uint8_t *addr, bool create)
128 {
129         struct sta *sta;
130 
131         sta = avl_find_element(&stations, addr, sta, avl);
132         if (sta)
133                 return sta;
134 
135         if (!create)
136                 return NULL;
137 
138         MSG(DEBUG, "Create station entry " MAC_ADDR_FMT "\n", MAC_ADDR_DATA(addr));
139         sta = calloc(1, sizeof(*sta));
140         memcpy(sta->addr, addr, sizeof(sta->addr));
141         sta->avl.key = sta->addr;
142         avl_insert(&stations, &sta->avl);
143         INIT_LIST_HEAD(&sta->nodes);
144         INIT_LIST_HEAD(&sta->measurements);
145 
146         return sta;
147 }
148 
149 void usteer_sta_disconnected(struct sta_info *si)
150 {
151         si->connected = STA_NOT_CONNECTED;
152         si->kick_time = 0;
153         usteer_sta_info_update_timeout(si, config.local_sta_timeout);
154 }
155 
156 void
157 usteer_sta_info_update(struct sta_info *si, int signal, bool avg)
158 {
159         /* ignore probe request signal when connected */
160         if (si->connected == STA_CONNECTED && si->signal != NO_SIGNAL && !avg)
161                 signal = NO_SIGNAL;
162 
163         if (signal != NO_SIGNAL) {
164                 si->signal = signal;
165                 usteer_band_steering_sta_update(si);
166         }
167 
168         si->seen = current_time;
169 
170         if (si->node->freq < 4000)
171                 si->sta->seen_2ghz = 1;
172         else
173                 si->sta->seen_5ghz = 1;
174 
175         usteer_sta_info_update_timeout(si, config.local_sta_timeout);
176 }
177 
178 bool
179 usteer_handle_sta_event(struct usteer_node *node, const uint8_t *addr,
180                        enum usteer_event_type type, int freq, int signal)
181 {
182         struct sta *sta;
183         struct sta_info *si;
184         uint32_t diff;
185         bool ret;
186         bool create;
187 
188         sta = usteer_sta_get(addr, true);
189         if (!sta)
190                 return -1;
191 
192         si = usteer_sta_info_get(sta, node, &create);
193         usteer_sta_info_update(si, signal, false);
194         si->stats[type].requests++;
195 
196         diff = si->stats[type].blocked_last_time - current_time;
197         if (diff > config.sta_block_timeout)
198                 si->stats[type].blocked_cur = 0;
199 
200         ret = usteer_check_request(si, type);
201         if (!ret) {
202                 si->stats[type].blocked_cur++;
203                 si->stats[type].blocked_total++;
204                 si->stats[type].blocked_last_time = current_time;
205         } else {
206                 si->stats[type].blocked_cur = 0;
207         }
208 
209         if (create)
210                 usteer_send_sta_update(si);
211 
212         return ret;
213 }
214 
215 bool
216 usteer_sta_supports_beacon_measurement_mode(struct sta_info *si, enum usteer_beacon_measurement_mode mode)
217 {
218         switch (mode) {
219                 case BEACON_MEASUREMENT_PASSIVE:
220                         return si->rrm & (1 << 4);
221                 case BEACON_MEASUREMENT_ACTIVE:
222                         return si->rrm & (1 << 5);
223                 case BEACON_MEASUREMENT_TABLE:
224                         return si->rrm & (1 << 6);
225         }
226 
227         return false;
228 }
229 
230 bool
231 usteer_sta_supports_link_measurement(struct sta_info *si)
232 {
233         return si->rrm & (1 << 0);
234 }
235 
236 static void __usteer_init usteer_sta_init(void)
237 {
238         usteer_timeout_init(&tq);
239         tq.cb = usteer_sta_info_timeout;
240 }
241 

This page was automatically generated by LXR 0.3.1.  •  OpenWrt