WPA_supplican架构及wext接口部分

WPA_supplicant架构及wext接口
1. 启动命令
wpa supplicant 在启动时，启动命令可以带有很多参数，目前我们的启动命令如下：
wpa_supplicant /system/bin/wpa_supplicant -Dwext -ieth0
-c/data/wifi/wpa_supplicant.conf -f/data/wifi/wpa_log.txt
wpa_supplicant对于启动命令带的参数，用了两个数据结构来保存，
一个是 wpa_params, 另一个是wpa_interface.
这主要是考虑到wpa_supplicant是可以同时支持多个网络接口的。

wpa_params数据结构主要记录与网络接口无关的一些参数设置。

而每一个网络接口就用一个wpa_interface数据结构来记录。

在启动命令行中，可以用-N来指定将要描述一个新的网络接口，对于一个新的网络接口，可以用下面六个参数描述：
-i<ifname> : 网络接口名称
-c<conf>: 配置文件名称
-C<ctrl_intf>: 控制接口名称
-D<driver>: 驱动类型
-p<driver_param>: 驱动参数
-b<br_ifname>: 桥接口名称
2. wpa_supplicant 初始化流程
2.1. main()函数：
在这个函数中，主要做了四件事。

a. 解析命令行传进的参数。

b. 调用wpa_supplicant_init()函数，做wpa_supplicant的初始化工作。

c. 调用wpa_supplicant_add_iface()函数，增加网络接口。

d. 调用wpa_supplicant_run()函数，让wpa_supplicant真正的run起来。

2.2. wpa_supplicant_init()函数：
a. 打开debug 文件。

b. 注册EAP peer方法。

c. 申请wpa_global内存，该数据结构作为统领其他数据结构的一个核心，主要
包括四个部分：
wpa_supplicant *ifaces /*每个网络接口都有一个对应的wpa_supplicant数据结构，该指针指向最近加入的一个，在wpa_supplicant数据结构中有指针指向next*/ wpa_params params /*启动命令行中带的通用的参数*/
ctrl_iface_global_priv *ctrl_iface /*global 的控制接口*/
ctrl_iface_dbus_priv *dbus_ctrl_iface /*dbus 的控制接口*/
d. 设置wpa_global中的wpa_params中的参数。

e. 调用eloop_init函数将全局变量eloop中的user_data指针指向wpa_global。

f. 调用wpa_supplicant_global_ctrl_iface_init函数初始化global 控制接口。

g. 调用wpa_supplicant_dbus_ctrl_iface_init函数初始化dbus 控制接口。

h. 将该daemon的pid写入pid_file中。

2.3. wpa_supplicant_add_iface()函数：
该函数根据启动命令行中带有的参数增加网络接口, 有几个就增加几个。

a. 因为wpa_supplicant是与网络接口对应的重要的数据结构，所以，首先分配一个wpa_supplicant数据结构的内存。

b. 调用wpa_supplicant_init_iface() 函数来做网络接口的初始工作，主要包括：
设置驱动类型，默认是wext；
读取配置文件，并将其中的信息设置到wpa_supplicant数据结构中的conf 指针指向的数据结构，它是一个wpa_config类型；
命令行设置的控制接口ctrl_interface和驱动参数driver_param覆盖配置文件里设置，命令行中的优先；
拷贝网络接口名称和桥接口名称到wpa_config数据结构；
对于网络配置块有两个链表描述它，一个是 config->ssid,它按照配置文件中的顺序依次挂载在这个链表上，还有一个是pssid，它是一个二级指针，指向一个指
针数组，该指针数组按照优先级从高到底的顺序依次保存wpa_ssid指针，相同优先级的在同一链表中挂载。

