Contents of /trunk/wpa_supplicant/patches/wpa-supplicant-0.2.4-zydas-support.patch
Parent Directory | Revision Log
Revision 153 -
(show annotations)
(download)
Tue May 8 20:52:56 2007 UTC (17 years, 4 months ago) by niro
File size: 15761 byte(s)
Tue May 8 20:52:56 2007 UTC (17 years, 4 months ago) by niro
File size: 15761 byte(s)
-import
1 | diff -wBNur wpa_supplicant-0.2.4/Makefile lnx_wpa_supplicant_1_2_0_0/Makefile |
2 | --- wpa_supplicant-0.2.4/Makefile 2004-07-18 02:14:25.000000000 +0200 |
3 | +++ lnx_wpa_supplicant_1_2_0_0/Makefile 2005-08-01 11:14:38.000000000 +0200 |
4 | @@ -89,6 +94,12 @@ |
5 | CONFIG_WIRELESS_EXTENSION=y |
6 | endif |
7 | |
8 | +ifdef CONFIG_DRIVER_ZYDAS |
9 | +CFLAGS += -DCONFIG_DRIVER_ZYDAS |
10 | +OBJS += driver_zydas.o |
11 | +CONFIG_WIRELESS_EXTENSION=y |
12 | +endif |
13 | + |
14 | ifdef CONFIG_EAP_TLS |
15 | # EAP-TLS |
16 | CFLAGS += -DEAP_TLS |
17 | diff -wBNur wpa_supplicant-0.2.4/wpa_supplicant.c lnx_wpa_supplicant_1_2_0_0/wpa_supplicant.c |
18 | --- wpa_supplicant-0.2.4/wpa_supplicant.c 2004-07-18 02:03:46.000000000 +0200 |
19 | +++ lnx_wpa_supplicant_1_2_0_0/wpa_supplicant.c 2005-08-01 11:14:37.000000000 +0200 |
20 | @@ -1354,6 +1355,9 @@ |
21 | /* driver_ndiswrapper.c */ |
22 | extern struct wpa_driver_ops wpa_driver_ndiswrapper_ops; |
23 | #endif /* CONFIG_DRIVER_NDISWRAPPER */ |
24 | +#ifdef CONFIG_DRIVER_ZYDAS |
25 | +extern struct wpa_driver_ops wpa_driver_zydas_ops; /* driver_zydas.c */ |
26 | +#endif /* CONFIG_DRIVER_ZYDAS */ |
27 | |
28 | static int wpa_supplicant_set_driver(struct wpa_supplicant *wpa_s, |
29 | const char *name) |
30 | @@ -1377,6 +1381,8 @@ |
31 | def_drv = &wpa_driver_wext_ops; |
32 | #elif CONFIG_DRIVER_NDISWRAPPER |
33 | def_drv = &wpa_driver_ndiswrapper_ops; |
34 | +#elif CONFIG_DRIVER_ZYDAS |
35 | + def_drv = &wpa_driver_zydas_ops; |
36 | #else |
37 | #error No driver support included in .config. |
38 | #error See README for more information. |
39 | @@ -1412,6 +1418,10 @@ |
40 | else if (strcmp(name, "ndiswrapper") == 0) |
41 | wpa_s->driver = &wpa_driver_ndiswrapper_ops; |
42 | #endif /* CONFIG_DRIVER_NDISWRAPPER */ |
43 | +#ifdef CONFIG_DRIVER_ZYDAS |
44 | + else if (strcmp(name, "zydas") == 0) |
45 | + wpa_s->driver = &wpa_driver_zydas_ops; |
46 | +#endif /* CONFIG_DRIVER_ZYDAS */ |
47 | else { |
48 | printf("Unsupported driver '%s'.\n", name); |
49 | return -1; |
50 | @@ -1507,6 +1517,9 @@ |
51 | #ifdef CONFIG_DRIVER_NDISWRAPPER |
52 | " ndiswrapper = Linux ndiswrapper\n" |
53 | #endif /* CONFIG_DRIVER_NDISWRAPER */ |
54 | +#ifdef CONFIG_DRIVER_ZYDAS |
55 | + " zydas = ZyDAS 802.11 driver (ZD1211)\n" |
56 | +#endif /* CONFIG_DRIVER_ZYDAS */ |
57 | "options:\n" |
58 | " -B = run daemon in the background\n" |
59 | " -d = increase debugging verbosity (-dd even more)\n" |
60 | diff -wBNur wpa_supplicant-0.2.4/driver_zydas.c lnx_wpa_supplicant_1_2_0_0/driver_zydas.c |
61 | --- wpa_supplicant-0.2.4/driver_zydas.c 1970-01-01 01:00:00.000000000 +0100 |
62 | +++ lnx_wpa_supplicant_1_2_0_0/driver_zydas.c 2005-08-01 11:14:37.000000000 +0200 |
63 | @@ -0,0 +1,444 @@ |
64 | +/* |
65 | + * WPA Supplicant - driver interaction with MADWIFI 802.11 driver |
66 | + * Copyright (c) 2004, Sam Leffler <sam@errno.com> |
67 | + * |
68 | + * This program is free software; you can redistribute it and/or modify |
69 | + * it under the terms of the GNU General Public License version 2 as |
70 | + * published by the Free Software Foundation. |
71 | + * |
72 | + * Alternatively, this software may be distributed under the terms of BSD |
73 | + * license. |
74 | + * |
75 | + * See README and COPYING for more details. |
76 | + */ |
77 | + |
78 | +#include <stdlib.h> |
79 | +#include <stdio.h> |
80 | +#include <unistd.h> |
81 | +#include <string.h> |
82 | +#include <sys/ioctl.h> |
83 | +#include <errno.h> |
84 | + |
85 | +#include "common.h" |
86 | +#include "driver.h" |
87 | +#include "driver_wext.h" |
88 | +#include "eloop.h" |
89 | +#include "wpa_supplicant.h" |
90 | +#include "zydas_common.h" |
91 | + |
92 | +#include <net/if_arp.h> |
93 | +#include <linux/wireless.h> |
94 | + |
95 | +static int zydas_ioctl(const char *ifname, struct zydas_wlan_param *param, |
96 | + int len, int show_err) |
97 | +{ |
98 | + int s; |
99 | + struct iwreq iwr; |
100 | + |
101 | + s = socket(PF_INET, SOCK_DGRAM, 0); |
102 | + if (s < 0) { |
103 | + perror("socket"); |
104 | + return -1; |
105 | + } |
106 | + memset(&iwr, 0, sizeof(iwr)); |
107 | + strncpy(iwr.ifr_name, ifname, IFNAMSIZ); |
108 | + iwr.u.data.pointer = (caddr_t) param; |
109 | + iwr.u.data.length = len; |
110 | + |
111 | + if (ioctl(s, ZD_IOCTL_WPA, &iwr) < 0) { |
112 | + int ret; |
113 | + close(s); |
114 | + ret = errno; |
115 | + if (show_err) |
116 | + perror("ioctl[ZD_IOCTL_WPA]"); |
117 | + return ret; |
118 | + } |
119 | + close(s); |
120 | + |
121 | + return 0; |
122 | +} |
123 | + |
124 | +static int |
125 | +zydas_set_param(const char *ifname, int op, int arg, int show_err) |
126 | +{ |
127 | + struct iwreq iwr; |
128 | + int *i, s, ret = 0; |
129 | + |
130 | + s = socket(PF_INET, SOCK_DGRAM, 0); |
131 | + if (s < 0) { |
132 | + perror("socket[PF_INET,SOCK_DGRAM]"); |
133 | + return -1; |
134 | + } |
135 | + |
136 | + memset(&iwr, 0, sizeof(iwr)); |
137 | + strncpy(iwr.ifr_name, ifname, IFNAMSIZ); |
138 | + i = (int *) iwr.u.name; |
139 | + *i++ = op; |
140 | + *i++ = arg; |
141 | + |
142 | + if (ioctl(s, ZD_IOCTL_PARAM, &iwr) < 0) { |
143 | + perror("ioctl[ZD_IOCTL_PARAM]"); |
144 | + ret = -1; |
145 | + } |
146 | + close(s); |
147 | + |
148 | + return ret; |
149 | +} |
150 | + |
151 | +static int |
152 | +getifflags(const char *ifname, int *flags) |
153 | +{ |
154 | + struct ifreq ifr; |
155 | + int s; |
156 | + |
157 | + s = socket(PF_INET, SOCK_DGRAM, 0); |
158 | + if (s < 0) { |
159 | + perror("socket"); |
160 | + return -1; |
161 | + } |
162 | + |
163 | + memset(&ifr, 0, sizeof(ifr)); |
164 | + strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name)); |
165 | + if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) { |
166 | + perror("SIOCGIFFLAGS"); |
167 | + return errno; |
168 | + } |
169 | + *flags = ifr.ifr_flags & 0xffff; |
170 | + return 0; |
171 | +} |
172 | + |
173 | +static int |
174 | +setifflags(const char *ifname, int flags) |
175 | +{ |
176 | + struct ifreq ifr; |
177 | + int s; |
178 | + |
179 | + s = socket(PF_INET, SOCK_DGRAM, 0); |
180 | + if (s < 0) { |
181 | + perror("socket"); |
182 | + return -1; |
183 | + } |
184 | + |
185 | + memset(&ifr, 0, sizeof(ifr)); |
186 | + strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name)); |
187 | + ifr.ifr_flags = flags & 0xffff; |
188 | + if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0) { |
189 | + perror("SIOCSIFFLAGS"); |
190 | + return errno; |
191 | + } |
192 | + return 0; |
193 | +} |
194 | + |
195 | +static int |
196 | +wpa_driver_zydas_set_wpa_ie(const char *ifname, |
197 | + const char *wpa_ie, size_t wpa_ie_len) |
198 | +{ |
199 | + struct zydas_wlan_param *param; |
200 | + int res; |
201 | + size_t blen = ZD_GENERIC_ELEMENT_HDR_LEN + wpa_ie_len; |
202 | + if (blen < sizeof(*param)) |
203 | + blen = sizeof(*param); |
204 | + |
205 | + param = (struct zydas_wlan_param *) malloc(blen); |
206 | + if (param == NULL) |
207 | + return -1; |
208 | + |
209 | + memset(param, 0, blen); |
210 | + param->cmd = ZD_CMD_SET_GENERIC_ELEMENT; |
211 | + param->u.generic_elem.len = wpa_ie_len; |
212 | + memcpy(param->u.generic_elem.data, wpa_ie, wpa_ie_len); |
213 | + res = zydas_ioctl(ifname, param, blen, 1); |
214 | + |
215 | + free(param); |
216 | + |
217 | + return res; |
218 | +} |
219 | + |
220 | +static int |
221 | +wpa_driver_zydas_set_wpa(const char *ifname, int enabled) |
222 | +{ |
223 | + int ret = 0; |
224 | + |
225 | + wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); |
226 | + |
227 | + if (!enabled && wpa_driver_zydas_set_wpa_ie(ifname, NULL, 0) < 0) |
228 | + ret = -1; |
229 | + if (zydas_set_param(ifname, ZD_PARAM_ROAMING, enabled, 1) < 0) |
230 | + ret = -1; |
231 | + if (zydas_set_param(ifname, ZD_PARAM_PRIVACY, enabled, 1) < 0) |
232 | + ret = -1; |
233 | + if (zydas_set_param(ifname, ZD_PARAM_WPA, enabled, 1) < 0) |
234 | + ret = -1; |
235 | + |
236 | + return ret; |
237 | +} |
238 | + |
239 | +static int |
240 | +wpa_driver_zydas_set_key(const char *ifname, wpa_alg alg, |
241 | + unsigned char *addr, int key_idx, |
242 | + int set_tx, u8 *seq, size_t seq_len, |
243 | + u8 *key, size_t key_len) |
244 | +{ |
245 | + struct zydas_wlan_param *param; |
246 | + u8 *buf; |
247 | + size_t blen; |
248 | + int ret = 0; |
249 | + char *alg_name; |
250 | + |
251 | + switch (alg) { |
252 | + case WPA_ALG_NONE: |
253 | + alg_name = "NONE"; |
254 | + break; |
255 | + case WPA_ALG_WEP: |
256 | + alg_name = "WEP"; |
257 | + break; |
258 | + case WPA_ALG_TKIP: |
259 | + alg_name = "TKIP"; |
260 | + break; |
261 | + case WPA_ALG_CCMP: |
262 | + alg_name = "CCMP"; |
263 | + break; |
264 | + default: |
265 | + return -1; |
266 | + } |
267 | + |
268 | + wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%d " |
269 | + "key_len=%d", __FUNCTION__, alg_name, key_idx, set_tx, |
270 | + seq_len, key_len); |
271 | + |
272 | + if (seq_len > 8) |
273 | + return -2; |
274 | + |
275 | + blen = sizeof(*param) + key_len; |
276 | + buf = malloc(blen); |
277 | + if (buf == NULL) |
278 | + return -1; |
279 | + memset(buf, 0, blen); |
280 | + |
281 | + param = (struct zydas_wlan_param *) buf; |
282 | + param->cmd = ZD_CMD_SET_ENCRYPT_KEY; |
283 | + /* TODO: In theory, STA in client mode can use five keys; four default |
284 | + * keys for receiving (with keyidx 0..3) and one individual key for |
285 | + * both transmitting and receiving (keyidx 0) _unicast_ packets. Now, |
286 | + * keyidx 0 is reserved for this unicast use and default keys can only |
287 | + * use keyidx 1..3 (i.e., default key with keyidx 0 is not supported). |
288 | + * This should be fine for more or less all cases, but for completeness |
289 | + * sake, the driver could be enhanced to support the missing key. */ |
290 | +#if 0 |
291 | + if (addr == NULL) |
292 | + memset(param->sta_addr, 0xff, ETH_ALEN); |
293 | + else |
294 | + memcpy(param->sta_addr, addr, ETH_ALEN); |
295 | +#else |
296 | + memset(param->sta_addr, 0xff, ETH_ALEN); |
297 | +#endif |
298 | + strncpy(param->u.crypt.alg, alg_name, ZD_CRYPT_ALG_NAME_LEN); |
299 | + param->u.crypt.flags = set_tx ? ZD_FLAG_SET_TX_KEY : 0; |
300 | + param->u.crypt.idx = key_idx; |
301 | + memcpy(param->u.crypt.seq, seq, seq_len); |
302 | + param->u.crypt.key_len = key_len; |
303 | + memcpy((u8 *) param->u.crypt.key, key, key_len); |
304 | + |
305 | + /* Dump key context */ |
306 | + if(alg == WPA_ALG_TKIP) { |
307 | + int ii; |
308 | + |
309 | + wpa_printf(MSG_DEBUG, "Key Context:"); |
310 | + for(ii = 0; ii < key_len; ) { |
311 | + printf("0x%02x ", key[ii]); |
312 | + |
313 | + if((++ii % 16) == 0) |
314 | + printf("\n"); |
315 | + } |
316 | + |
317 | + printf("\n"); |
318 | + } |
319 | + |
320 | + if (zydas_ioctl(ifname, param, blen, 1)) { |
321 | + wpa_printf(MSG_WARNING, "Failed to set encryption."); |
322 | + //show_set_key_error(param); |
323 | + ret = -1; |
324 | + } |
325 | + free(buf); |
326 | + |
327 | + return ret; |
328 | +} |
329 | + |
330 | +static int |
331 | +wpa_driver_zydas_set_countermeasures(const char *ifname, int enabled) |
332 | +{ |
333 | + /* Enable the countermeasure */ |
334 | + wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); |
335 | + return zydas_set_param(ifname, ZD_PARAM_COUNTERMEASURES, enabled, 1); |
336 | +} |
337 | + |
338 | +static int |
339 | +wpa_driver_zydas_set_drop_unencrypted(const char *ifname, int enabled) |
340 | +{ |
341 | + /* Enable the countermeasure */ |
342 | + wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled); |
343 | + return zydas_set_param(ifname, ZD_PARAM_DROPUNENCRYPTED, enabled, 1); |
344 | +} |
345 | + |
346 | +static int |
347 | +wpa_driver_zydas_deauthenticate(const char *ifname, u8 *addr, int reason_code) |
348 | +{ |
349 | + struct zydas_wlan_param *param; |
350 | + int blen; |
351 | + int ret; |
352 | + |
353 | + blen = sizeof(*param); |
354 | + param = (struct zydas_wlan_param *) malloc(blen); |
355 | + if (param == NULL) |
356 | + return -1; |
357 | + |
358 | + memset(param, 0, blen); |
359 | + param->cmd = ZD_CMD_SET_MLME; |
360 | + param->u.mlme.cmd = MLME_STA_DEAUTH; |
361 | + param->u.mlme.reason_code = reason_code; |
362 | + memcpy(param->sta_addr, addr, ETH_ALEN); |
363 | + ret = zydas_ioctl(ifname, param, blen, 1); |
364 | + usleep(100000); |
365 | + free(param); |
366 | + return ret; |
367 | +} |
368 | + |
369 | +static int |
370 | +wpa_driver_zydas_disassociate(const char *ifname, u8 *addr, int reason_code) |
371 | +{ |
372 | + struct zydas_wlan_param *param; |
373 | + int blen; |
374 | + int ret; |
375 | + |
376 | + blen = sizeof(*param); |
377 | + param = (struct zydas_wlan_param *) malloc(blen); |
378 | + if (param == NULL) |
379 | + return -1; |
380 | + |
381 | + memset(param, 0, blen); |
382 | + param->cmd = ZD_CMD_SET_MLME; |
383 | + param->u.mlme.cmd = MLME_STA_DISASSOC; |
384 | + param->u.mlme.reason_code = reason_code; |
385 | + memcpy(param->sta_addr, addr, ETH_ALEN); |
386 | + ret = zydas_ioctl(ifname, param, blen, 1); |
387 | + free(param); |
388 | + return ret; |
389 | +} |
390 | + |
391 | +static int |
392 | +wpa_driver_zydas_associate(const char *ifname, const char *bssid, |
393 | + const char *ssid, size_t ssid_len, |
394 | + int freq, |
395 | + const char *wpa_ie, size_t wpa_ie_len, |
396 | + wpa_cipher pairwise_suite, |
397 | + wpa_cipher group_suite, |
398 | + wpa_key_mgmt key_mgmt_suite) |
399 | +{ |
400 | + int ret = 0; |
401 | + |
402 | + wpa_printf(MSG_DEBUG, "%s", __FUNCTION__); |
403 | + |
404 | + /* Because there might be the case, two or more APs with the same |
405 | + * SSID, in order to identify them, we need to set the BSSID. */ |
406 | + if (wpa_driver_zydas_set_wpa_ie(ifname, wpa_ie, wpa_ie_len) < 0) |
407 | + ret = -1; |
408 | + if (wpa_driver_wext_set_ssid(ifname, ssid, ssid_len) < 0) |
409 | + ret = -1; |
410 | + |
411 | + // Mark for test |
412 | + //if (wpa_driver_wext_set_bssid(ifname, bssid) < 0) |
413 | + // ret = -1; |
414 | + |
415 | +#if 0 |
416 | + /* Allow unencrypted EAPOL messages even if pairwise keys are set when |
417 | + * not using WPA. IEEE 802.1X specifies that these frames are not |
418 | + * encrypted, but WPA encrypts them when pairwise keys are in use. */ |
419 | + if (key_mgmt_suite == KEY_MGMT_802_1X || |
420 | + key_mgmt_suite == KEY_MGMT_PSK) |
421 | + allow_unencrypted_eapol = 0; |
422 | + else |
423 | + allow_unencrypted_eapol = 1; |
424 | + |
425 | + if (prism2param(ifname, PRISM2_PARAM_IEEE_802_1X, |
426 | + allow_unencrypted_eapol) < 0) { |
427 | + wpa_printf(MSG_DEBUG, "hostap: Failed to configure " |
428 | + "ieee_802_1x param"); |
429 | + /* Ignore this error.. driver_hostap.c can also be used with |
430 | + * other drivers that do not support this prism2_param. */ |
431 | + } |
432 | +#endif |
433 | + |
434 | + return ret; |
435 | +} |
436 | + |
437 | +static int |
438 | +wpa_driver_zydas_scan(const char *ifname, |
439 | + void *ctx, u8 *ssid, size_t ssid_len) |
440 | +{ |
441 | + struct zydas_wlan_param param; |
442 | + int ret; |
443 | + |
444 | + if (ssid == NULL) { |
445 | + /* Use standard Linux Wireless Extensions ioctl if possible |
446 | + * because some drivers using hostap code in wpa_supplicant |
447 | + * might not support Host AP specific scan request (with SSID |
448 | + * info). */ |
449 | + return wpa_driver_wext_scan(ifname, ctx, ssid, ssid_len); |
450 | + } |
451 | + |
452 | + if (ssid_len > 32) |
453 | + ssid_len = 32; |
454 | + |
455 | + memset(¶m, 0, sizeof(param)); |
456 | + param.cmd = ZD_CMD_SCAN_REQ; |
457 | + param.u.scan_req.ssid_len = ssid_len; |
458 | + memcpy(param.u.scan_req.ssid, ssid, ssid_len); |
459 | + ret = zydas_ioctl(ifname, ¶m, sizeof(param), 1); |
460 | + |
461 | + /* Not all drivers generate "scan completed" wireless event, so try to |
462 | + * read results after a timeout. */ |
463 | + eloop_register_timeout(3, 0, wpa_driver_wext_scan_timeout, NULL, ctx); |
464 | + |
465 | + return ret; |
466 | +} |
467 | + |
468 | +static int wpa_driver_zydas_set_auth_alg(const char *ifname, int auth_alg) |
469 | +{ |
470 | + int algs = 0; |
471 | + |
472 | + if (auth_alg & AUTH_ALG_OPEN_SYSTEM) |
473 | + algs = 0; |
474 | + if (auth_alg & AUTH_ALG_SHARED_KEY) |
475 | + algs = 1; |
476 | + |
477 | + return zydas_set_param(ifname, ZD_PARAM_AUTH_ALGS, algs, 1); |
478 | +} |
479 | + |
480 | +static void |
481 | +wpa_driver_zydas_cleanup(const char *ifname) |
482 | +{ |
483 | + int flags; |
484 | + |
485 | + /* NB: mark interface down */ |
486 | + if (getifflags(ifname, &flags) == 0) |
487 | + (void) setifflags(ifname, flags &~ IFF_UP); |
488 | +} |
489 | + |
490 | +struct wpa_driver_ops wpa_driver_zydas_ops = { |
491 | + .get_bssid = wpa_driver_wext_get_bssid, |
492 | + .get_ssid = wpa_driver_wext_get_ssid, |
493 | + .set_wpa = wpa_driver_zydas_set_wpa, |
494 | + .set_key = wpa_driver_zydas_set_key, |
495 | + .events_init = wpa_driver_wext_events_init, |
496 | + .events_deinit = wpa_driver_wext_events_deinit, |
497 | + .set_countermeasures = wpa_driver_zydas_set_countermeasures, |
498 | + .set_drop_unencrypted = wpa_driver_zydas_set_drop_unencrypted, |
499 | + .scan = wpa_driver_zydas_scan, |
500 | + .get_scan_results = wpa_driver_wext_get_scan_results, |
501 | + .deauthenticate = wpa_driver_zydas_deauthenticate, |
502 | + .disassociate = wpa_driver_zydas_disassociate, |
503 | + .associate = wpa_driver_zydas_associate, |
504 | + .set_auth_alg = wpa_driver_zydas_set_auth_alg, |
505 | + .cleanup = wpa_driver_zydas_cleanup, |
506 | +}; |
507 | + |
508 | diff -wBNur wpa_supplicant-0.2.4/zydas_common.h lnx_wpa_supplicant_1_2_0_0/zydas_common.h |
509 | --- wpa_supplicant-0.2.4/zydas_common.h 1970-01-01 01:00:00.000000000 +0100 |
510 | +++ lnx_wpa_supplicant_1_2_0_0/zydas_common.h 2005-08-01 11:14:37.000000000 +0200 |
511 | @@ -0,0 +1,65 @@ |
512 | +#ifndef ZYDAS_COMMON_H |
513 | +#define ZYDAS_COMMON_H |
514 | + |
515 | +#define ZD_IOCTL_WPA (SIOCDEVPRIVATE + 1) |
516 | +#define ZD_IOCTL_PARAM (SIOCDEVPRIVATE + 2) |
517 | + |
518 | +#define ZD_PARAM_ROAMING 0x0001 |
519 | +#define ZD_PARAM_PRIVACY 0x0002 |
520 | +#define ZD_PARAM_WPA 0x0003 |
521 | +#define ZD_PARAM_COUNTERMEASURES 0x0004 |
522 | +#define ZD_PARAM_DROPUNENCRYPTED 0x0005 |
523 | +#define ZD_PARAM_AUTH_ALGS 0x0006 |
524 | + |
525 | +#define ZD_CMD_SET_ENCRYPT_KEY 0x0001 |
526 | +#define ZD_CMD_SET_MLME 0x0002 |
527 | +#define ZD_CMD_SCAN_REQ 0x0003 |
528 | +#define ZD_CMD_SET_GENERIC_ELEMENT 0x0004 |
529 | + |
530 | +#define ZD_FLAG_SET_TX_KEY 0x0001 |
531 | + |
532 | +#define ZD_GENERIC_ELEMENT_HDR_LEN \ |
533 | +((int) (&((struct zydas_wlan_param *) 0)->u.generic_elem.data)) |
534 | + |
535 | +#define ZD_CRYPT_ALG_NAME_LEN 16 |
536 | +#define ZD_MAX_KEY_SIZE 32 |
537 | +#define ZD_MAX_GENERIC_SIZE 64 |
538 | + |
539 | +/* structure definition */ |
540 | + |
541 | +struct zydas_wlan_param { |
542 | + u32 cmd; |
543 | + u8 sta_addr[ETH_ALEN]; |
544 | + union { |
545 | + struct { |
546 | + u8 alg[ZD_CRYPT_ALG_NAME_LEN]; |
547 | + u32 flags; |
548 | + u32 err; |
549 | + u8 idx; |
550 | + u8 seq[8]; /* sequence counter (set: RX, get: TX) */ |
551 | + u16 key_len; |
552 | + u8 key[ZD_MAX_KEY_SIZE]; |
553 | + } crypt; |
554 | + struct { |
555 | + u32 flags_and; |
556 | + u32 flags_or; |
557 | + } set_flags_sta; |
558 | + struct { |
559 | + u8 len; |
560 | + u8 data[ZD_MAX_GENERIC_SIZE]; |
561 | + } generic_elem; |
562 | + struct { |
563 | +#define MLME_STA_DEAUTH 0 |
564 | +#define MLME_STA_DISASSOC 1 |
565 | + u16 cmd; |
566 | + u16 reason_code; |
567 | + } mlme; |
568 | + struct { |
569 | + u8 ssid_len; |
570 | + u8 ssid[32]; |
571 | + } scan_req; |
572 | + } u; |
573 | +}; |
574 | + |
575 | +#endif |
576 | + |