Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/wpa_supplicant/wpa-supplicant-0.4.7-zd1211.patch

    Annotation of /trunk/wpa_supplicant/wpa-supplicant-0.4.7-zd1211.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 76 - (hide annotations) (download)
    Tue Jun 27 16:57:08 2006 UTC (17 years, 11 months ago) by niro
    File size: 14900 byte(s) 
    new patch for wpa-supplicant >= 0.4.7
    1 niro 76 diff -Nur wpa_supplicant-0.4.7/defconfig wpa_supplicant-0.4.7.new/defconfig
    2     --- wpa_supplicant-0.4.7/defconfig 2005-09-24 20:30:43.000000000 +0200
    3     +++ wpa_supplicant-0.4.7.new/defconfig 2005-12-26 19:18:14.000000000 +0100
    4     @@ -68,6 +68,9 @@
    5     # Driver interface for Intel ipw2100/2200 driver
    6     #CONFIG_DRIVER_IPW=y
    7    
    8     +# Driver interface for Zydas zd1211 driver
    9     +#CONFIG_DRIVER_ZD1211=y
    10     +
    11     # Driver interface for generic Linux wireless extensions
    12     CONFIG_DRIVER_WEXT=y
    13    
    14     diff -Nur wpa_supplicant-0.4.7/drivers.c wpa_supplicant-0.4.7.new/drivers.c
    15     --- wpa_supplicant-0.4.7/drivers.c 2005-02-20 01:15:54.000000000 +0100
    16     +++ wpa_supplicant-0.4.7.new/drivers.c 2005-12-26 19:19:16.000000000 +0100
    17     @@ -55,6 +55,9 @@
    18     #ifdef CONFIG_DRIVER_TEST
    19     extern struct wpa_driver_ops wpa_driver_test_ops; /* driver_test.c */
    20     #endif /* CONFIG_DRIVER_TEST */
    21     +#ifdef CONFIG_DRIVER_ZD1211
    22     +extern struct wpa_driver_ops wpa_driver_zd1211_ops; /* driver_zd1211.c */
    23     +#endif /* CONFIG_DRIVER_ZD1211 */
    24    
    25    
    26     struct wpa_driver_ops *wpa_supplicant_drivers[] =
    27     @@ -98,5 +101,8 @@
    28     #ifdef CONFIG_DRIVER_TEST
    29     &wpa_driver_test_ops,
    30     #endif /* CONFIG_DRIVER_TEST */
    31     +#ifdef CONFIG_DRIVER_ZD1211
    32     + &wpa_driver_zd1211_ops,
    33     +#endif /* CONFIG_DRIVER_ZD1211 */
    34     NULL
    35     };
    36     diff -Nur wpa_supplicant-0.4.7/driver_zd1211.c wpa_supplicant-0.4.7.new/driver_zd1211.c
    37     --- wpa_supplicant-0.4.7/driver_zd1211.c 1970-01-01 01:00:00.000000000 +0100
    38     +++ wpa_supplicant-0.4.7.new/driver_zd1211.c 2005-12-27 16:28:46.000000000 +0100
    39     @@ -0,0 +1,408 @@
    40     +#include <stdlib.h>
    41     +#include <stdio.h>
    42     +#include <unistd.h>
    43     +#include <string.h>
    44     +#include <sys/ioctl.h>
    45     +#include <errno.h>
    46     +
    47     +#include "common.h"
    48     +#include "driver.h"
    49     +#include "driver_wext.h"
    50     +#include "eloop.h"
    51     +#include "wireless_copy.h"
    52     +#include "wpa_supplicant.h"
    53     +
    54     +#include "zd1211_common.h"
    55     +
    56     +
    57     +struct wpa_driver_zd1211_data {
    58     + void *ctx;
    59     + void *wext; /* private data for driver_wext */
    60     + char ifname[IFNAMSIZ + 1];
    61     + int sock;
    62     +};
    63     +
    64     +
    65     +static int zd1211_ioctl(struct wpa_driver_zd1211_data *zd1211_drv, struct zd1211_wlan_param *param, int len, int show_err) {
    66     + struct iwreq iwr;
    67     +
    68     + memset(&iwr, 0, sizeof(iwr));
    69     + strncpy(iwr.ifr_name, zd1211_drv->ifname, IFNAMSIZ);
    70     + iwr.u.data.pointer = (caddr_t) param;
    71     + iwr.u.data.length = len;
    72     +
    73     + if (ioctl(zd1211_drv->sock, ZD_IOCTL_WPA, &iwr) < 0) {
    74     + int ret;
    75     +
    76     + ret = errno;
    77     + if (show_err)
    78     + perror("ioctl[ZD_IOCTL_WPA]");
    79     + return ret;
    80     + }
    81     +
    82     + return 0;
    83     +}
    84     +
    85     +
    86     +static int zd1211_set_param(struct wpa_driver_zd1211_data *zd1211_drv, int op, int arg, int show_err) {
    87     + struct iwreq iwr;
    88     + int *i, ret = 0;
    89     +
    90     + memset(&iwr, 0, sizeof(iwr));
    91     + strncpy(iwr.ifr_name, zd1211_drv->ifname, IFNAMSIZ);
    92     + i = (int *) iwr.u.name;
    93     + *i++ = op;
    94     + *i++ = arg;
    95     +
    96     + if (ioctl(zd1211_drv->sock, ZD_IOCTL_PARAM, &iwr) < 0) {
    97     + perror("ioctl[ZD_IOCTL_PARAM]");
    98     + ret = -1;
    99     + }
    100     +
    101     + return ret;
    102     +}
    103     +
    104     +
    105     +static int wpa_driver_zd1211_get_scan_results(void *priv, struct wpa_scan_result *results, size_t max_size) {
    106     + struct wpa_driver_zd1211_data *zd1211_drv;
    107     +
    108     + zd1211_drv = priv;
    109     + return wpa_driver_wext_get_scan_results(zd1211_drv->wext, results, max_size);
    110     +}
    111     +
    112     +
    113     +static int wpa_driver_zd1211_get_bssid(void *priv, u8 *bssid) {
    114     + struct wpa_driver_zd1211_data *zd1211_drv;
    115     +
    116     + zd1211_drv = priv;
    117     + return wpa_driver_wext_get_bssid(zd1211_drv->wext, bssid);
    118     +}
    119     +
    120     +
    121     +static int wpa_driver_zd1211_get_ssid(void *priv, u8 *ssid) {
    122     + struct wpa_driver_zd1211_data *zd1211_drv;
    123     +
    124     + zd1211_drv = priv;
    125     + return wpa_driver_wext_get_ssid(zd1211_drv->wext, ssid);
    126     +}
    127     +
    128     +
    129     +static int wpa_driver_zd1211_set_auth_alg(void *priv, int auth_alg) {
    130     + struct wpa_driver_zd1211_data *zd1211_drv = priv;
    131     + int algs = 0;
    132     +
    133     + if (auth_alg & AUTH_ALG_OPEN_SYSTEM)
    134     + algs = 0;
    135     + if (auth_alg & AUTH_ALG_SHARED_KEY)
    136     + algs = 1;
    137     +
    138     + return zd1211_set_param(zd1211_drv, ZD_PARAM_AUTH_ALGS, algs, 1);
    139     +}
    140     +
    141     +
    142     +static int wpa_driver_zd1211_set_countermeasures(void *priv, int enabled) {
    143     + struct wpa_driver_zd1211_data *zd1211_drv = priv;
    144     +
    145     + /* Enable the countermeasure */
    146     + wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
    147     + return zd1211_set_param(zd1211_drv, ZD_PARAM_COUNTERMEASURES, enabled, 1);
    148     +}
    149     +
    150     +
    151     +static int wpa_driver_zd1211_set_drop_unencrypted(void *priv, int enabled) {
    152     + struct wpa_driver_zd1211_data *zd1211_drv = priv;
    153     +
    154     + /* Enable the countermeasure */
    155     + wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
    156     + return zd1211_set_param(zd1211_drv, ZD_PARAM_DROPUNENCRYPTED, enabled, 1);
    157     +}
    158     +
    159     +
    160     +static int wpa_driver_zd1211_set_key(void *priv, wpa_alg alg,
    161     + const u8 *addr, int key_idx,
    162     + int set_tx, const u8 *seq, size_t seq_len,
    163     + const u8 *key, size_t key_len) {
    164     + struct wpa_driver_zd1211_data *zd1211_drv = priv;
    165     + struct zd1211_wlan_param *param;
    166     + u8 *buf;
    167     + size_t blen;
    168     + int ret = 0;
    169     + char *alg_name;
    170     +
    171     + switch (alg) {
    172     + case WPA_ALG_NONE:
    173     + alg_name = "NONE";
    174     + break;
    175     + case WPA_ALG_WEP:
    176     + alg_name = "WEP";
    177     + break;
    178     + case WPA_ALG_TKIP:
    179     + alg_name = "TKIP";
    180     + break;
    181     + case WPA_ALG_CCMP:
    182     + alg_name = "CCMP";
    183     + break;
    184     + default:
    185     + return -1;
    186     + }
    187     +
    188     + wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%d "
    189     + "key_len=%d", __FUNCTION__, alg_name, key_idx, set_tx,
    190     + seq_len, key_len);
    191     +
    192     + if (seq_len > 8)
    193     + return -2;
    194     +
    195     + blen = sizeof(*param) + key_len;
    196     + buf = malloc(blen);
    197     + if (buf == NULL)
    198     + return -1;
    199     + memset(buf, 0, blen);
    200     +
    201     + param = (struct zd1211_wlan_param *) buf;
    202     + param->cmd = ZD_CMD_SET_ENCRYPT_KEY;
    203     + /* TODO: In theory, STA in client mode can use five keys; four default
    204     + * keys for receiving (with keyidx 0..3) and one individual key for
    205     + * both transmitting and receiving (keyidx 0) _unicast_ packets. Now,
    206     + * keyidx 0 is reserved for this unicast use and default keys can only
    207     + * use keyidx 1..3 (i.e., default key with keyidx 0 is not supported).
    208     + * This should be fine for more or less all cases, but for completeness
    209     + * sake, the driver could be enhanced to support the missing key. */
    210     +#if 0
    211     + if (addr == NULL)
    212     + memset(param->sta_addr, 0xff, ETH_ALEN);
    213     + else
    214     + memcpy(param->sta_addr, addr, ETH_ALEN);
    215     +#else
    216     + memset(param->sta_addr, 0xff, ETH_ALEN);
    217     +#endif
    218     + strncpy(param->u.crypt.alg, alg_name, ZD_CRYPT_ALG_NAME_LEN);
    219     + param->u.crypt.flags = set_tx ? ZD_FLAG_SET_TX_KEY : 0;
    220     + param->u.crypt.idx = key_idx;
    221     + memcpy(param->u.crypt.seq, seq, seq_len);
    222     + param->u.crypt.key_len = key_len;
    223     + memcpy((u8 *) param->u.crypt.key, key, key_len);
    224     +
    225     + /* Dump key context */
    226     + if(alg == WPA_ALG_TKIP) {
    227     + int ii;
    228     +
    229     + wpa_printf(MSG_DEBUG, "Key Context:");
    230     + for(ii = 0; ii < key_len; ) {
    231     + printf("0x%02x ", key[ii]);
    232     +
    233     + if((++ii % 16) == 0)
    234     + printf("\n");
    235     + }
    236     +
    237     + printf("\n");
    238     + }
    239     +
    240     + if (zd1211_ioctl(zd1211_drv, param, blen, 1)) {
    241     + wpa_printf(MSG_WARNING, "Failed to set encryption.");
    242     + //show_set_key_error(param);
    243     + ret = -1;
    244     + }
    245     + free(buf);
    246     +
    247     + return ret;
    248     +}
    249     +
    250     +
    251     +static int wpa_driver_zd1211_set_wpa_ie(struct wpa_driver_zd1211_data *zd1211_drv, const u8 *wpa_ie, size_t wpa_ie_len) {
    252     + int res;
    253     + struct zd1211_wlan_param *param;
    254     + size_t blen = ZD_GENERIC_ELEMENT_HDR_LEN + wpa_ie_len;
    255     +
    256     + if (blen < sizeof(*param))
    257     + blen = sizeof(*param);
    258     +
    259     + param = (struct zd1211_wlan_param *) malloc(blen);
    260     + if (param == NULL)
    261     + return -1;
    262     +
    263     + memset(param, 0, blen);
    264     + param->cmd = ZD_CMD_SET_GENERIC_ELEMENT;
    265     + param->u.generic_elem.len = wpa_ie_len;
    266     + memcpy(param->u.generic_elem.data, wpa_ie, wpa_ie_len);
    267     + res = zd1211_ioctl(zd1211_drv, param, blen, 1);
    268     +
    269     + free(param);
    270     +
    271     + return res;
    272     +}
    273     +
    274     +
    275     +static int wpa_driver_zd1211_set_wpa(void *priv, int enabled) {
    276     + struct wpa_driver_zd1211_data *zd1211_drv = priv;
    277     + int ret = 0;
    278     +
    279     + wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
    280     +
    281     + if (!enabled && wpa_driver_zd1211_set_wpa_ie(zd1211_drv, NULL, 0) < 0)
    282     + ret = -1;
    283     + if (zd1211_set_param(zd1211_drv, ZD_PARAM_ROAMING, enabled, 1) < 0)
    284     + ret = -1;
    285     + if (zd1211_set_param(zd1211_drv, ZD_PARAM_PRIVACY, enabled, 1) < 0)
    286     + ret = -1;
    287     + if (zd1211_set_param(zd1211_drv, ZD_PARAM_WPA, enabled, 1) < 0)
    288     + ret = -1;
    289     +
    290     + return ret;
    291     +}
    292     +
    293     +
    294     +static int wpa_driver_zd1211_associate(void *priv, struct wpa_driver_associate_params *params) {
    295     + struct wpa_driver_zd1211_data *zd1211_drv = priv;
    296     + int ret = 0;
    297     +
    298     + wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
    299     +
    300     + /* Because there might be the case, two or more APs with the same
    301     + * SSID, in order to identify them, we need to set the BSSID. */
    302     + if (wpa_driver_zd1211_set_wpa_ie(zd1211_drv, params->wpa_ie, params->wpa_ie_len) < 0)
    303     + ret = -1;
    304     + if (wpa_driver_wext_set_ssid(zd1211_drv->wext, params->ssid, params->ssid_len) < 0)
    305     + ret = -1;
    306     +
    307     + // Mark for test
    308     + //if (wpa_driver_wext_set_bssid(ifname, bssid) < 0)
    309     + // ret = -1;
    310     +
    311     +#if 0
    312     + /* Allow unencrypted EAPOL messages even if pairwise keys are set when
    313     + * not using WPA. IEEE 802.1X specifies that these frames are not
    314     + * encrypted, but WPA encrypts them when pairwise keys are in use. */
    315     + if (key_mgmt_suite == KEY_MGMT_802_1X ||
    316     + key_mgmt_suite == KEY_MGMT_PSK)
    317     + allow_unencrypted_eapol = 0;
    318     + else
    319     + allow_unencrypted_eapol = 1;
    320     +
    321     + if (prism2param(ifname, PRISM2_PARAM_IEEE_802_1X,
    322     + allow_unencrypted_eapol) < 0) {
    323     + wpa_printf(MSG_DEBUG, "hostap: Failed to configure "
    324     + "ieee_802_1x param");
    325     + /* Ignore this error.. driver_hostap.c can also be used with
    326     + * other drivers that do not support this prism2_param. */
    327     + }
    328     +#endif
    329     +
    330     + return ret;
    331     +}
    332     +
    333     +
    334     +static int wpa_driver_zd1211_deauthenticate(void *priv, const u8 *addr, int reason_code) {
    335     + struct zd1211_wlan_param *param;
    336     + struct wpa_driver_zd1211_data *zd1211_drv = priv;
    337     + int blen;
    338     + int ret;
    339     +
    340     + wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
    341     +
    342     + blen = sizeof(*param);
    343     + param = (struct zd1211_wlan_param *) malloc(blen);
    344     + if (param == NULL)
    345     + return -1;
    346     +
    347     + memset(param, 0, blen);
    348     + param->cmd = ZD_CMD_SET_MLME;
    349     + param->u.mlme.cmd = MLME_STA_DEAUTH;
    350     + param->u.mlme.reason_code = reason_code;
    351     + memcpy(param->sta_addr, addr, ETH_ALEN);
    352     + ret = zd1211_ioctl(zd1211_drv, param, blen, 1);
    353     + usleep(100000);
    354     + free(param);
    355     + return ret;
    356     +}
    357     +
    358     +
    359     +static int wpa_driver_zd1211_disassociate(void *priv, const u8 *addr, int reason_code) {
    360     + struct zd1211_wlan_param *param;
    361     + struct wpa_driver_zd1211_data *zd1211_drv = priv;
    362     + int blen;
    363     + int ret;
    364     +
    365     + wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
    366     +
    367     + blen = sizeof(*param);
    368     + param = (struct zd1211_wlan_param *) malloc(blen);
    369     + if (param == NULL)
    370     + return -1;
    371     +
    372     + memset(param, 0, blen);
    373     + param->cmd = ZD_CMD_SET_MLME;
    374     + param->u.mlme.cmd = MLME_STA_DISASSOC;
    375     + param->u.mlme.reason_code = reason_code;
    376     + memcpy(param->sta_addr, addr, ETH_ALEN);
    377     + ret = zd1211_ioctl(zd1211_drv, param, blen, 1);
    378     + free(param);
    379     + return ret;
    380     +}
    381     +
    382     +
    383     +static int wpa_driver_zd1211_scan(void *priv, const u8 *ssid, size_t ssid_len) {
    384     + struct wpa_driver_zd1211_data *zd1211_drv;
    385     +
    386     + zd1211_drv = priv;
    387     + return wpa_driver_wext_scan(zd1211_drv->wext, ssid, ssid_len);
    388     +}
    389     +
    390     +
    391     +static void * wpa_driver_zd1211_init(void *ctx, const char *ifname) {
    392     + struct wpa_driver_zd1211_data *zd1211_drv;
    393     +
    394     + zd1211_drv = malloc(sizeof(*zd1211_drv));
    395     + if (zd1211_drv == NULL)
    396     + return NULL;
    397     + memset(zd1211_drv, 0, sizeof(*zd1211_drv));
    398     +
    399     + zd1211_drv->wext = wpa_driver_wext_init(ctx, ifname);
    400     + if (zd1211_drv->wext == NULL)
    401     + goto exit_no_wext;
    402     +
    403     + zd1211_drv->ctx = ctx;
    404     + strncpy(zd1211_drv->ifname, ifname, sizeof(zd1211_drv->ifname));
    405     +
    406     + zd1211_drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
    407     + if (zd1211_drv->sock < 0)
    408     + goto exit_no_socket;
    409     +
    410     + return zd1211_drv;
    411     +
    412     +exit_no_socket:
    413     + wpa_driver_wext_deinit(zd1211_drv->wext);
    414     +exit_no_wext:
    415     + free(zd1211_drv);
    416     + return NULL;
    417     +}
    418     +
    419     +
    420     +static void wpa_driver_zd1211_deinit(void *ctx) {
    421     + struct wpa_driver_zd1211_data *zd1211_drv = ctx;
    422     +
    423     + wpa_driver_wext_deinit(zd1211_drv->wext);
    424     + close(zd1211_drv->sock);
    425     + free(zd1211_drv);
    426     +}
    427     +
    428     +
    429     +struct wpa_driver_ops wpa_driver_zd1211_ops = {
    430     + .name = "zd1211",
    431     + .desc = "Zydas zd1211 drivers",
    432     + .init = wpa_driver_zd1211_init,
    433     + .deinit = wpa_driver_zd1211_deinit,
    434     + .associate = wpa_driver_zd1211_associate,
    435     + .deauthenticate = wpa_driver_zd1211_deauthenticate,
    436     + .disassociate = wpa_driver_zd1211_disassociate,
    437     + .get_bssid = wpa_driver_zd1211_get_bssid,
    438     + .get_scan_results = wpa_driver_zd1211_get_scan_results,
    439     + .get_ssid = wpa_driver_zd1211_get_ssid,
    440     +// .get_capa = wpa_driver_zd1211_get_capa,
    441     + .scan = wpa_driver_zd1211_scan,
    442     + .set_auth_alg = wpa_driver_zd1211_set_auth_alg,
    443     + .set_countermeasures = wpa_driver_zd1211_set_countermeasures,
    444     + .set_drop_unencrypted = wpa_driver_zd1211_set_drop_unencrypted,
    445     + .set_key = wpa_driver_zd1211_set_key,
    446     + .set_wpa = wpa_driver_zd1211_set_wpa,
    447     +};
    448     diff -Nur wpa_supplicant-0.4.7/Makefile wpa_supplicant-0.4.7.new/Makefile
    449     --- wpa_supplicant-0.4.7/Makefile 2005-11-21 02:42:12.000000000 +0100
    450     +++ wpa_supplicant-0.4.7.new/Makefile 2005-12-26 19:17:14.000000000 +0100
    451     @@ -107,6 +107,12 @@
    452     CONFIG_WIRELESS_EXTENSION=y
    453     endif
    454    
    455     +ifdef CONFIG_DRIVER_ZD1211
    456     +CFLAGS += -DCONFIG_DRIVER_ZD1211
    457     +OBJS_d += driver_zd1211.o
    458     +CONFIG_WIRELESS_EXTENSION=y
    459     +endif
    460     +
    461     ifdef CONFIG_DRIVER_BSD
    462     CFLAGS += -DCONFIG_DRIVER_BSD
    463     OBJS_d += driver_bsd.o
    464     diff -Nur wpa_supplicant-0.4.7/zd1211_common.h wpa_supplicant-0.4.7.new/zd1211_common.h
    465     --- wpa_supplicant-0.4.7/zd1211_common.h 1970-01-01 01:00:00.000000000 +0100
    466     +++ wpa_supplicant-0.4.7.new/zd1211_common.h 2005-12-27 16:00:36.000000000 +0100
    467     @@ -0,0 +1,68 @@
    468     +#ifndef ZD1211_COMMON_H
    469     +#define ZD1211_COMMON_H
    470     +
    471     +
    472     +#define ZD_IOCTL_WPA (SIOCDEVPRIVATE + 1)
    473     +#define ZD_IOCTL_PARAM (SIOCDEVPRIVATE + 2)
    474     +
    475     +#define ZD_PARAM_ROAMING 0x0001
    476     +#define ZD_PARAM_PRIVACY 0x0002
    477     +#define ZD_PARAM_WPA 0x0003
    478     +#define ZD_PARAM_COUNTERMEASURES 0x0004
    479     +#define ZD_PARAM_DROPUNENCRYPTED 0x0005
    480     +#define ZD_PARAM_AUTH_ALGS 0x0006
    481     +
    482     +#define ZD_CMD_SET_ENCRYPT_KEY 0x0001
    483     +#define ZD_CMD_SET_MLME 0x0002
    484     +//#define ZD_CMD_SCAN_REQ 0x0003
    485     +#define ZD_CMD_SET_GENERIC_ELEMENT 0x0004
    486     +
    487     +#define ZD_FLAG_SET_TX_KEY 0x0001
    488     +
    489     +#define ZD_GENERIC_ELEMENT_HDR_LEN \
    490     +((int) (&((struct zd1211_wlan_param *) 0)->u.generic_elem.data))
    491     +
    492     +#define ZD_CRYPT_ALG_NAME_LEN 16
    493     +#define ZD_MAX_KEY_SIZE 32
    494     +#define ZD_MAX_GENERIC_SIZE 64
    495     +
    496     +/* structure definition */
    497     +
    498     +struct zd1211_wlan_param {
    499     + u32 cmd;
    500     + u8 sta_addr[ETH_ALEN];
    501     + union {
    502     + struct {
    503     + u8 alg[ZD_CRYPT_ALG_NAME_LEN];
    504     + u32 flags;
    505     + u32 err;
    506     + u8 idx;
    507     + u8 seq[8]; /* sequence counter (set: RX, get: TX) */
    508     + u16 key_len;
    509     + u8 key[ZD_MAX_KEY_SIZE];
    510     + } crypt;
    511     +/*
    512     + struct {
    513     + u32 flags_and;
    514     + u32 flags_or;
    515     + } set_flags_sta;
    516     +*/
    517     + struct {
    518     + u8 len;
    519     + u8 data[ZD_MAX_GENERIC_SIZE];
    520     + } generic_elem;
    521     + struct {
    522     +#define MLME_STA_DEAUTH 0
    523     +#define MLME_STA_DISASSOC 1
    524     + u16 cmd;
    525     + u16 reason_code;
    526     + } mlme;
    527     + struct {
    528     + u8 ssid_len;
    529     + u8 ssid[32];
    530     + } scan_req;
    531     + } u;
    532     +};
    533     +
    534     +
    535     +#endif