c. 调用wpa_supplicant_init_iface2() 函数，主要包括：
调用wpa_supplicant_init_eapol()函数来初始化eapol；
调用相应类型的driver的init()函数；
设置driver的param参数；
调用wpa_drv_get_ifname()函数获得网络接口的名称，对于wext类型的driver，没有这个接口函数；
调用wpa_supplicant_init_wpa()函数来初始化wpa，并做相应的初始化工作；
调用wpa_supplicant_driver_init()函数，来初始化driver接口参数；在该函数的最后，会
wpa_s->prev_scan_ssid = BROADCAST_SSID_SCAN;
wpa_supplicant_req_scan(wpa_s, interface_count, 100000);
来主动发起scan，
调用wpa_supplicant_ctrl_iface_init()函数，来初始化控制接口；对于UNIX SOCKET这种方式，其本地socket文件是由配置文件里的ctrl_interface参数指定的路径加上网络接口名称；
2.4. wpa_supplicant_run()函数：
初始化完成之后，让wpa_supplicant的main event loop run起来。

在wpa_supplicant中，有许多与外界通信的socket，它们都是需要注册到eloop event模块中的，具体地说，就是在eloop_sock_table中增加一项记录，其中包括了sock_fd, handle, eloop_data, user_data。

eloop event模块就是将这些socket组织起来，统一管理，然后在eloop_run中利用select机制来管理socket的通信。

3. Wpa_supplicant提供的接口
从通信层次上划分，wpa_supplicant提供向上的控制接口 control interface，用于与其他模块（如UI）进行通信，其他模块可以通过control interface 来获取信息或下发命令。

Wpa_supplicant通过socket通信机制实现下行接口，与内核进行通信，获取信息或下发命令。

3.1 上行接口
Wpa_supplicant提供两种方式的上行接口。

一种基于传统dbus机制实现与其他进程间的IPC通信；另一种通过Unix domain socket机制实现进程间的IPC通信。

3.1.1 Dbus接口
该接口主要在文件“ctrl_iface_dbus.h”，“ctrl_iface_dbus.c”，
“ctrl_iface_dbus_handler.h”和“ctrl_iface_dbus_handler.c”中实现，提供一些基本的控制方法。

