Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/wpa_supplicant/wpa-supplicant-0.2.4-zydas-support.patch

    Contents of /trunk/wpa_supplicant/wpa-supplicant-0.2.4-zydas-support.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 40 - (show annotations) (download)
    Mon Oct 10 18:41:40 2005 UTC (18 years, 6 months ago) by niro
    File size: 15761 byte(s) 
    renamed to wpa-supplicant
    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(&param, 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, &param, 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 +