?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] core-dumping unreadable binaries via PT_INTERP
[linux-2.6/verdex.git] / net / ieee80211 / softmac / ieee80211softmac_module.c
blob256207b71dc94ce135aca1d3adc36f5c49875305
1 /*
2 * Contains some basic softmac functions along with module registration code etc.
3 *
4 * Copyright (c) 2005, 2006 Johannes Berg <johannes@sipsolutions.net>
5 * Joseph Jezak <josejx@gentoo.org>
6 * Larry Finger <Larry.Finger@lwfinger.net>
7 * Danny van Dyk <kugelfang@gentoo.org>
8 * Michael Buesch <mbuesch@freenet.de>
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but WITHOUT
15 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
17 * more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 * The full GNU General Public License is included in this distribution in the
24 * file called COPYING.
25 */
26
27 #include "ieee80211softmac_priv.h"
28 #include <linux/sort.h>
29 #include <linux/etherdevice.h>
30
31 struct net_device *alloc_ieee80211softmac(int sizeof_priv)
32 {
33 struct ieee80211softmac_device *softmac;
34 struct net_device *dev;
35
36 dev = alloc_ieee80211(sizeof(struct ieee80211softmac_device) + sizeof_priv);
37 softmac = ieee80211_priv(dev);
38 softmac->dev = dev;
39 softmac->ieee = netdev_priv(dev);
40 spin_lock_init(&softmac->lock);
41
42 softmac->ieee->handle_auth = ieee80211softmac_auth_resp;
43 softmac->ieee->handle_deauth = ieee80211softmac_deauth_resp;
44 softmac->ieee->handle_assoc_response = ieee80211softmac_handle_assoc_response;
45 softmac->ieee->handle_reassoc_request = ieee80211softmac_handle_reassoc_req;
46 softmac->ieee->handle_disassoc = ieee80211softmac_handle_disassoc;
47 softmac->ieee->handle_beacon = ieee80211softmac_handle_beacon;
48 softmac->scaninfo = NULL;
49
50 softmac->associnfo.scan_retry = IEEE80211SOFTMAC_ASSOC_SCAN_RETRY_LIMIT;
51
52 /* TODO: initialise all the other callbacks in the ieee struct
53 * (once they're written)
54 */
55
56 INIT_LIST_HEAD(&softmac->auth_queue);
57 INIT_LIST_HEAD(&softmac->network_list);
58 INIT_LIST_HEAD(&softmac->events);
59
60 mutex_init(&softmac->associnfo.mutex);
61 INIT_DELAYED_WORK(&softmac->associnfo.work, ieee80211softmac_assoc_work);
62 INIT_DELAYED_WORK(&softmac->associnfo.timeout, ieee80211softmac_assoc_timeout);
63 softmac->start_scan = ieee80211softmac_start_scan_implementation;
64 softmac->wait_for_scan = ieee80211softmac_wait_for_scan_implementation;
65 softmac->stop_scan = ieee80211softmac_stop_scan_implementation;
66
67 /* to start with, we can't send anything ... */
68 netif_carrier_off(dev);
69
70 return dev;
71 }
72 EXPORT_SYMBOL_GPL(alloc_ieee80211softmac);
73
74 /* Clears the pending work queue items, stops all scans, etc. */
75 void
76 ieee80211softmac_clear_pending_work(struct ieee80211softmac_device *sm)
77 {
78 unsigned long flags;
79 struct ieee80211softmac_event *eventptr, *eventtmp;
80 struct ieee80211softmac_auth_queue_item *authptr, *authtmp;
81 struct ieee80211softmac_network *netptr, *nettmp;
82
83 ieee80211softmac_stop_scan(sm);
84 ieee80211softmac_wait_for_scan(sm);
85
86 spin_lock_irqsave(&sm->lock, flags);
87 sm->running = 0;
88
89 /* Free all pending assoc work items */
90 cancel_delayed_work(&sm->associnfo.work);
91
92 /* Free all pending scan work items */
93 if(sm->scaninfo != NULL)
94 cancel_delayed_work(&sm->scaninfo->softmac_scan);
95
96 /* Free all pending auth work items */
97 list_for_each_entry(authptr, &sm->auth_queue, list)
98 cancel_delayed_work(&authptr->work);
99
100 /* delete all pending event calls and work items */
101 list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list)
102 cancel_delayed_work(&eventptr->work);
103
104 spin_unlock_irqrestore(&sm->lock, flags);
105 flush_scheduled_work();
106
107 /* now we should be save and no longer need locking... */
108 spin_lock_irqsave(&sm->lock, flags);
109 /* Free all pending auth work items */
110 list_for_each_entry_safe(authptr, authtmp, &sm->auth_queue, list) {
111 list_del(&authptr->list);
112 kfree(authptr);
113 }
114
115 /* delete all pending event calls and work items */
116 list_for_each_entry_safe(eventptr, eventtmp, &sm->events, list) {
117 list_del(&eventptr->list);
118 kfree(eventptr);
119 }
120
121 /* Free all networks */
122 list_for_each_entry_safe(netptr, nettmp, &sm->network_list, list) {
123 ieee80211softmac_del_network_locked(sm, netptr);
124 if(netptr->challenge != NULL)
125 kfree(netptr->challenge);
126 kfree(netptr);
127 }
128
129 spin_unlock_irqrestore(&sm->lock, flags);
130 }
131 EXPORT_SYMBOL_GPL(ieee80211softmac_clear_pending_work);
132
133 void free_ieee80211softmac(struct net_device *dev)
134 {
135 struct ieee80211softmac_device *sm = ieee80211_priv(dev);
136 ieee80211softmac_clear_pending_work(sm);
137 kfree(sm->scaninfo);
138 kfree(sm->wpa.IE);
139 free_ieee80211(dev);
140 }
141 EXPORT_SYMBOL_GPL(free_ieee80211softmac);
142
143 static void ieee80211softmac_start_check_rates(struct ieee80211softmac_device *mac)
144 {
145 struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
146 /* I took out the sorting check, we're seperating by modulation now. */
147 if (ri->count)
148 return;
149 /* otherwise assume we hav'em all! */
150 if (mac->ieee->modulation & IEEE80211_CCK_MODULATION) {
151 ri->rates[ri->count++] = IEEE80211_CCK_RATE_1MB;
152 ri->rates[ri->count++] = IEEE80211_CCK_RATE_2MB;
153 ri->rates[ri->count++] = IEEE80211_CCK_RATE_5MB;
154 ri->rates[ri->count++] = IEEE80211_CCK_RATE_11MB;
155 }
156 if (mac->ieee->modulation & IEEE80211_OFDM_MODULATION) {
157 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_6MB;
158 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_9MB;
159 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_12MB;
160 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_18MB;
161 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_24MB;
162 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_36MB;
163 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_48MB;
164 ri->rates[ri->count++] = IEEE80211_OFDM_RATE_54MB;
165 }
166 }
167
168 int ieee80211softmac_ratesinfo_rate_supported(struct ieee80211softmac_ratesinfo *ri, u8 rate)
169 {
170 int search;
171 u8 search_rate;
172
173 for (search = 0; search < ri->count; search++) {
174 search_rate = ri->rates[search];
175 search_rate &= ~IEEE80211_BASIC_RATE_MASK;
176 if (rate == search_rate)
177 return 1;
178 }
179
180 return 0;
181 }
182
183 u8 ieee80211softmac_highest_supported_rate(struct ieee80211softmac_device *mac,
184 struct ieee80211softmac_ratesinfo *ri, int basic_only)
185 {
186 u8 user_rate = mac->txrates.user_rate;
187 int i;
188
189 if (ri->count == 0)
190 return IEEE80211_CCK_RATE_1MB;
191
192 for (i = ri->count - 1; i >= 0; i--) {
193 u8 rate = ri->rates[i];
194 if (basic_only && !(rate & IEEE80211_BASIC_RATE_MASK))
195 continue;
196 rate &= ~IEEE80211_BASIC_RATE_MASK;
197 if (rate > user_rate)
198 continue;
199 if (ieee80211softmac_ratesinfo_rate_supported(&mac->ratesinfo, rate))
200 return rate;
201 }
202
203 /* If we haven't found a suitable rate by now, just trust the user */
204 return user_rate;
205 }
206 EXPORT_SYMBOL_GPL(ieee80211softmac_highest_supported_rate);
207
208 void ieee80211softmac_process_erp(struct ieee80211softmac_device *mac,
209 u8 erp_value)
210 {
211 int use_protection;
212 int short_preamble;
213 u32 changes = 0;
214
215 /* Barker preamble mode */
216 short_preamble = ((erp_value & WLAN_ERP_BARKER_PREAMBLE) == 0
217 && mac->associnfo.short_preamble_available) ? 1 : 0;
218
219 /* Protection needed? */
220 use_protection = (erp_value & WLAN_ERP_USE_PROTECTION) != 0;
221
222 if (mac->bssinfo.short_preamble != short_preamble) {
223 changes |= IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE;
224 mac->bssinfo.short_preamble = short_preamble;
225 }
226
227 if (mac->bssinfo.use_protection != use_protection) {
228 changes |= IEEE80211SOFTMAC_BSSINFOCHG_PROTECTION;
229 mac->bssinfo.use_protection = use_protection;
230 }
231
232 if (mac->bssinfo_change && changes)
233 mac->bssinfo_change(mac->dev, changes);
234 }
235
236 void ieee80211softmac_recalc_txrates(struct ieee80211softmac_device *mac)
237 {
238 struct ieee80211softmac_txrates *txrates = &mac->txrates;
239 u32 change = 0;
240
241 change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
242 txrates->default_rate = ieee80211softmac_highest_supported_rate(mac, &mac->bssinfo.supported_rates, 0);
243
244 change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
245 txrates->default_fallback = lower_rate(mac, txrates->default_rate);
246
247 change |= IEEE80211SOFTMAC_TXRATECHG_MCAST;
248 txrates->mcast_rate = ieee80211softmac_highest_supported_rate(mac, &mac->bssinfo.supported_rates, 1);
249
250 if (mac->txrates_change)
251 mac->txrates_change(mac->dev, change);
252
253 }
254
255 void ieee80211softmac_init_bss(struct ieee80211softmac_device *mac)
256 {
257 struct ieee80211_device *ieee = mac->ieee;
258 u32 change = 0;
259 struct ieee80211softmac_txrates *txrates = &mac->txrates;
260 struct ieee80211softmac_bss_info *bssinfo = &mac->bssinfo;
261
262 /* TODO: We need some kind of state machine to lower the default rates
263 * if we loose too many packets.
264 */
265 /* Change the default txrate to the highest possible value.
266 * The txrate machine will lower it, if it is too high.
267 */
268 /* FIXME: We don't correctly handle backing down to lower
269 rates, so 801.11g devices start off at 11M for now. People
270 can manually change it if they really need to, but 11M is
271 more reliable. Note similar logic in
272 ieee80211softmac_wx_set_rate() */
273 if (ieee->modulation & IEEE80211_CCK_MODULATION) {
274 txrates->user_rate = IEEE80211_CCK_RATE_11MB;
275 } else if (ieee->modulation & IEEE80211_OFDM_MODULATION) {
276 txrates->user_rate = IEEE80211_OFDM_RATE_54MB;
277 } else
278 assert(0);
279
280 txrates->default_rate = IEEE80211_CCK_RATE_1MB;
281 change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
282
283 txrates->default_fallback = IEEE80211_CCK_RATE_1MB;
284 change |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
285
286 txrates->mcast_rate = IEEE80211_CCK_RATE_1MB;
287 change |= IEEE80211SOFTMAC_TXRATECHG_MCAST;
288
289 txrates->mgt_mcast_rate = IEEE80211_CCK_RATE_1MB;
290 change |= IEEE80211SOFTMAC_TXRATECHG_MGT_MCAST;
291
292 if (mac->txrates_change)
293 mac->txrates_change(mac->dev, change);
294
295 change = 0;
296
297 bssinfo->supported_rates.count = 0;
298 memset(bssinfo->supported_rates.rates, 0,
299 sizeof(bssinfo->supported_rates.rates));
300 change |= IEEE80211SOFTMAC_BSSINFOCHG_RATES;
301
302 bssinfo->short_preamble = 0;
303 change |= IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE;
304
305 bssinfo->use_protection = 0;
306 change |= IEEE80211SOFTMAC_BSSINFOCHG_PROTECTION;
307
308 if (mac->bssinfo_change)
309 mac->bssinfo_change(mac->dev, change);
310
311 mac->running = 1;
312 }
313
314 void ieee80211softmac_start(struct net_device *dev)
315 {
316 struct ieee80211softmac_device *mac = ieee80211_priv(dev);
317
318 ieee80211softmac_start_check_rates(mac);
319 ieee80211softmac_init_bss(mac);
320 }
321 EXPORT_SYMBOL_GPL(ieee80211softmac_start);
322
323 void ieee80211softmac_stop(struct net_device *dev)
324 {
325 struct ieee80211softmac_device *mac = ieee80211_priv(dev);
326
327 ieee80211softmac_clear_pending_work(mac);
328 }
329 EXPORT_SYMBOL_GPL(ieee80211softmac_stop);
330
331 void ieee80211softmac_set_rates(struct net_device *dev, u8 count, u8 *rates)
332 {
333 struct ieee80211softmac_device *mac = ieee80211_priv(dev);
334 unsigned long flags;
335
336 spin_lock_irqsave(&mac->lock, flags);
337 memcpy(mac->ratesinfo.rates, rates, count);
338 mac->ratesinfo.count = count;
339 spin_unlock_irqrestore(&mac->lock, flags);
340 }
341 EXPORT_SYMBOL_GPL(ieee80211softmac_set_rates);
342
343 static u8 raise_rate(struct ieee80211softmac_device *mac, u8 rate)
344 {
345 int i;
346 struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
347
348 for (i=0; i<ri->count-1; i++) {
349 if (ri->rates[i] == rate)
350 return ri->rates[i+1];
351 }
352 /* I guess we can't go any higher... */
353 return ri->rates[ri->count];
354 }
355
356 u8 ieee80211softmac_lower_rate_delta(struct ieee80211softmac_device *mac, u8 rate, int delta)
357 {
358 int i;
359 struct ieee80211softmac_ratesinfo *ri = &mac->ratesinfo;
360
361 for (i=delta; i<ri->count; i++) {
362 if (ri->rates[i] == rate)
363 return ri->rates[i-delta];
364 }
365 /* I guess we can't go any lower... */
366 return ri->rates[0];
367 }
368
369 static void ieee80211softmac_add_txrates_badness(struct ieee80211softmac_device *mac,
370 int amount)
371 {
372 u8 default_rate = mac->txrates.default_rate;
373 u8 default_fallback = mac->txrates.default_fallback;
374 u32 changes = 0;
375
376 //TODO: This is highly experimental code.
377 // Maybe the dynamic rate selection does not work
378 // and it has to be removed again.
379
380 printk("badness %d\n", mac->txrate_badness);
381 mac->txrate_badness += amount;
382 if (mac->txrate_badness <= -1000) {
383 /* Very small badness. Try a faster bitrate. */
384 default_rate = raise_rate(mac, default_rate);
385 changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
386 default_fallback = get_fallback_rate(mac, default_rate);
387 changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
388 mac->txrate_badness = 0;
389 printk("Bitrate raised to %u\n", default_rate);
390 } else if (mac->txrate_badness >= 10000) {
391 /* Very high badness. Try a slower bitrate. */
392 default_rate = lower_rate(mac, default_rate);
393 changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT;
394 default_fallback = get_fallback_rate(mac, default_rate);
395 changes |= IEEE80211SOFTMAC_TXRATECHG_DEFAULT_FBACK;
396 mac->txrate_badness = 0;
397 printk("Bitrate lowered to %u\n", default_rate);
398 }
399
400 mac->txrates.default_rate = default_rate;
401 mac->txrates.default_fallback = default_fallback;
402
403 if (changes && mac->txrates_change)
404 mac->txrates_change(mac->dev, changes);
405 }
406
407 void ieee80211softmac_fragment_lost(struct net_device *dev,
408 u16 wl_seq)
409 {
410 struct ieee80211softmac_device *mac = ieee80211_priv(dev);
411 unsigned long flags;
412
413 spin_lock_irqsave(&mac->lock, flags);
414 ieee80211softmac_add_txrates_badness(mac, 1000);
415 //TODO
416
417 spin_unlock_irqrestore(&mac->lock, flags);
418 }
419 EXPORT_SYMBOL_GPL(ieee80211softmac_fragment_lost);
420
421 static int rate_cmp(const void *a_, const void *b_) {
422 u8 *a, *b;
423 a = (u8*)a_;
424 b = (u8*)b_;
425 return ((*a & ~IEEE80211_BASIC_RATE_MASK) - (*b & ~IEEE80211_BASIC_RATE_MASK));
426 }
427
428 /* Allocate a softmac network struct and fill it from a network */
429 struct ieee80211softmac_network *
430 ieee80211softmac_create_network(struct ieee80211softmac_device *mac,
431 struct ieee80211_network *net)
432 {
433 struct ieee80211softmac_network *softnet;
434 softnet = kzalloc(sizeof(struct ieee80211softmac_network), GFP_ATOMIC);
435 if(softnet == NULL)
436 return NULL;
437 memcpy(softnet->bssid, net->bssid, ETH_ALEN);
438 softnet->channel = net->channel;
439 softnet->essid.len = net->ssid_len;
440 memcpy(softnet->essid.data, net->ssid, softnet->essid.len);
441
442 /* copy rates over */
443 softnet->supported_rates.count = net->rates_len;
444 memcpy(&softnet->supported_rates.rates[0], net->rates, net->rates_len);
445 memcpy(&softnet->supported_rates.rates[softnet->supported_rates.count], net->rates_ex, net->rates_ex_len);
446 softnet->supported_rates.count += net->rates_ex_len;
447 sort(softnet->supported_rates.rates, softnet->supported_rates.count, sizeof(softnet->supported_rates.rates[0]), rate_cmp, NULL);
448
449 /* we save the ERP value because it is needed at association time, and
450 * many AP's do not include an ERP IE in the association response. */
451 softnet->erp_value = net->erp_value;
452
453 softnet->capabilities = net->capability;
454 return softnet;
455 }
456
457
458 /* Add a network to the list, while locked */
459 void
460 ieee80211softmac_add_network_locked(struct ieee80211softmac_device *mac,
461 struct ieee80211softmac_network *add_net)
462 {
463 struct list_head *list_ptr;
464 struct ieee80211softmac_network *softmac_net = NULL;
465
466 list_for_each(list_ptr, &mac->network_list) {
467 softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
468 if(!memcmp(softmac_net->bssid, add_net->bssid, ETH_ALEN))
469 break;
470 else
471 softmac_net = NULL;
472 }
473 if(softmac_net == NULL)
474 list_add(&(add_net->list), &mac->network_list);
475 }
476
477 /* Add a network to the list, with locking */
478 void
479 ieee80211softmac_add_network(struct ieee80211softmac_device *mac,
480 struct ieee80211softmac_network *add_net)
481 {
482 unsigned long flags;
483 spin_lock_irqsave(&mac->lock, flags);
484 ieee80211softmac_add_network_locked(mac, add_net);
485 spin_unlock_irqrestore(&mac->lock, flags);
486 }
487
488
489 /* Delete a network from the list, while locked*/
490 void
491 ieee80211softmac_del_network_locked(struct ieee80211softmac_device *mac,
492 struct ieee80211softmac_network *del_net)
493 {
494 list_del(&(del_net->list));
495 }
496
497 /* Delete a network from the list with locking */
498 void
499 ieee80211softmac_del_network(struct ieee80211softmac_device *mac,
500 struct ieee80211softmac_network *del_net)
501 {
502 unsigned long flags;
503 spin_lock_irqsave(&mac->lock, flags);
504 ieee80211softmac_del_network_locked(mac, del_net);
505 spin_unlock_irqrestore(&mac->lock, flags);
506 }
507
508 /* Get a network from the list by MAC while locked */
509 struct ieee80211softmac_network *
510 ieee80211softmac_get_network_by_bssid_locked(struct ieee80211softmac_device *mac,
511 u8 *bssid)
512 {
513 struct list_head *list_ptr;
514 struct ieee80211softmac_network *softmac_net = NULL;
515 list_for_each(list_ptr, &mac->network_list) {
516 softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
517 if(!memcmp(softmac_net->bssid, bssid, ETH_ALEN))
518 break;
519 else
520 softmac_net = NULL;
521 }
522 return softmac_net;
523 }
524
525 /* Get a network from the list by BSSID with locking */
526 struct ieee80211softmac_network *
527 ieee80211softmac_get_network_by_bssid(struct ieee80211softmac_device *mac,
528 u8 *bssid)
529 {
530 unsigned long flags;
531 struct ieee80211softmac_network *softmac_net;
532
533 spin_lock_irqsave(&mac->lock, flags);
534 softmac_net = ieee80211softmac_get_network_by_bssid_locked(mac, bssid);
535 spin_unlock_irqrestore(&mac->lock, flags);
536 return softmac_net;
537 }
538
539 /* Get a network from the list by ESSID while locked */
540 struct ieee80211softmac_network *
541 ieee80211softmac_get_network_by_essid_locked(struct ieee80211softmac_device *mac,
542 struct ieee80211softmac_essid *essid)
543 {
544 struct list_head *list_ptr;
545 struct ieee80211softmac_network *softmac_net = NULL;
546
547 list_for_each(list_ptr, &mac->network_list) {
548 softmac_net = list_entry(list_ptr, struct ieee80211softmac_network, list);
549 if (softmac_net->essid.len == essid->len &&
550 !memcmp(softmac_net->essid.data, essid->data, essid->len))
551 return softmac_net;
552 }
553 return NULL;
554 }
555
556 /* Get a network from the list by ESSID with locking */
557 struct ieee80211softmac_network *
558 ieee80211softmac_get_network_by_essid(struct ieee80211softmac_device *mac,
559 struct ieee80211softmac_essid *essid)
560 {
561 unsigned long flags;
562 struct ieee80211softmac_network *softmac_net = NULL;
563
564 spin_lock_irqsave(&mac->lock, flags);
565 softmac_net = ieee80211softmac_get_network_by_essid_locked(mac, essid);
566 spin_unlock_irqrestore(&mac->lock, flags);
567 return softmac_net;
568 }
569
570 MODULE_LICENSE("GPL");
571 MODULE_AUTHOR("Johannes Berg");
572 MODULE_AUTHOR("Joseph Jezak");
573 MODULE_AUTHOR("Larry Finger");
574 MODULE_AUTHOR("Danny van Dyk");
575 MODULE_AUTHOR("Michael Buesch");
576 MODULE_DESCRIPTION("802.11 software MAC");
Verdex Pro support