DBusMessage * wpas_dbus_new_invalid_iface_error(DBusMessage *message);
DBusMessage * wpas_dbus_global_add_interface(DBusMessage *message,
struct wpa_global *global);
DBusMessage * wpas_dbus_global_remove_interface(DBusMessage *message,
struct wpa_global *global);
DBusMessage * wpas_dbus_global_get_interface(DBusMessage *message,
struct wpa_global *global);
DBusMessage * wpas_dbus_global_set_debugparams(DBusMessage *message,
struct wpa_global *global);
DBusMessage * wpas_dbus_iface_scan(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_scan_results(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_bssid_properties(DBusMessage *message,
struct wpa_supplicant *wpa_s,
struct wpa_scan_res *res);
DBusMessage * wpas_dbus_iface_capabilities(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_add_network(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_remove_network(DBusMessage *message, struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_set_network(DBusMessage *message,
struct wpa_supplicant *wpa_s,
struct wpa_ssid *ssid);
DBusMessage * wpas_dbus_iface_enable_network(DBusMessage *message, struct wpa_supplicant *wpa_s,
struct wpa_ssid *ssid);
DBusMessage * wpas_dbus_iface_disable_network(DBusMessage *message, struct wpa_supplicant *wpa_s,
struct wpa_ssid *ssid);
DBusMessage * wpas_dbus_iface_select_network(DBusMessage *message, struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_disconnect(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_set_ap_scan(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_set_smartcard_modules(
DBusMessage *message, struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_get_state(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_get_scanning(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_set_blobs(DBusMessage *message,
struct wpa_supplicant *wpa_s);
DBusMessage * wpas_dbus_iface_remove_blobs(DBusMessage *message,
struct wpa_supplicant *wpa_s);
3.1.2 Unix domain socket 接口
该接口主要在文件“wpa_ctrl.h”，“wpa_ctrl.c”，“ctrl_iface_unix.c”，“ctrl_iface.h”和“ctrl_iface.c”实现。

（1）“wpa_ctrl.h”，“wpa_ctrl.c”完成对control interface的封装，对外提供统一的接口。

其主要的工作是通过Unix domain socket建立一个control interface 的client结点，与作为server的wpa_supplicant结点通信。

主要功能函数：
struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path);
/* 建立并初始化一个Unix domain socket的client结点，并与作为server的
wpa_supplicant结点绑定 */
void wpa_ctrl_close(struct wpa_ctrl *ctrl);
/* 撤销并销毁已建立的Unix domain socket的client结点 */
int wpa_ctrl_request(struct wpa_ctrl *ctrl, const char *cmd, size_t cmd_len,
char *reply, size_t *reply_len,
void (*msg_cb)(char *msg, size_t len));
/* 用户模块直接调用该函数对wpa_supplicant发送命令并获取所需信息
* 可以发送的命令如附件1所示 */
Note:
Wpa_supplicant 提供两种由外部模块获取信息的方式：一种是外部模块通过发送request 命令然后获取response的问答模式，另一种是wpa_supplicant主动向外部发送event事件，由外部模块监听接收。

一般的常用做法是外部模块通过调用wpa_ctrl_open()两次，建立两个control interface接口，一个为ctrl interface，用于发送命令，获取信息，另一个为monitor interface，用于监听接收来自于wpa_supplicant的event时间。

此举可以降低通信的耦合性，避免response和event的相互干扰。

int wpa_ctrl_attach(struct wpa_ctrl *ctrl);
/* 注册某个 control interface 作为 monitor interface */
int wpa_ctrl_detach(struct wpa_ctrl *ctrl);
/* 撤销某个 monitor interface 为普通的 control interface */
int wpa_ctrl_pending(struct wpa_ctrl *ctrl)；
/* 判断是否有挂起的event 事件 */
int wpa_ctrl_recv(struct wpa_ctrl *ctrl, char *reply, size_t *reply_len);
/* 获取挂起的event 事件 */
（2）“ctrl_iface_unix.c”实现wpa_supplicant的Unix domain socket通信机制中server结点，完成对client结点的响应。

其中最主要的两个函数为：
static void wpa_supplicant_ctrl_iface_receive(int sock, void *eloop_ctx,
void *sock_ctx)
/* 接收并解析client发送request命令，然后根据不同的命令调用底层不同的处理函数；
* 然后将获得response结果回馈到 client 结点。

*/
static void wpa_supplicant_ctrl_iface_send(struct ctrl_iface_priv *priv,
int level, const char *buf,
size_t len)
/* 向注册的monitor interfaces 主动发送event事件 */
（3）“ctrl_iface.h”和“ctrl_iface.c”主要实现了各种request命令的底层处理函数。

3.2 下行接口
Wpa_supplicant提供的下行接口主要用于和kernel（driver）进行通信，下发命令和获取信息。

Wpa_supplicant下行接口主要包括三种重要的接口：
1．PF_INET socket接口，主要用于向kernel 发送ioctl命令，控制并获取相应信息。

2．PF_NETLINK socket接口，主要用于接收kernel发送上来的event 事件。

3．PF_PACKET socket接口，主要用于向driver传递802.1X报文。

主要涉及到的文件包括：“driver.h”，“drivers.c”，“driver_wext.h”，“driver_wext.c”，
“drivers.c”，“driver_wext.h”“l2_packet.h”和“l2_packet_linux.c”。

其中“driver.h”，
和“driver_wext.c”实现PF_INET socket接口和PF_NETLINK socket接口；
“l2_packet.h”和“l2_packet_linux.c”实现PF_PACKET socket接口。

（1）“driver.h”，“drivers.c”主要用于封装底层差异对外显示一个相同的wpa_driver_ops接口。

Wpa_supplicant可支持atmel, Broadcom, ipw, madwifi, ndis, nl80211, wext等多种驱动。

其中一个最主要的数据结构为wpa_driver_ops, 其定义了driver相关的各种操作接口。

（2）“driver_wext.h”，“driver_wext.c”实现了wext形式的wpa_driver_ops，并创建了PF_INET socket接口和PF_NETLINK socket接口，然后通过这两个接口完成与kernel的信息交互。

Wext提供的一个主要数据结构为：
struct wpa_driver_wext_data {
void *ctx;
int event_sock;
int ioctl_sock;
int mlme_sock;
char ifname[IFNAMSIZ + 1];
int ifindex;
int ifindex2;
int if_removed;
u8 *assoc_req_ies;
size_t assoc_req_ies_len;
u8 *assoc_resp_ies;
size_t assoc_resp_ies_len;
struct wpa_driver_capa capa;
int has_capability;
int we_version_compiled;
/* for set_auth_alg fallback */
int use_crypt;
int auth_alg_fallback;
int operstate;
char mlmedev[IFNAMSIZ + 1];
int scan_complete_events;
};
其中event_sock 为PF_NETLINK socket接口，ioctl_sock为PF_INET socket借口。

Driver_wext.c实现了大量底层处理函数用于实现wpa_driver_ops操作参数，其中比较重要的有：
void * wpa_driver_wext_init(void *ctx, const char *ifname)；
/* 初始化wpa_driver_wext_data 数据结构，并创建PF_NETLINK socket
和PF_INET socket 接口 */
void wpa_driver_wext_deinit(void *priv)；
/* 销毁wpa_driver_wext_data 数据结构，PF_NETLINK socket
和PF_INET socket 接口 */
static void wpa_driver_wext_event_receive(int sock, void *eloop_ctx,
void *sock_ctx)；
/* 处理kernel主动发送的event事件的 callback 函数 */
最后，将实现的操作函数映射到一个全局的wpa_driver_ops类型数据结构wpa_driver_wext_ops中。

const struct wpa_driver_ops wpa_driver_wext_ops = {
.name = "wext",
.desc = "Linux wireless extensions (generic)",
.get_bssid = wpa_driver_wext_get_bssid,
.get_ssid = wpa_driver_wext_get_ssid,
.set_wpa = wpa_driver_wext_set_wpa,
.set_key = wpa_driver_wext_set_key,
.set_countermeasures = wpa_driver_wext_set_countermeasures,
.set_drop_unencrypted = wpa_driver_wext_set_drop_unencrypted,
.scan = wpa_driver_wext_scan,
.get_scan_results2 = wpa_driver_wext_get_scan_results,
.deauthenticate = wpa_driver_wext_deauthenticate,
.disassociate = wpa_driver_wext_disassociate,
.set_mode = wpa_driver_wext_set_mode,
.associate = wpa_driver_wext_associate,
.set_auth_alg = wpa_driver_wext_set_auth_alg,
.init = wpa_driver_wext_init,
.deinit = wpa_driver_wext_deinit,
.add_pmkid = wpa_driver_wext_add_pmkid,
.remove_pmkid = wpa_driver_wext_remove_pmkid,
.flush_pmkid = wpa_driver_wext_flush_pmkid,
.get_capa = wpa_driver_wext_get_capa,
.set_operstate = wpa_driver_wext_set_operstate,
};
（3）“l2_packet.h”和“l2_packet_linux.c”主要用于实现PF_PACKET socket 接口，通过该接口，wpa_supplicant可以直接将802.1X packet发送到L2层，而不经过TCP/IP协议栈。

其中主要的功能函数为：
struct l2_packet_data * l2_packet_init(
const char *ifname, const u8 *own_addr, unsigned short protocol,
void (*rx_callback)(void *ctx, const u8 *src_addr,
const u8 *buf, size_t len),
void *rx_callback_ctx, int l2_hdr);
/* 创建并初始化PF_PACKET socket接口，其中rx_callback 为从L2接收到的packet 处理callback函数 */
void l2_packet_deinit(struct l2_packet_data *l2);
/* 销毁PF_PACKET socket接口 */
int l2_packet_send(struct l2_packet_data *l2, const u8 *dst_addr, u16 proto,
const u8 *buf, size_t len);
/*L2层packet发送函数，wpa_supplicant用此发送L2层 802.1X packet */
static void l2_packet_receive(int sock, void *eloop_ctx, void *sock_ctx);
/* L2层packet接收函数，接收来自L2层数据后，将其发送到上层 */
WPA_supplicant与wifi的WEXT接口
/* -------------------------- IOCTL LIST -------------------------- */
/* Wireless Identification */
#define SIOCSIWCOMMIT 0x8B00 /* Commit pending changes to driver */
//RDA:NULL
#define SIOCGIWNAME 0x8B01 /* get name == wireless protocol */
/* SIOCGIWNAME is used to verify the presence of Wireless Extensions.
* Common values : "IEEE 802.11-DS", "IEEE 802.11-FH", "IEEE 802.11b"...
* Don't put the name of your driver there, it's useless. */
// RDA code:snprintf(cwrq, IFNAMSIZ, "IEEE 802.11b/g");
/* Basic operations */
#define SIOCSIWNWID 0x8B02 /* set network id (pre-802.11) */
//RDA:NULL
#define SIOCGIWNWID 0x8B03 /* get network id (the cell) */
//RDA:NULL
#define SIOCSIWFREQ 0x8B04 /* set channel/frequency (Hz) */
//RDA:直接return
#define SIOCGIWFREQ 0x8B05 /* get channel/frequency (Hz) */
//RDA:
fwrq->m = (long)2437 * 100000;
fwrq->e = 1;
#define SIOCSIWMODE 0x8B06 /* set operation mode */
//RDA:直接return
/*mode?IW_MODE_ADHOC : IW_MODE_INFRA*/
#define SIOCGIWMODE 0x8B07 /* get operation mode */
//RDA:*uwrq = IW_MODE_INFRA;
/*#define IW_MODE_AUTO 0 /* Let the driver decides */
#define IW_MODE_ADHOC 1 /* Single cell network */
#define IW_MODE_INFRA 2 /* Multi cell network, roaming, ... */
#define IW_MODE_MASTER 3 /* Synchronisation master or Access Point */ #define IW_MODE_REPEAT 4 /* Wireless Repeater (forwarder) */
#define IW_MODE_SECOND 5 /* Secondary master/repeater (backup) */ #define IW_MODE_MONITOR 6 /* Passive monitor (listen only) */
#define IW_MODE_MESH 7 /* Mesh (IEEE 802.11s) network */*/
#define SIOCSIWSENS 0x8B08 /* set sensitivity (dBm) */
//RDA:NULL
#define SIOCGIWSENS 0x8B09 /* get sensitivity (dBm) */
/* Informative stuff */
#define SIOCSIWRANGE 0x8B0A /* Unused */
//RDA:NULL
#define SIOCGIWRANGE 0x8B0B /* Get range of parameters */
//RDA:
range->we_version_compiled;
range->enc_capa:加密方式支持
/* Bit field values for enc_capa in struct iw_range */
#define IW_ENC_CAPA_WPA 0x00000001
#define IW_ENC_CAPA_WPA2 0x00000002
#define IW_ENC_CAPA_CIPHER_TKIP 0x00000004
#define IW_ENC_CAPA_CIPHER_CCMP 0x00000008
#define IW_ENC_CAPA_4WAY_HANDSHAKE 0x00000010//RDA未支持该项range->bitrate[i] = rda5890_bg_rates[i] * 500000;
range->num_bitrates = i;
range->scan_capa = IW_SCAN_CAPA_ESSID
#define IW_SCAN_CAPA_NONE 0x00
#define IW_SCAN_CAPA_ESSID 0x01
#define IW_SCAN_CAPA_BSSID 0x02
#define IW_SCAN_CAPA_CHANNEL 0x04
#define IW_SCAN_CAPA_MODE 0x08
#define IW_SCAN_CAPA_RATE 0x10
#define IW_SCAN_CAPA_TYPE 0x20
#define IW_SCAN_CAPA_TIME 0x40
range->freq[range->num_frequency].i = (long)(i + 1);
range->freq[range->num_frequency].m = (long)((2412 + 5 * i) * 100000); range->freq[range->num_frequency].e = 1;
range->num_channels = range->num_frequency;
range->throughput = 5000 * 1000;
range->min_rts = RDA5890_RTS_MIN_VALUE;
range->max_rts = RDA5890_RTS_MAX_VALUE;
range->min_frag = RDA5890_FRAG_MIN_VALUE;
range->max_frag = RDA5890_FRAG_MAX_VALUE;
range->encoding_size[0] = 5;
range->encoding_size[1] = 13;
range->num_encoding_sizes = 2;
range->max_encoding_tokens = 4;
range->pm_capa = IW_POWER_ON;
range->we_version_compiled = WIRELESS_EXT;
range->retry_capa = IW_RETRY_LIMIT;
range->retry_flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
range->min_retry = 0;
range->max_retry = 14;
/*
* Set the qual, level and noise range values
*/
range->max_qual.qual = 100;
range->max_qual.level = 0;
range->max_qual.noise = 0;
range->max_qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
range->avg_qual.qual = 70;
/* TODO: Find real 'good' to 'bad' threshold value for RSSI */
range->avg_qual.level = 0;
range->avg_qual.noise = 0;
range->avg_qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
range->sensitivity = 0;
/* Setup the supported power level ranges */
memset(range->txpower, 0, sizeof(range->txpower));
range->txpower_capa = IW_TXPOW_DBM | IW_TXPOW_RANGE;
range->txpower[0] = 0;
range->txpower[1] = 20;
range->num_txpower = 2;
range->event_capa[0] = (IW_EVENT_CAPA_K_0 |
IW_EVENT_CAPA_MASK(SIOCGIWAP) |
IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
range->event_capa[1] = IW_EVENT_CAPA_K_1;
range->enc_capa = IW_ENC_CAPA_WPA
| IW_ENC_CAPA_WPA2
| IW_ENC_CAPA_CIPHER_TKIP
| IW_ENC_CAPA_CIPHER_CCMP;
#define SIOCSIWPRIV 0x8B0C /* Unused */
//RDA:NULL
//this is private command interface,we could add some like “driver_*” cmd #define SIOCGIWPRIV 0x8B0D /* get private ioctl interface info */ //RDA:NULL
#define SIOCSIWSTATS 0x8B0E /* Unused */
//RDA:NULL
#define SIOCGIWSTATS 0x8B0F /* Get /proc/net/wireless stats */
/* SIOCGIWSTATS is strictly used between user space and the kernel, and
* is never passed to the driver (i.e. the driver will never see it). */
//RDA:NULL
/* Spy support (statistics per MAC address - used for Mobile IP support) */ #define SIOCSIWSPY 0x8B10 /* set spy addresses */
//RDA:NULL
#define SIOCGIWSPY 0x8B11 /* get spy info (quality of link) */
//RDA:NULL
#define SIOCSIWTHRSPY 0x8B12 /* set spy threshold (spy event) */
//RDA:NULL
#define SIOCGIWTHRSPY 0x8B13 /* get spy threshold */
//RDA:NULL
/* Access Point manipulation */
#define SIOCSIWAP 0x8B14 /* set access point MAC addresses */ RDA:ap_addr = awrq->sa_data;//this modify will cause associate
#define SIOCGIWAP 0x8B15 /* get access point MAC addresses */ //RDA:return address
#define SIOCGIWAPLIST 0x8B17 /* Deprecated in favor of scanning */ //RDA:NULL
#define SIOCSIWSCAN 0x8B18 /* trigger scanning (list cells) */
//RDA:trigger scan ,RDA’s driver do not use any param
#define SIOCGIWSCAN 0x8B19 /* get scanning results */
/* 802.11 specific support */
#define SIOCSIWESSID 0x8B1A /* set ESSID (network name) */
memcpy(&ssid, extra, in_ssid_len);
//than trigger associate
#define SIOCGIWESSID 0x8B1B /* get ESSID */
#define SIOCSIWNICKN 0x8B1C /* set node name/nickname */
//RDA:直接return
#define SIOCGIWNICKN 0x8B1D /* get node name/nickname */
//RDA:直接return
/* As the ESSID and NICKN are strings up to 32 bytes long, it doesn't fit
* within the 'iwreq' structure, so we need to use the 'data' member to
* point to a string in user space, like it is done for RANGE... */
/* Other parameters useful in 802.11 and some other devices */
#define SIOCSIWRATE 0x8B20 /* set default bit rate (bps) */
//RDA:直接return
#define SIOCGIWRATE 0x8B21 /* get default bit rate (bps) */
vwrq->fixed = 0;
vwrq->value = 108*500000;
#define SIOCSIWRTS 0x8B22 /* set RTS/CTS threshold (bytes) */
#define SIOCGIWRTS 0x8B23 /* get RTS/CTS threshold (bytes) */
#define SIOCSIWFRAG 0x8B24 /* set fragmentation thr (bytes) */
#define SIOCGIWFRAG 0x8B25 /* get fragmentation thr (bytes) */
val = 1460;
vwrq->value = val;
vwrq->disabled = ((val < RDA5890_FRAG_MIN_VALUE) || (val > RDA5890_FRAG_MAX_VALUE)); vwrq->fixed = 1;
#define SIOCSIWTXPOW 0x8B26 /* set transmit power (dBm) */
//this interface could be use for powermagement
#define SIOCGIWTXPOW 0x8B27 /* get transmit power (dBm) */
#define SIOCSIWRETRY 0x8B28 /* set retry limits and lifetime */
#define SIOCGIWRETRY 0x8B29 /* get retry limits and lifetime */
/* Encoding stuff (scrambling, hardware security, WEP...) */
#define SIOCSIWENCODE 0x8B2A /* set encoding token & mode */
#define SIOCGIWENCODE 0x8B2B /* get encoding token & mode */
/* Power saving stuff (power management, unicast and multicast) */
#define SIOCSIWPOWER 0x8B2C /* set Power Management settings */
#define SIOCGIWPOWER 0x8B2D /* get Power Management settings */
/* WPA : Generic IEEE 802.11 informatiom element (e.g., for WPA/RSN/WMM). * This ioctl uses struct iw_point and data buffer that includes IE id and len
* fields. More than one IE may be included in the request. Setting the generic * IE to empty buffer (len=0) removes the generic IE from the driver. Drivers
* are allowed to generate their own WPA/RSN IEs, but in these cases, drivers * are required to report the used IE as a wireless event, e.g., when
* associating with an AP. */
#define SIOCSIWGENIE 0x8B30 /* set generic IE */
#define SIOCGIWGENIE 0x8B31 /* get generic IE */
/* WPA : IEEE 802.11 MLME requests */
#define SIOCSIWMLME 0x8B16 /* request MLME operation; uses
* struct iw_mlme */
/* WPA : Authentication mode parameters */
//RDA: deauth&disassoc use this func
#define SIOCSIWAUTH 0x8B32 /* set authentication mode params */ #define SIOCGIWAUTH 0x8B33 /* get authentication mode params */
/* WPA : Extended version of encoding configuration */
#define SIOCSIWENCODEEXT 0x8B34 /* set encoding token & mode */ #define SIOCGIWENCODEEXT 0x8B35 /* get encoding token & mode */
/* WPA2 : PMKSA cache management */
#define SIOCSIWPMKSA0x8B36 /* PMKSA cache operation */
/* -------------------- DEV PRIVATE IOCTL LIST -------------------- */
/* These 32 ioctl are wireless device private, for 16 commands.
* Each driver is free to use them for whatever purpose it chooses,
* however the driver *must* export the description of those ioctls
* with SIOCGIWPRIV and *must* use arguments as defined below.
* If you don't follow those rules, DaveM is going to hate you (reason :
* it make mixed 32/64bit operation impossible).
*/
#define SIOCIWFIRSTPRIV 0x8BE0
#define SIOCIWLASTPRIV 0x8BFF。