Author: arekm Date: Tue Dec 20 21:08:43 2005 GMT
Module: SOURCES Tag: HEAD
---- Log message:
- new from http://kernel.org/pub/linux/kernel/people/jbenc/; utils tarball
---- Files affected:
SOURCES:
wpa_supplicant-0.4.7_dscape-02.patch (NONE -> 1.1) (NEW)
---- Diffs:
================================================================
Index: SOURCES/wpa_supplicant-0.4.7_dscape-02.patch
diff -u /dev/null SOURCES/wpa_supplicant-0.4.7_dscape-02.patch:1.1
--- /dev/null Tue Dec 20 22:08:43 2005
+++ SOURCES/wpa_supplicant-0.4.7_dscape-02.patch Tue Dec 20 22:08:38 2005
@@ -0,0 +1,1486 @@
+From: Sven Henkel <[EMAIL PROTECTED]>
+
+(Comment by Jiri Benc <[EMAIL PROTECTED]>: This is a patch that adds a "dscape"
+driver to wpa_supplicant 0.4.7. It's purpose is to allow testing of WPA with
+Devicescape ieee80211 stack. There is a plan to update Wireless Extension
+support in the stack so the "wext" driver can be used and this patch won't
+be needed.)
+
+diff -upN wpa_supplicant-0.4.7/defconfig wpa_supplicant-0.4.7-dev/defconfig
+--- wpa_supplicant-0.4.7/defconfig 2005-09-24 20:30:43.000000000 +0200
++++ wpa_supplicant-0.4.7-dev/defconfig 2005-12-18 12:13:21.000000000 +0100
+@@ -38,6 +38,9 @@
+ # Driver interface for Host AP driver
+ CONFIG_DRIVER_HOSTAP=y
+
++# Driver interface for Devicescape stack
++CONFIG_DRIVER_DSCAPE=y
++
+ # Driver interface for Agere driver
+ #CONFIG_DRIVER_HERMES=y
+ # Change include directories to match with the local setup
+diff -upN wpa_supplicant-0.4.7/driver_dscape.c
wpa_supplicant-0.4.7-dev/driver_dscape.c
+--- wpa_supplicant-0.4.7/driver_dscape.c 1970-01-01 01:00:00.000000000
+0100
++++ wpa_supplicant-0.4.7-dev/driver_dscape.c 2005-12-18 12:48:32.000000000
+0100
+@@ -0,0 +1,466 @@
++/*
++ * WPA Supplicant - driver interaction with Devicescape stack
++ * Copyright (c) 2003-2005, Sven Henkel <[EMAIL PROTECTED]>
++ *
++ * This file includes code from the hostap-driver for WPA supplicant
++ * Copyright (c) 2003-2005, Jouni Malinen <[EMAIL PROTECTED]>
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ *
++ * Alternatively, this software may be distributed under the terms of BSD
++ * license.
++ *
++ * See README and COPYING for more details.
++ */
++
++
++#include <stdlib.h>
++#include <stdio.h>
++#include <unistd.h>
++#include <string.h>
++#include <sys/ioctl.h>
++#include <errno.h>
++
++#include "wireless_copy.h"
++#include "common.h"
++#include "driver.h"
++#include "eloop.h"
++#include "driver_dscape.h"
++#include "l2_packet.h"
++#include "wpa_supplicant.h"
++#include "driver_wext.h"
++
++
++struct wpa_driver_dscape_data {
++ void *wext; /* private data for driver_wext */
++ void *ctx;
++ char ifname[IFNAMSIZ + 1];
++ int sock;
++ int current_mode; /* infra/adhoc */
++};
++
++
++static int dscape_ioctl(struct wpa_driver_dscape_data *drv,
++ struct prism2_hostapd_param *param,
++ int len, int show_err)
++{
++ struct iwreq iwr;
++
++ memset(&iwr, 0, sizeof(iwr));
++ strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
++ iwr.u.data.pointer = (caddr_t) param;
++ iwr.u.data.length = len;
++
++ if (ioctl(drv->sock, PRISM2_IOCTL_HOSTAPD, &iwr) < 0) {
++ int ret = errno;
++ if (show_err)
++ perror("ioctl[PRISM2_IOCTL_HOSTAPD]");
++ return ret;
++ }
++
++ return 0;
++}
++
++static int prism2param(struct wpa_driver_dscape_data *drv, int param,
++ int value)
++{
++ struct iwreq iwr;
++ int *i, ret = 0;
++
++ memset(&iwr, 0, sizeof(iwr));
++ strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
++ i = (int *) iwr.u.name;
++ *i++ = param;
++ *i++ = value;
++
++ if (ioctl(drv->sock, PRISM2_IOCTL_PRISM2_PARAM, &iwr) < 0) {
++ fprintf(stderr, "ioctl[PRISM2_IOCTL_PRISM2_PARAM] param = %d
value = %d\n", param, value);
++ ret = -1;
++ }
++ return ret;
++}
++
++static int wpa_driver_dscape_set_wpa_ie(struct wpa_driver_dscape_data *drv,
const u8 *wpa_ie, size_t wpa_ie_len)
++{
++ struct prism2_hostapd_param *param;
++ int res;
++ size_t blen = PRISM2_DSCAPE_GENERIC_ELEMENT_HDR_LEN + wpa_ie_len;
++
++ if (blen < sizeof(*param))
++ blen = sizeof(*param);
++
++ param = (struct prism2_hostapd_param *) malloc(blen);
++ if (param == NULL)
++ return -1;
++
++ memset(param, 0, blen);
++ param->cmd = PRISM2_HOSTAPD_SET_GENERIC_INFO_ELEM;
++ param->u.set_generic_info_elem.len = wpa_ie_len;
++ memcpy(param->u.set_generic_info_elem.data, wpa_ie, wpa_ie_len);
++ res = dscape_ioctl(drv, param, blen, 1);
++
++ free(param);
++
++ return res;
++}
++
++static int wpa_driver_dscape_set_wpa(void *priv, int enabled)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ int ret = 0;
++
++ wpa_printf(MSG_DEBUG, "%s: enabled=%d", __FUNCTION__, enabled);
++
++ if (!enabled && wpa_driver_dscape_set_wpa_ie(drv, NULL, 0) < 0)
++ ret = -1;
++
++ //if (prism2param(drv, PRISM2_PARAM_HOST_ROAMING, enabled ? 2 : 0) < 0)
++ //ret = -1;
++ //if (prism2param(drv, PRISM2_PARAM_WPA, enabled) < 0)
++ //ret = -1;
++
++ return ret;
++}
++
++
++
++static int wpa_driver_dscape_set_key(void *priv, wpa_alg alg, const u8 *addr,
int key_idx,
++ int set_tx, const u8 *seq, size_t
seq_len,
++ const u8 *key, size_t key_len)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ struct prism2_hostapd_param *param;
++
++ u8 *buf;
++ size_t blen;
++ int ret = 0;
++ char *alg_name;
++ //int i;
++
++ switch (alg) {
++ case WPA_ALG_NONE:
++ alg_name = "none";
++ break;
++ case WPA_ALG_WEP:
++ alg_name = "WEP";
++ break;
++ case WPA_ALG_TKIP:
++ alg_name = "TKIP";
++ break;
++ case WPA_ALG_CCMP:
++ alg_name = "CCMP";
++ break;
++ default:
++ return -1;
++ }
++
++ wpa_printf(MSG_DEBUG, "%s: alg=%s key_idx=%d set_tx=%d seq_len=%lu "
++ "key_len=%lu", __FUNCTION__, alg_name, key_idx, set_tx,
++ (unsigned long) seq_len, (unsigned long) key_len);
++
++// printf("key = ");
++// for (i = 0; i < key_len; i++) {
++// printf("%.2x ", key[i]);
++// }
++// printf("\n");
++
++ if (seq_len > 8)
++ return -2;
++
++ blen = sizeof(*param) + key_len;
++ buf = malloc(blen);
++ if (buf == NULL)
++ return -1;
++ memset(buf, 0, blen);
++
++ param = (struct prism2_hostapd_param *) buf;
++ param->cmd = PRISM2_SET_ENCRYPTION;
++ /* TODO: In theory, STA in client mode can use five keys; four default
++ * keys for receiving (with keyidx 0..3) and one individual key for
++ * both transmitting and receiving (keyidx 0) _unicast_ packets. Now,
++ * keyidx 0 is reserved for this unicast use and default keys can only
++ * use keyidx 1..3 (i.e., default key with keyidx 0 is not supported).
++ * This should be fine for more or less all cases, but for completeness
++ * sake, the driver could be enhanced to support the missing key. */
++#if 0
++ if (addr == NULL)
++ memset(param->sta_addr, 0xff, ETH_ALEN);
++ else
++ memcpy(param->sta_addr, addr, ETH_ALEN);
++#else
++ memset(param->sta_addr, 0xff, ETH_ALEN);
++#endif
++ strncpy((char *) param->u.crypt.alg, alg_name,
++ HOSTAP_CRYPT_ALG_NAME_LEN);
++ param->u.crypt.flags = set_tx ? HOSTAP_CRYPT_FLAG_SET_TX_KEY : 0;
++ param->u.crypt.idx = key_idx;
++ //memcpy(param->u.crypt.seq, seq, seq_len);
++ param->u.crypt.key_len = key_len;
++ memcpy(param->u.crypt.key, key, key_len);
++
++ if (dscape_ioctl(drv, param, blen, 1)) {
++ wpa_printf(MSG_WARNING, "Failed to set encryption.");
++ //show_set_key_error(param);
++ ret = -1;
++ }
++ free(buf);
++
++ return ret;
++}
++
++static int wpa_driver_dscape_set_countermeasures(void *priv, int enabled)
++{
++ //FIXME: we should tell the driver to drop all tkip packets iff enabled
++ fprintf(stderr, "FIXME wpa_driver_dscape_set_countermeasures
entered\n");
++ return 0;
++}
++
++static int wpa_driver_dscape_set_drop_unencrypted(void *priv, int enabled)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ int ret = prism2param(drv, PRISM2_PARAM_DROP_UNENCRYPTED, enabled);
++ if (ret < 0)
++ return ret;
++
++ // allow eapol packets
++ ret = prism2param(drv, PRISM2_PARAM_EAPOL, enabled);
++ if (ret < 0)
++ return ret;
++
++ return 0;
++}
++
++static int wpa_driver_dscape_mlme(struct wpa_driver_dscape_data *drv, const
u8 *addr, int cmd, int reason_code)
++{
++ struct prism2_hostapd_param param;
++ int ret;
++
++ /* There does not seem to be a better way of deauthenticating or
++ * disassociating with Prism2/2.5/3 than sending the management frame
++ * and then resetting the Port0 to make sure both the AP and the STA
++ * end up in disconnected state. */
++ memset(¶m, 0, sizeof(param));
++ param.cmd = PRISM2_HOSTAPD_MLME;
++ memcpy(param.sta_addr, addr, ETH_ALEN);
++ param.u.mlme.cmd = cmd;
++ param.u.mlme.reason_code = reason_code;
++ ret = dscape_ioctl(drv, ¶m, sizeof(param), 1);
++
++// if (ret == 0) {
++// usleep(100000);
++// ret = wpa_driver_hostap_reset(drv, 2);
++// }
++ return ret;
++}
++
++static int wpa_driver_hostap_associate(void *priv, struct
wpa_driver_associate_params *params)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ int ret = 0;
++ int ieee8021x = 0;
++ int key_mgmt = IEEE80211_KEY_MGMT_NONE;
++
++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
++
++// if (params->mode != drv->current_mode) {
++// /* At the moment, Host AP driver requires host_roaming=2 for
++// * infrastructure mode and host_roaming=0 for adhoc. */
++// if (prism2param(drv, PRISM2_PARAM_HOST_ROAMING,
++// params->mode == IEEE80211_MODE_IBSS ? 0 : 2) <
++// 0) {
++// wpa_printf(MSG_DEBUG, "%s: failed to set host_roaming",
++// __func__);
++// }
++// drv->current_mode = params->mode;
++// }
++
++ if (prism2param(drv, PRISM2_PARAM_PRIVACY_INVOKED,
++ params->key_mgmt_suite != KEY_MGMT_NONE) < 0)
++ ret = -1;
++ if (wpa_driver_dscape_set_wpa_ie(drv, params->wpa_ie,
++ params->wpa_ie_len) < 0)
++ ret = -1;
++
++ switch(params->key_mgmt_suite) {
++ case KEY_MGMT_802_1X:
++ ieee8021x = 1;
++ key_mgmt = IEEE80211_KEY_MGMT_IEEE8021X;
++ break;
++ case KEY_MGMT_PSK:
++ key_mgmt = IEEE80211_KEY_MGMT_WPA_PSK;
++ break;
++ case KEY_MGMT_NONE:
++ key_mgmt = IEEE80211_KEY_MGMT_NONE;
++ break;
++ case KEY_MGMT_802_1X_NO_WPA:
++ case KEY_MGMT_WPA_NONE:
++ key_mgmt = IEEE80211_KEY_MGMT_NONE; //FIXME Do those
modes have a corresponding mode in dscape?
++ break;
++ }
++
++ if (prism2param(drv, PRISM2_PARAM_IEEE_802_1X, ieee8021x) < 0) {
++ wpa_printf(MSG_DEBUG, "hostap: Failed to configure "
++ "ieee_802_1x param");
++ ret = -1;
++ }
++
++ if (prism2param(drv, PRISM2_PARAM_KEY_MGMT, key_mgmt) < 0) {
++ wpa_printf(MSG_DEBUG, "hostap: Failed to configure "
++ "key-management param");
++ ret = -1;
++ }
++
++ if (wpa_driver_wext_set_mode(drv->wext, params->mode) < 0)
++ ret = -1;
++ if (params->freq &&
++ wpa_driver_wext_set_freq(drv->wext, params->freq) < 0)
++ ret = -1;
++ if (wpa_driver_wext_set_ssid(drv->wext, params->ssid, params->ssid_len)
++ < 0)
++ ret = -1;
++ if (wpa_driver_wext_set_bssid(drv->wext, params->bssid) < 0)
++ ret = -1;
++
++ return ret;
++}
++
++
++static int wpa_driver_dscape_deauthenticate(void *priv, const u8 *addr, int
reason_code)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
++ return wpa_driver_dscape_mlme(drv, addr, MLME_STA_DEAUTH,
reason_code);
++}
++
++static int wpa_driver_dscape_disassociate(void *priv, const u8 *addr, int
reason_code)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ wpa_printf(MSG_DEBUG, "%s", __FUNCTION__);
++ return wpa_driver_dscape_mlme(drv, addr, MLME_STA_DISASSOC,
reason_code);
++}
++
++static int wpa_driver_dscape_scan(void *priv, const u8 *ssid, size_t ssid_len)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ struct prism2_hostapd_param param;
++ int ret;
++
++ fprintf(stderr, "wpa_driver_dscape_scan entered\n");
++
++ if (ssid == NULL) {
++ /* Use standard Linux Wireless Extensions ioctl if possible
++ * because some drivers using hostap code in wpa_supplicant
++ * might not support Host AP specific scan request (with SSID
++ * info). */
++ return wpa_driver_wext_scan(drv->wext, ssid, ssid_len);
++ }
++
++ if (ssid_len > 32)
++ ssid_len = 32;
++
++ memset(¶m, 0, sizeof(param));
++ param.cmd = PRISM2_HOSTAPD_SCAN_REQ;
++ param.u.scan_req.ssid_len = ssid_len;
++ memcpy(param.u.scan_req.ssid, ssid, ssid_len);
++ ret = dscape_ioctl(drv, ¶m, sizeof(param), 1);
++
++ /* Not all drivers generate "scan completed" wireless event, so try to
++ * read results after a timeout. */
++ eloop_register_timeout(3, 0, wpa_driver_wext_scan_timeout, drv->wext,
++ drv->ctx);
++
++ return ret;
++}
++
++static int wpa_driver_dscape_set_auth_alg(void *priv, int auth_alg)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ int algs = 0;
++
++ if (auth_alg & AUTH_ALG_OPEN_SYSTEM)
++ algs |= 1;
++ if (auth_alg & AUTH_ALG_SHARED_KEY)
++ algs |= 2;
++ if (auth_alg & AUTH_ALG_LEAP)
++ algs |= 4;
++ if (algs == 0)
++ algs = 1; /* at least one algorithm should be set */
++
++ return prism2param(drv, PRISM2_PARAM_AP_AUTH_ALGS, algs);
++ return 0;
++}
++
++static int wpa_driver_dscape_get_bssid(void *priv, u8 *bssid)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ return wpa_driver_wext_get_bssid(drv->wext, bssid);
++}
++
++static int wpa_driver_dscape_get_ssid(void *priv, u8 *ssid)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ return wpa_driver_wext_get_ssid(drv->wext, ssid);
++}
++
++static int wpa_driver_dscape_get_scan_results(void *priv, struct
wpa_scan_result *results, size_t max_size)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ return wpa_driver_wext_get_scan_results(drv->wext, results, max_size);
++}
++
++static void * wpa_driver_dscape_init(void *ctx, const char *ifname)
++{
++ struct wpa_driver_dscape_data *drv;
++
++ drv = malloc(sizeof(*drv));
++ if (drv == NULL)
++ return NULL;
++ memset(drv, 0, sizeof(*drv));
++
++ drv->wext = wpa_driver_wext_init(ctx, ifname);
++ if (drv->wext == NULL) {
++ free(drv);
++ return NULL;
++ }
++
++ drv->ctx = ctx;
++ strncpy(drv->ifname, ifname, sizeof(drv->ifname));
++ drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
++ if (drv->sock < 0) {
++ perror("socket");
++ wpa_driver_wext_deinit(drv->wext);
++ free(drv);
++ return NULL;
++ }
++
++ return drv;
++}
++
++static void wpa_driver_dscape_deinit(void *priv)
++{
++ struct wpa_driver_dscape_data *drv = priv;
++ wpa_driver_wext_deinit(drv->wext);
++ close(drv->sock);
++ free(drv);
++}
++
++const struct wpa_driver_ops wpa_driver_dscape_ops = {
++ .name = "dscape",
++ .desc = "Devicescape driver",
++ .get_bssid = wpa_driver_dscape_get_bssid,
++ .get_ssid = wpa_driver_dscape_get_ssid,
++ .set_wpa = wpa_driver_dscape_set_wpa,
++ .set_key = wpa_driver_dscape_set_key,
++ .set_countermeasures = wpa_driver_dscape_set_countermeasures,
++ .set_drop_unencrypted = wpa_driver_dscape_set_drop_unencrypted,
++ .scan = wpa_driver_dscape_scan,
++ .get_scan_results = wpa_driver_dscape_get_scan_results,
++ .deauthenticate = wpa_driver_dscape_deauthenticate,
++ .disassociate = wpa_driver_dscape_disassociate,
++ .associate = wpa_driver_hostap_associate,
++ .set_auth_alg = wpa_driver_dscape_set_auth_alg,
++ .init = wpa_driver_dscape_init,
++ .deinit = wpa_driver_dscape_deinit,
++};
+diff -upN wpa_supplicant-0.4.7/driver_dscape.h
wpa_supplicant-0.4.7-dev/driver_dscape.h
+--- wpa_supplicant-0.4.7/driver_dscape.h 1970-01-01 01:00:00.000000000
+0100
++++ wpa_supplicant-0.4.7-dev/driver_dscape.h 2005-12-18 12:41:32.000000000
+0100
+@@ -0,0 +1,452 @@
++/*
++ * WPA Supplicant - driver interaction with devicescape stack
++ * Copyright (c) 2005, Sven Henkel <[EMAIL PROTECTED]>
++ *
++ * Derived from Host AP (software wireless LAN access point) user space
++ * daemon for Host AP kernel driver
++ * Copyright 2002-2003, Jouni Malinen <[EMAIL PROTECTED]>
++ * Copyright 2002-2004, Instant802 Networks, Inc.
++ * Copyright 2005, Devicescape Software, Inc.
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ *
++ * See README and COPYING for more details.
++ */
++
++
++#ifndef DSCAPE_DRIVER_H
++#define DSCAPE_DRIVER_H
++
++#ifndef BIT
++#define BIT(n) (1 << (n))
++#endif
++
++
++#ifndef __KERNEL__
++#include "ieee80211_shared.h"
++#endif /* __KERNEL__ */
++
++#define PRISM2_IOCTL_PRISM2_PARAM (SIOCIWFIRSTPRIV + 0)
++#define PRISM2_IOCTL_GET_PRISM2_PARAM (SIOCIWFIRSTPRIV + 1)
++#define PRISM2_IOCTL_HOSTAPD (SIOCIWFIRSTPRIV + 3)
++#define PRISM2_IOCTL_TEST_PARAM (SIOCIWFIRSTPRIV + 4)
++
++/* PRISM2_IOCTL_PRISM2_PARAM ioctl() subtypes: */
++enum {
++ PRISM2_PARAM_PTYPE = 1,
++ PRISM2_PARAM_TXRATECTRL = 2,
++ PRISM2_PARAM_BEACON_INT = 3,
++ PRISM2_PARAM_PSEUDO_IBSS = 4,
++ PRISM2_PARAM_ALC = 5,
++ PRISM2_PARAM_TXPOWER = 6,
++ PRISM2_PARAM_DUMP = 7,
++ PRISM2_PARAM_OTHER_AP_POLICY = 8,
++ PRISM2_PARAM_AP_MAX_INACTIVITY = 9,
++ PRISM2_PARAM_AP_BRIDGE_PACKETS = 10,
++ PRISM2_PARAM_DTIM_PERIOD = 11,
++ PRISM2_PARAM_AP_NULLFUNC_ACK = 12,
++ PRISM2_PARAM_MAX_WDS = 13,
++ PRISM2_PARAM_AP_AUTOM_AP_WDS = 14,
++ PRISM2_PARAM_AP_AUTH_ALGS = 15,
++ PRISM2_PARAM_MONITOR_ALLOW_FCSERR = 16,
++ PRISM2_PARAM_HOST_ENCRYPT = 17,
++ PRISM2_PARAM_HOST_DECRYPT = 18,
++ PRISM2_PARAM_BUS_MASTER_THRESHOLD_RX = 19,
++ PRISM2_PARAM_BUS_MASTER_THRESHOLD_TX = 20,
++ PRISM2_PARAM_HOST_ROAMING = 21,
++ PRISM2_PARAM_BCRX_STA_KEY = 22,
++ PRISM2_PARAM_IEEE_802_1X = 23,
++ PRISM2_PARAM_ANTSEL_TX = 24,
++ PRISM2_PARAM_ANTSEL_RX = 25,
++ PRISM2_PARAM_MONITOR_TYPE = 26,
++ PRISM2_PARAM_WDS_TYPE = 27,
++ PRISM2_PARAM_HOSTSCAN = 28,
++ PRISM2_PARAM_AP_SCAN = 29,
++
++ /* Instant802 additions */
++ PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES = 1001,
++ PRISM2_PARAM_DROP_UNENCRYPTED = 1002,
++ PRISM2_PARAM_PREAMBLE = 1003,
++ PRISM2_PARAM_RATE_LIMIT = 1004,
++ PRISM2_PARAM_RATE_LIMIT_BURST = 1005,
++ PRISM2_PARAM_SHORT_SLOT_TIME = 1006,
++ PRISM2_PARAM_TEST_MODE = 1007,
++ PRISM2_PARAM_NEXT_MODE = 1008,
++ PRISM2_PARAM_CLEAR_KEYS = 1009,
++ PRISM2_PARAM_ADM_STATUS = 1010,
++ PRISM2_PARAM_ANTENNA_SEL = 1011,
++ PRISM2_PARAM_CALIB_INT = 1012,
++ PRISM2_PARAM_ANTENNA_MODE = 1013,
++ PRISM2_PARAM_PRIVACY_INVOKED = 1014,
++ PRISM2_PARAM_BROADCAST_SSID = 1015,
++ PRISM2_PARAM_STAT_TIME = 1016,
++ PRISM2_PARAM_STA_ANTENNA_SEL = 1017,
++ PRISM2_PARAM_FORCE_UNICAST_RATE = 1018,
++ PRISM2_PARAM_RATE_CTRL_NUM_UP = 1019,
++ PRISM2_PARAM_RATE_CTRL_NUM_DOWN = 1020,
++ PRISM2_PARAM_MAX_RATECTRL_RATE = 1021,
++ PRISM2_PARAM_TX_POWER_REDUCTION = 1022,
++ PRISM2_PARAM_EAPOL = 1023,
++ PRISM2_PARAM_KEY_TX_RX_THRESHOLD = 1024,
++ PRISM2_PARAM_KEY_INDEX = 1025,
++ PRISM2_PARAM_DEFAULT_WEP_ONLY = 1026,
++ PRISM2_PARAM_WIFI_WME_NOACK_TEST = 1033,
++ PRISM2_PARAM_ALLOW_BROADCAST_ALWAYS = 1034,
<<Diff was trimmed, longer than 597 lines>>
_______________________________________________
pld-cvs-commit mailing list
[email protected]
http://lists.pld-linux.org/mailman/listinfo/pld-cvs-commit
