Magellan Linux

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

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

    Parent Directory Parent Directory | Revision Log Revision Log

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