?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert between 56095 -> 55830 in arch
[AROS.git] / workbench / network / WirelessManager / src / drivers / driver_sana2.c
blob3c95ed238cdc794ca80bb86d387d082fdf6afbff
1 /*
2 * WPA Supplicant - AmigaOS/MorphOS/AROS SANA-II driver interface
3 * Copyright (c) 2010-2013, Neil Cafferkey
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * Alternatively, this software may be distributed under the terms of BSD
10 * license.
11 *
12 * See README and COPYING for more details.
13 */
14
15 #include "includes.h"
16
17 #include "common.h"
18 #include "driver.h"
19 #include "eloop.h"
20
21 #include <exec/types.h>
22 #include <exec/io.h>
23 #include <exec/memory.h>
24 #include <dos/dos.h>
25 #include <devices/sana2.h>
26 #include <devices/sana2wireless.h>
27 #include <devices/newstyle.h>
28
29 #include <proto/exec.h>
30 #include <proto/utility.h>
31 #include <proto/dos.h>
32
33 #ifndef UPINT
34 #ifdef __AROS__
35 typedef IPTR UPINT;
36 typedef SIPTR PINT;
37 #else
38 typedef ULONG UPINT;
39 typedef LONG PINT;
40 #endif
41 #endif
42
43 #define ETH_MTU 1500
44 #define MAX_SSID_LEN 32
45
46 #define MAX_TX_POWER 15
47
48 #define PUDDLE_SIZE 2000
49 #define MLME_REQ_COUNT 5
50 #define NULL_INTERVAL 30
51
52 int using_wep = 0;
53
54 void wpa_scan_results_free(struct wpa_scan_results *res);
55
56 static const char device_dir[] = "Networks/";
57
58 static const u8 broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
59
60 #ifdef __AROS__
61 static BOOL wpa_driver_sana2_buffer_hook(UBYTE *dest, UBYTE *src,
62 ULONG size)
63 {
64 CopyMem(src, dest, size);
65 return TRUE;
66 }
67 #else
68 /* m68k code to do the same as above */
69 static const ULONG wpa_driver_sana2_buffer_hook[] =
70 {0xC1492C78, 0x00044EAE, 0xFD907001, 0x4E754E71};
71 #endif
72
73 static const struct TagItem buffer_tags[] = {
74 {S2_CopyToBuff, (UPINT)wpa_driver_sana2_buffer_hook},
75 {S2_CopyFromBuff, (UPINT)wpa_driver_sana2_buffer_hook},
76 {TAG_END, 0}
77 };
78
79 struct wpa_driver_sana2_data {
80 void *ctx;
81 char *device_name;
82 struct MsgPort *port;
83 struct IOSana2Req *request;
84 struct IOSana2Req *event_request;
85 struct IOSana2Req *eapol_request;
86 struct IOSana2Req *mlme_requests[MLME_REQ_COUNT];
87 ULONG event_mask;
88 u8 addr[ETH_ALEN];
89 u8 bssid[ETH_ALEN];
90 char ssid[MAX_SSID_LEN + 1];
91 int freq;
92 int device_opened;
93 int hard_mac;
94 int scanning;
95 int online;
96 };
97
98 static int b_rates[] = {
99 10,
100 20,
101 55,
102 110
103 };
104
105 static int g_rates[] = {
106 10,
107 20,
108 55,
109 110,
110 60,
111 90,
112 120,
113 180,
114 240,
115 360,
116 480,
117 540
118 };
119
120
121 static int wpa_driver_sana2_get_ssid(void *priv, u8 *ssid)
122 {
123 struct wpa_driver_sana2_data *drv = priv;
124 u16 len;
125
126 len = strlen(drv->ssid);
127 os_memcpy(ssid, drv->ssid, len);
128
129 return len;
130 }
131
132
133 static int wpa_driver_sana2_get_bssid(void *priv, u8 *bssid)
134 {
135 struct wpa_driver_sana2_data *drv = priv;
136 u8 *cur_bssid = NULL;
137 struct TagItem *tag_list;
138 struct IOSana2Req *request = drv->request;
139 APTR pool;
140
141 request->ios2_Req.io_Command = S2_GETNETWORKINFO;
142 pool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR, PUDDLE_SIZE, PUDDLE_SIZE);
143 request->ios2_Data = pool;
144 if (pool != NULL && DoIO((APTR)request) == 0) {
145 tag_list = request->ios2_StatData;
146 cur_bssid = (u8 *)GetTagData(S2INFO_BSSID, (UPINT)NULL,
147 tag_list);
148 }
149 if (cur_bssid != NULL) {
150 os_memcpy(bssid, cur_bssid, ETH_ALEN);
151 os_memcpy(drv->bssid, cur_bssid, ETH_ALEN);
152 }
153 DeletePool(pool);
154
155 return (cur_bssid != NULL) ? 0 : 1;
156 }
157
158
159 static int wpa_driver_sana2_scan(void *priv,
160 struct wpa_driver_scan_params *params)
161 {
162 struct wpa_driver_sana2_data *drv = priv;
163 int err = 0;
164 struct IOSana2Req *request = drv->request;
165 const u8 *ssid;
166 size_t ssid_len;
167 TEXT *ssid_str = NULL;
168 struct TagItem *tag_list;
169 APTR pool;
170
171 if (drv->scanning) {
172 printf("[scan] MULTIPLE CONCURRENT SCAN REQUESTS!\n");
173 Delay(200);
174 return 1;
175 }
176
177 pool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR, PUDDLE_SIZE, PUDDLE_SIZE);
178 if (pool == NULL)
179 err = 1;
180
181 if (err == 0) {
182 ssid = params->ssids[0].ssid;
183 ssid_len = params->ssids[0].ssid_len;
184 if (ssid != NULL) {
185 ssid_str = AllocPooled(pool, ssid_len + 1);
186 if (ssid_str != NULL) {
187 CopyMem(ssid, ssid_str, ssid_len);
188 ssid_str[ssid_len] = '\0';
189 } else
190 err = 1;
191 }
192 }
193
194 if (err == 0) {
195 tag_list = AllocPooled(pool, sizeof(struct TagItem) * 2);
196 if (tag_list == NULL)
197 err = 1;
198 }
199
200 if (err == 0) {
201 tag_list[0].ti_Tag = S2INFO_SSID;
202 tag_list[0].ti_Data = (UPINT)ssid_str;
203 tag_list[1].ti_Tag = TAG_END;
204
205 request->ios2_Req.io_Command = S2_GETNETWORKS;
206 request->ios2_Data = pool;
207 request->ios2_StatData = tag_list;
208 SendIO((APTR)request);
209 drv->scanning = 1;
210 }
211
212 return err;
213 }
214
215
216 static struct wpa_scan_results * wpa_driver_sana2_get_scan_results(void *priv)
217 {
218 struct wpa_driver_sana2_data *drv = priv;
219 int err = 0;
220 struct IOSana2Req *request = drv->request;
221 struct wpa_scan_results *results;
222 size_t i, count;
223 struct TagItem **tag_lists, *tag;
224 TEXT *str;
225 UPINT num;
226 u8 *ie;
227 u16 ie_len, ssid_len, *data;
228
229 if (request->ios2_Req.io_Command != S2_GETNETWORKS) return NULL;
230
231 count = request->ios2_DataLength;
232 tag_lists = request->ios2_StatData;
233
234 results = os_zalloc(sizeof(struct wpa_scan_results));
235 if (results == NULL) {
236 err = 1;
237 }
238
239 if (err == 0) {
240 results->res =
241 os_zalloc(count * sizeof(struct wpa_scan_res *));
242 if (results->res != NULL)
243 results->num = count;
244 else
245 err = 1;
246 }
247
248 for (i = 0; i < count && err == 0; i++) {
249 struct wpa_scan_res *res;
250 data = (u16 *)GetTagData(S2INFO_InfoElements,
251 (UPINT)NULL, tag_lists[i]);
252 if (data != NULL)
253 ie_len = data[0];
254 else
255 ie_len = MAX_SSID_LEN + 2;
256 res = results->res[i] =
257 os_zalloc(sizeof(struct wpa_scan_res) + ie_len);
258 if (res == NULL)
259 err = 1;
260
261 if (err == 0) {
262 tag = FindTagItem(S2INFO_BSSID, tag_lists[i]);
263 if (tag != NULL)
264 os_memcpy(res->bssid, (void *)tag->ti_Data,
265 ETH_ALEN);
266
267 num = GetTagData(S2INFO_Channel, 0, tag_lists[i]);
268 if (num == 14)
269 res->freq = 2484;
270 else if (num != 0)
271 res->freq = 2407 + num * 5;
272
273 res->beacon_int = GetTagData(S2INFO_BeaconInterval,
274 0, tag_lists[i]);
275
276 res->caps = GetTagData(S2INFO_Capabilities, 0,
277 tag_lists[i]);
278
279 res->level = GetTagData(S2INFO_Signal, 0, tag_lists[i]);
280
281 res->noise = GetTagData(S2INFO_Noise, 0, tag_lists[i]);
282
283 if (res->level > res->noise)
284 res->qual = res->level - res->noise;
285
286 /* Copy all IEs if available, or make fake IEs
287 * containing just SSID */
288 ie = (u8 *)(res + 1);
289 if (data != NULL) {
290 res->ie_len = ie_len;
291 os_memcpy(ie, data + 1, ie_len);
292 } else {
293 str = (TEXT *)GetTagData(S2INFO_SSID,
294 (UPINT)NULL, tag_lists[i]);
295 if (str != NULL) {
296 ssid_len = strlen((char *)str);
297 res->ie_len = ssid_len + 2;
298 ie[0] = 0;
299 ie[1] = ssid_len;
300 os_memcpy(ie + 2, str, ssid_len);
301 }
302 }
303
304 }
305 }
306 DeletePool(request->ios2_Data);
307
308 if (err != 0) {
309 wpa_scan_results_free(results);
310 results = NULL;
311 }
312
313 drv->scanning = 0;
314 return results;
315 }
316
317
318 static int wpa_driver_sana2_cipher(int cipher)
319 {
320 switch (cipher) {
321 case CIPHER_NONE:
322 return S2ENC_NONE;
323 case CIPHER_WEP40:
324 case CIPHER_WEP104:
325 return S2ENC_WEP;
326 case CIPHER_TKIP:
327 return S2ENC_TKIP;
328 case CIPHER_CCMP:
329 return S2ENC_CCMP;
330 default:
331 return 0;
332 }
333 }
334
335
336 static int wpa_driver_sana2_band(enum hostapd_hw_mode mode)
337 {
338 switch (mode) {
339 case HOSTAPD_MODE_IEEE80211B:
340 return S2BAND_B;
341 case HOSTAPD_MODE_IEEE80211G:
342 return S2BAND_G;
343 case HOSTAPD_MODE_IEEE80211A:
344 return S2BAND_A;
345 default:
346 return 0;
347 }
348 }
349
350
351 static int wpa_driver_sana2_set_key(const char *ifname, void *priv,
352 enum wpa_alg alg, const u8 *addr, int key_idx, int set_tx,
353 const u8 *seq, size_t seq_len, const u8 *key, size_t key_len)
354 {
355 struct wpa_driver_sana2_data *drv = priv;
356 int err = 0;
357 struct IOSana2Req *request = drv->request;
358
359 request->ios2_Req.io_Command = S2_SETKEY;
360 request->ios2_WireError = key_idx;
361 request->ios2_PacketType = wpa_driver_sana2_cipher(alg);
362 request->ios2_DataLength = key_len;
363 request->ios2_Data = (u8 *) key;
364 request->ios2_StatData = (u8 *) seq;
365
366 /* Work-around for a bug in MLME code */
367 if (wpa_driver_sana2_cipher(alg) == S2ENC_WEP)
368 using_wep = 1;
369
370 err = DoIO((APTR)request);
371
372 return err;
373 }
374
375
376 static int wpa_driver_sana2_associate(
377 void *priv, struct wpa_driver_associate_params *params)
378 {
379 struct wpa_driver_sana2_data *drv = priv;
380 int err = 0, i, alg;
381 struct IOSana2Req *request = drv->request;
382 struct TagItem *tag_list2 = NULL;
383 char *ssid = os_zalloc(MAX_SSID_LEN + 1);
384 struct TagItem tag_list[] =
385 {{S2INFO_SSID, (UPINT)ssid},
386 {(params->bssid != NULL) ? S2INFO_BSSID : TAG_IGNORE,
387 (UPINT)params->bssid},
388 {S2INFO_PortType, (params->mode == IEEE80211_MODE_IBSS) ?
389 S2PORT_ADHOC : S2PORT_MANAGED},
390 {S2INFO_Channel, params->freq == 2484 ?
391 14 : (params->freq - 2407) / 5},
392 {S2INFO_WPAInfo, (params->wpa_ie_len > 0) ?
393 (UPINT)params->wpa_ie : (UPINT)NULL},
394 {S2INFO_AuthTypes, params->auth_alg},
395 {TAG_END, 0}};
396
397 if (ssid == NULL) {
398 err = 1;
399 }
400
401 if (err == 0) {
402 CopyMem(params->ssid, ssid, params->ssid_len);
403 ssid[params->ssid_len] = '\0';
404
405 tag_list2 = CloneTagItems(tag_list);
406 if (tag_list2 == NULL) {
407 err = 1;
408 }
409 }
410
411 /* Set or clear WEP keys */
412 for (i = 0; i < 4; i++) {
413 if (params->wep_key_len[i] > 0)
414 alg = WPA_ALG_WEP;
415 else
416 alg = WPA_ALG_NONE;
417 wpa_driver_sana2_set_key(NULL, priv, alg, broadcast_addr, i,
418 i == params->wep_tx_keyidx, NULL, 0,
419 params->wep_key[i], params->wep_key_len[i]);
420 }
421
422 /* Set other options */
423 if (err == 0) {
424 request->ios2_Req.io_Command = S2_SETOPTIONS;
425 request->ios2_Data = tag_list2;
426 err = DoIO((APTR)request);
427 FreeTagItems(tag_list2);
428 }
429
430 /* Store current SSID and BSSID */
431 if (err == 0) {
432 strcpy(drv->ssid, ssid);
433 }
434
435 return 0;
436 }
437
438
439 static int wpa_driver_sana2_get_capa(void *priv, struct wpa_driver_capa *capa)
440 {
441 struct wpa_driver_sana2_data *drv = priv;
442 u8 *enc_list = NULL;
443 int i;
444 struct IOSana2Req *request = drv->request;
445 APTR pool;
446
447 os_memset(capa, 0, sizeof(*capa));
448
449 request->ios2_Req.io_Command = S2_GETCRYPTTYPES;
450 pool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR, PUDDLE_SIZE, PUDDLE_SIZE);
451 request->ios2_Data = pool;
452 if (pool != NULL && DoIO((APTR)request) == 0) {
453 enc_list = request->ios2_StatData;
454 for (i = 0; i < request->ios2_DataLength; i++)
455 {
456 switch (enc_list[i]) {
457 case S2ENC_WEP:
458 capa->enc |= WPA_DRIVER_CAPA_ENC_WEP40
459 | WPA_DRIVER_CAPA_ENC_WEP104;
460 break;
461 case S2ENC_TKIP:
462 capa->enc |= WPA_DRIVER_CAPA_ENC_TKIP;
463 break;
464 case S2ENC_CCMP:
465 capa->enc |= WPA_DRIVER_CAPA_ENC_CCMP;
466 break;
467 }
468 }
469 } else
470 capa->enc = WPA_DRIVER_CAPA_ENC_WEP40 |
471 WPA_DRIVER_CAPA_ENC_WEP104 |
472 WPA_DRIVER_CAPA_ENC_TKIP |
473 WPA_DRIVER_CAPA_ENC_CCMP;
474 DeletePool(pool);
475
476 if (capa->enc & WPA_DRIVER_CAPA_ENC_TKIP) {
477 capa->key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA |
478 WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK;
479 }
480 if (capa->enc & WPA_DRIVER_CAPA_ENC_CCMP) {
481 capa->key_mgmt |= WPA_DRIVER_CAPA_KEY_MGMT_WPA2 |
482 WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK;
483 }
484
485 if (!drv->hard_mac)
486 capa->flags = WPA_DRIVER_FLAGS_USER_SPACE_MLME;
487
488 return 0;
489 }
490
491
492 static int wpa_driver_sana2_send_eapol(void *priv, const u8 *dest, u16 proto,
493 const u8 *data, size_t data_len)
494 {
495 struct wpa_driver_sana2_data *drv = priv;
496 struct IOSana2Req *request = drv->request;
497
498 request->ios2_Req.io_Command = CMD_WRITE;
499 request->ios2_Req.io_Flags = 0;
500 CopyMem(dest, request->ios2_DstAddr, ETH_ALEN);
501 request->ios2_PacketType = proto;
502 request->ios2_DataLength = data_len;
503 request->ios2_Data = (APTR)data;
504
505 return DoIO((APTR)request);
506 }
507
508
509 static void wpa_driver_sana2_stay_alive(void *eloop_ctx, void *timeout_ctx)
510 {
511 struct wpa_driver_sana2_data *drv = timeout_ctx;
512
513 wpa_driver_sana2_send_eapol(drv, drv->bssid, 0, NULL, 0);
514 eloop_register_timeout(NULL_INTERVAL, 0, wpa_driver_sana2_stay_alive,
515 drv->ctx, drv);
516 }
517
518
519 static const u8 *wpa_driver_sana2_get_mac_addr(void *priv)
520 {
521 struct wpa_driver_sana2_data *drv = priv;
522
523 return drv->addr;
524 }
525
526
527 static struct hostapd_hw_modes * wpa_driver_sana2_get_hw_feature_data(
528 void *priv, u16 *num_modes, u16 *flags)
529 {
530 int err = 0, i, mode_count, channel_count, rate_count;
531 struct hostapd_hw_modes *modes;
532
533 /* IEEE 802.11b */
534 mode_count = 2;
535 channel_count = 14;
536 rate_count = 4;
537
538 modes = os_zalloc(sizeof(struct hostapd_hw_modes) * mode_count);
539 if (modes == NULL) {
540 err = 1;
541 }
542
543 if (err == 0) {
544 modes[0].mode = HOSTAPD_MODE_IEEE80211B;
545
546 modes[0].num_channels = channel_count;
547 modes[0].channels = os_zalloc(
548 channel_count * sizeof(struct hostapd_channel_data));
549 if (modes[0].channels == NULL)
550 err = 1;
551 }
552
553 if (err == 0) {
554 for (i = 0; i < 13; i++) {
555 modes[0].channels[i].chan = i + 1;
556 modes[0].channels[i].freq = 2407 + (i + 1) * 5;
557 modes[0].channels[i].flag = 0;
558 modes[0].channels[i].max_tx_power = MAX_TX_POWER;
559 }
560 modes[0].channels[i].chan = 14;
561 modes[0].channels[i].freq = 2484;
562 modes[0].channels[i].flag = 0;
563 modes[0].channels[i].max_tx_power = MAX_TX_POWER;
564 }
565
566 if (err == 0) {
567 modes[0].num_rates = rate_count;
568 modes[0].rates = os_zalloc(rate_count * sizeof(int));
569 if (modes[0].rates == NULL)
570 err = 1;
571 }
572
573 if (err == 0) {
574 os_memcpy(modes[0].rates, b_rates, sizeof(b_rates));
575 }
576
577 /* IEEE 802.11g */
578 channel_count = 13;
579 rate_count = 12;
580
581 if (err == 0) {
582 modes[1].mode = HOSTAPD_MODE_IEEE80211G;
583
584 modes[1].num_channels = channel_count;
585 modes[1].channels = os_zalloc(
586 channel_count * sizeof(struct hostapd_channel_data));
587 if (modes[1].channels == NULL)
588 err = 1;
589 }
590
591 if (err == 0) {
592 for (i = 0; i < 13; i++) {
593 modes[1].channels[i].chan = i + 1;
594 modes[1].channels[i].freq = 2407 + (i + 1) * 5;
595 modes[1].channels[i].flag = 0;
596 modes[1].channels[i].max_tx_power = MAX_TX_POWER;
597 }
598 }
599
600 if (err == 0) {
601 modes[1].num_rates = rate_count;
602 modes[1].rates = os_zalloc(rate_count * sizeof(int));
603 if (modes[1].rates == NULL)
604 err = 1;
605 }
606
607 if (err == 0) {
608 os_memcpy(modes[1].rates, g_rates, sizeof(g_rates));
609 }
610
611 if (err != 0) {
612 os_free(modes[0].channels);
613 os_free(modes[0].rates);
614 os_free(modes[1].channels);
615 os_free(modes[1].rates);
616 modes = NULL;
617 }
618
619 *num_modes = mode_count;
620 *flags = 0;
621 return modes;
622 }
623
624
625 static int wpa_driver_sana2_set_channel(void *priv,
626 enum hostapd_hw_mode phymode, int chan, int freq)
627 {
628 struct wpa_driver_sana2_data *drv = priv;
629 struct IOSana2Req *request = drv->request;
630 struct TagItem tag_list[] =
631 {{S2INFO_Band, wpa_driver_sana2_band(phymode)},
632 {S2INFO_Channel, chan},
633 {TAG_END, 0}};
634
635 drv->freq = freq;
636 request->ios2_Req.io_Command = S2_SETOPTIONS;
637 request->ios2_Data = tag_list;
638 return DoIO((APTR)request);
639 }
640
641
642 static int wpa_driver_sana2_set_ssid(void *priv, const u8 *ssid,
643 size_t ssid_len)
644 {
645 struct wpa_driver_sana2_data *drv = priv;
646 struct IOSana2Req *request = drv->request;
647 TEXT ssid_str[ssid_len + 1];
648 struct TagItem tag_list[] =
649 {{S2INFO_SSID, (UPINT)ssid_str},
650 {TAG_END, 0}};
651
652 CopyMem(ssid, ssid_str, ssid_len);
653 ssid_str[ssid_len] = '\0';
654
655 request->ios2_Req.io_Command = S2_SETOPTIONS;
656 request->ios2_Data = tag_list;
657 return DoIO((APTR)request);
658 }
659
660
661 static int wpa_driver_sana2_set_bssid(void *priv, const u8 *bssid)
662 {
663 struct wpa_driver_sana2_data *drv = priv;
664 struct IOSana2Req *request = drv->request;
665 struct TagItem tag_list[] =
666 {{S2INFO_BSSID, (UPINT)bssid},
667 {TAG_END, 0}};
668
669 CopyMem(bssid, drv->bssid, ETH_ALEN);
670
671 request->ios2_Req.io_Command = S2_SETOPTIONS;
672 request->ios2_Data = tag_list;
673 return DoIO((APTR)request);
674 }
675
676
677 static int wpa_driver_sana2_set_associd(void *priv, u16 aid)
678 {
679 struct wpa_driver_sana2_data *drv = priv;
680 struct IOSana2Req *request = drv->request;
681 struct TagItem tag_list[] =
682 {{S2INFO_AssocID, aid},
683 {TAG_END, 0}};
684
685 eloop_register_timeout(NULL_INTERVAL, 0, wpa_driver_sana2_stay_alive,
686 drv->ctx, drv);
687
688 request->ios2_Req.io_Command = S2_SETOPTIONS;
689 request->ios2_Data = tag_list;
690 return DoIO((APTR)request);
691 }
692
693
694 static int wpa_driver_sana2_set_capabilities(void *priv, u16 capab)
695 {
696 struct wpa_driver_sana2_data *drv = priv;
697 struct IOSana2Req *request = drv->request;
698 struct TagItem tag_list[] =
699 {{S2INFO_Capabilities, capab},
700 {TAG_END, 0}};
701
702 request->ios2_Req.io_Command = S2_SETOPTIONS;
703 request->ios2_Data = tag_list;
704 return DoIO((APTR)request);
705 }
706
707
708 static int wpa_driver_sana2_send_mlme(void *priv, const u8 *data,
709 size_t data_len)
710 {
711 struct wpa_driver_sana2_data *drv = priv;
712 struct IOSana2Req *request = drv->request;
713
714 wpa_printf(MSG_DEBUG, "sana2: sending MLME frame");
715 request->ios2_Req.io_Command = S2_WRITEMGMT;
716 request->ios2_Req.io_Flags = 0;
717 request->ios2_DataLength = data_len;
718 request->ios2_Data = (APTR)data;
719
720 return DoIO((APTR)request);
721 }
722
723
724 static int wpa_driver_sana2_mlme_add_sta(void *priv, const u8 *addr,
725 const u8 *supp_rates, size_t supp_rates_len)
726 {
727 return 0;
728 }
729
730
731 static int wpa_driver_sana2_mlme_remove_sta(void *priv, const u8 *addr)
732 {
733 return 0;
734 }
735
736
737 static void wpa_driver_sana2_event_handler(int sig, void *sig_ctx)
738 {
739 struct wpa_driver_sana2_data *drv = sig_ctx;
740 int i;
741 ULONG events;
742 struct IOSana2Req *request;
743 union wpa_event_data event_data;
744 struct TagItem *tag_list;
745 u8 *ie;
746 APTR pool;
747
748 os_memset(&event_data, 0, sizeof(event_data));
749
750 /* Propagate events */
751 while ((request = (APTR)GetMsg(drv->port)) != NULL)
752 {
753 switch (request->ios2_Req.io_Command)
754 {
755 case CMD_READ:
756 if (request->ios2_Req.io_Error == 0) {
757 /* Deliver frame to supplicant */
758 drv_event_eapol_rx(drv->ctx,
759 request->ios2_SrcAddr,
760 request->ios2_Data,
761 request->ios2_DataLength);
762 }
763 if (request->ios2_Req.io_Error != S2ERR_OUTOFSERVICE) {
764 /* Send request back for next frame */
765 SendIO((APTR)request);
766 }
767 break;
768
769 case S2_READMGMT:
770 if (request->ios2_Req.io_Error == 0) {
771 /* Deliver frame to supplicant */
772 os_memset(&event_data, 0, sizeof(event_data));
773 event_data.mlme_rx.buf = request->ios2_Data;
774 event_data.mlme_rx.len =
775 request->ios2_DataLength;
776 event_data.mlme_rx.freq = drv->freq;
777 wpa_supplicant_event(drv->ctx, EVENT_MLME_RX,
778 &event_data);
779 }
780 if (request->ios2_Req.io_Error != S2ERR_OUTOFSERVICE) {
781 /* Send request back for next frame */
782 request->ios2_DataLength = ETH_MTU;
783 SendIO((APTR)request);
784 }
785 break;
786
787 case S2_ONEVENT:
788 events = request->ios2_WireError;
789 if (request->ios2_Req.io_Error != 0)
790 events = 0;
791 if (events & S2EVENT_CONNECT)
792 {
793 request->ios2_Req.io_Command =
794 S2_GETNETWORKINFO;
795 pool = CreatePool(MEMF_PUBLIC | MEMF_CLEAR,
796 PUDDLE_SIZE, PUDDLE_SIZE);
797 request->ios2_Data = pool;
798 if (pool != NULL && DoIO((APTR)request) == 0)
799 {
800 tag_list = request->ios2_StatData;
801 event_data.assoc_info.req_ies = ie =
802 (u8 *)GetTagData(S2INFO_WPAInfo,
803 (UPINT)NULL,
804 tag_list);
805 } else
806 ie = NULL;
807 if (ie != NULL)
808 event_data.assoc_info.req_ies_len =
809 ie[1] + 2;
810 else
811 event_data.assoc_info.req_ies_len = 0;
812
813 wpa_supplicant_event(drv->ctx, EVENT_ASSOC,
814 &event_data);
815
816 DeletePool(pool);
817
818 /* Start periodic sending of null-data frames */
819 eloop_register_timeout(NULL_INTERVAL, 0,
820 wpa_driver_sana2_stay_alive,
821 drv->ctx, drv);
822 }
823
824 if (events & S2EVENT_DISCONNECT) {
825 wpa_supplicant_event(drv->ctx, EVENT_DISASSOC,
826 NULL);
827
828 /* Stop periodic sending of null-data frames */
829 eloop_cancel_timeout(
830 wpa_driver_sana2_stay_alive,
831 drv->ctx, drv);
832 }
833
834 if (events & S2EVENT_ONLINE) {
835 drv->event_mask &= ~S2EVENT_ONLINE;
836 drv->event_mask |= S2EVENT_OFFLINE;
837
838 /* Send read requests back for next frame */
839 SendIO((APTR)drv->eapol_request);
840 if (!drv->hard_mac)
841 for (i = 0; i < MLME_REQ_COUNT; i++)
842 SendIO((APTR)
843 drv->mlme_requests[i]);
844 }
845
846 if (events & S2EVENT_OFFLINE) {
847 drv->event_mask &= ~S2EVENT_OFFLINE;
848 drv->event_mask |= S2EVENT_ONLINE;
849 }
850
851 /* Send request back to receive next event */
852 request->ios2_Req.io_Command = S2_ONEVENT;
853 request->ios2_WireError = drv->event_mask;
854 SendIO((APTR)request);
855 break;
856
857 case S2_GETNETWORKS:
858 wpa_supplicant_event(drv->ctx, EVENT_SCAN_RESULTS,
859 NULL);
860 break;
861 }
862 }
863 }
864
865
866 static void wpa_driver_sana2_deinit(void *priv)
867 {
868 struct wpa_driver_sana2_data *drv = priv;
869 int i;
870
871 /* Abort outstanding I/O requests */
872 if (drv->eapol_request != NULL) {
873 AbortIO((APTR)drv->eapol_request);
874 WaitIO((APTR)drv->eapol_request);
875 FreeVec(drv->eapol_request);
876 }
877
878 for (i = 0; i < MLME_REQ_COUNT; i++) {
879 if (drv->mlme_requests[i] != NULL) {
880 AbortIO((APTR)drv->mlme_requests[i]);
881 WaitIO((APTR)drv->mlme_requests[i]);
882 FreeVec(drv->mlme_requests[i]);
883 }
884 }
885
886 if (drv->event_request != NULL) {
887 AbortIO((APTR)drv->event_request);
888 WaitIO((APTR)drv->event_request);
889 }
890
891 /* Close device */
892 if (drv->device_opened) {
893 AbortIO((APTR)drv->request);
894 WaitIO((APTR)drv->request);
895 CloseDevice((APTR)drv->request);
896 }
897 DeleteIORequest((APTR)drv->request);
898 DeleteMsgPort(drv->port);
899
900 FreeVec(drv->device_name);
901
902 os_free(drv);
903 }
904
905
906 static void * wpa_driver_sana2_init(void *ctx, const char *ifname)
907 {
908 struct wpa_driver_sana2_data *drv;
909 int err = 0, i;
910 char *end, *p;
911 ULONG unit_no;
912 struct IOSana2Req *request, *eapol_request, *mlme_request;
913 struct NSDeviceQueryResult device_info =
914 {0, sizeof(struct NSDeviceQueryResult)};
915
916 drv = os_zalloc(sizeof(*drv));
917 if (drv == NULL)
918 return NULL;
919 drv->ctx = ctx;
920 drv->device_name = AllocVec(strlen(device_dir) + strlen(ifname),
921 MEMF_PUBLIC);
922 if (drv->device_name == NULL)
923 err = 1;
924
925 /* Split fake interface name into device and unit */
926 if (err == 0) {
927 end = strrchr(ifname, ':');
928 if (strchr(ifname, ':') == end && strchr(ifname, '/') == NULL) {
929 strcpy(drv->device_name, device_dir);
930 p = drv->device_name + strlen(device_dir);
931 } else
932 p = drv->device_name;
933 strncpy(p, ifname, end - ifname);
934 p[end - ifname] = '\0';
935
936 unit_no = atoi(end + 1);
937
938 drv->port = CreateMsgPort();
939 drv->request = (APTR)CreateIORequest(drv->port,
940 sizeof(struct IOSana2Req));
941 if (drv->request == NULL)
942 err = 1;
943 }
944
945 if (err == 0) {
946 /* Open device */
947 drv->request->ios2_BufferManagement = (APTR)buffer_tags;
948 if (OpenDevice((TEXT *)drv->device_name, unit_no,
949 (APTR)drv->request, 0) != 0)
950 err = 1;
951 }
952
953 /* Register a handler for the port's signal */
954 if (err == 0) {
955 drv->device_opened = 1;
956
957 eloop_register_signal(drv->port->mp_SigBit,
958 wpa_driver_sana2_event_handler, drv);
959 }
960
961 /* Check if this is a hard-MAC device */
962 if (err == 0) {
963 request = drv->request;
964 ((struct IOStdReq *)request)->io_Command = NSCMD_DEVICEQUERY;
965 ((struct IOStdReq *)request)->io_Data = &device_info;
966 if (DoIO((APTR)request) != 0)
967 err = 1;
968 else {
969 for (i = 0; device_info.SupportedCommands[i] != 0; i++)
970 if (device_info.SupportedCommands[i]
971 == S2_GETNETWORKS)
972 drv->hard_mac = 1;
973 }
974 }
975
976 /* Put device online */
977 if (err == 0) {
978 request = drv->request;
979 request->ios2_Req.io_Command = S2_GETSTATIONADDRESS;
980 if (DoIO((APTR)request) != 0)
981 err = 1;
982 }
983
984 if (err == 0) {
985 CopyMem(request->ios2_DstAddr, drv->addr, ETH_ALEN);
986
987 request->ios2_Req.io_Command = S2_CONFIGINTERFACE;
988 CopyMem(drv->addr, request->ios2_SrcAddr, ETH_ALEN);
989
990 if (DoIO((APTR)request) != 0) {
991 if (request->ios2_WireError == S2WERR_IS_CONFIGURED) {
992 request->ios2_Req.io_Command = S2_ONLINE;
993 DoIO((APTR)request);
994 } else
995 err = 1;
996 }
997 drv->online = 1;
998 }
999
1000 /* Create and queue up EAPOL frame read request */
1001 if (err == 0) {
1002 request = drv->request;
1003 request->ios2_Req.io_Command = CMD_READ;
1004 request->ios2_PacketType = ETH_P_EAPOL;
1005
1006 eapol_request = AllocVec(sizeof(struct IOSana2Req) + ETH_MTU,
1007 MEMF_PUBLIC | MEMF_CLEAR);
1008 if (eapol_request == NULL)
1009 err = 1;
1010 }
1011
1012 if (err == 0) {
1013 CopyMem(drv->request, eapol_request,
1014 sizeof(struct IOSana2Req));
1015 eapol_request->ios2_Data = eapol_request + 1;
1016 drv->eapol_request = eapol_request;
1017
1018 SendIO((APTR)eapol_request);
1019 }
1020
1021 /* Create and queue up management frame read requests */
1022 if (err == 0 && !drv->hard_mac) {
1023 request = drv->request;
1024 request->ios2_Req.io_Command = S2_READMGMT;
1025 request->ios2_DataLength = ETH_MTU;
1026 for (i = 0; i < MLME_REQ_COUNT; i++) {
1027 mlme_request =
1028 AllocVec(sizeof(struct IOSana2Req) + ETH_MTU,
1029 MEMF_PUBLIC | MEMF_CLEAR);
1030 if (mlme_request == NULL)
1031 err = 1;
1032
1033 if (err == 0) {
1034 CopyMem(drv->request, mlme_request,
1035 sizeof(struct IOSana2Req));
1036 mlme_request->ios2_Data = mlme_request + 1;
1037 drv->mlme_requests[i] = mlme_request;
1038
1039 SendIO((APTR)mlme_request);
1040 }
1041 }
1042 }
1043
1044 if (err == 0) {
1045 /* Create and send event-notification request */
1046 request = drv->request;
1047 request->ios2_Req.io_Command = S2_ONEVENT;
1048 if (drv->hard_mac)
1049 drv->event_mask = S2EVENT_CONNECT | S2EVENT_DISCONNECT
1050 | S2EVENT_OFFLINE;
1051 else
1052 drv->event_mask = S2EVENT_OFFLINE;
1053 request->ios2_WireError = drv->event_mask;
1054
1055 drv->event_request = AllocVec(sizeof(struct IOSana2Req),
1056 MEMF_PUBLIC | MEMF_CLEAR);
1057 if (drv->event_request == NULL)
1058 err = 1;
1059 }
1060
1061 if (err == 0) {
1062 CopyMem(drv->request, drv->event_request,
1063 sizeof(struct IOSana2Req));
1064
1065 SendIO((APTR)drv->event_request);
1066 }
1067
1068 if (err != 0) {
1069 wpa_driver_sana2_deinit(drv);
1070 drv = NULL;
1071 }
1072
1073 return drv;
1074 }
1075
1076
1077 const struct wpa_driver_ops wpa_driver_sana2_ops = {
1078 .name = "sana2",
1079 .desc = "SANA-II driver",
1080 .get_bssid = wpa_driver_sana2_get_bssid,
1081 .get_ssid = wpa_driver_sana2_get_ssid,
1082 .set_key = wpa_driver_sana2_set_key,
1083 .init = wpa_driver_sana2_init,
1084 .deinit = wpa_driver_sana2_deinit,
1085 .scan2 = wpa_driver_sana2_scan,
1086 .associate = wpa_driver_sana2_associate,
1087 .get_capa = wpa_driver_sana2_get_capa,
1088 .get_mac_addr = wpa_driver_sana2_get_mac_addr,
1089 .send_eapol = wpa_driver_sana2_send_eapol,
1090 .get_scan_results2 = wpa_driver_sana2_get_scan_results,
1091 .get_hw_feature_data = wpa_driver_sana2_get_hw_feature_data,
1092 .set_channel = wpa_driver_sana2_set_channel,
1093 .set_ssid = wpa_driver_sana2_set_ssid,
1094 .set_bssid = wpa_driver_sana2_set_bssid,
1095 .set_associd = wpa_driver_sana2_set_associd,
1096 .set_capabilities = wpa_driver_sana2_set_capabilities,
1097 .send_mlme = wpa_driver_sana2_send_mlme,
1098 .mlme_add_sta = wpa_driver_sana2_mlme_add_sta,
1099 .mlme_remove_sta = wpa_driver_sana2_mlme_remove_sta,
1100 };
Mirror of AROS' svn.