ref: https://blog.csdn.net/tmwiajd
hostapd源代码分析（一）：网络接口和BSS的初始化
最近在做一个基于OpenFlow 协议的无线AP 的项目，于是就分析了hostapd 的源代码，并在原有的基础上添加上我们的代码。经过近半个月的调试和分析，算是基本上搞清楚了hostapd 的运作机制。鉴于网上对于hostapd 的具体资料甚是稀少，所以笔者在此整理学习笔记并在网上与各位读者分享，希望能对读者们有帮助。如果有分析不恰当或者错误的地方，也欢迎各位指正。另外，本文是在读者已经具有IEEE 802.11 和良好C 语言的基础的假设上写的，因此，本文将直奔主题，对于IEEE 802.11 和C 代码细节将不再赘述。
还有，笔者在分析hostapd 源代码的时候，hostapd/supplicant 开发文档也提供了大量的有用信息，各位读者也可以参考。（http://w1.fi/wpa_supplicant/devel/）
一、几个重要的数据结构
此次分析hostapd 源代码，发现了其中出现频率最高的两个数据结构——struct hostapd_iface 和struct hostapd_data。其实很简单，hostapd_iface 结构体描述了一个物理接口（比如wlan0），hostapd_data 则描述一个BSS。这两个数据结构几乎贯穿所有的源代码，所以一定要搞清楚这两个数据结构。
struct hostapd_iface (src/ap/hostapd.h)。在这个数据结构中，主要有以下字段：
struct hostapd_config： 保存对网络接口的配置（从配置文件hostapd.conf中加载）
sizt_t num_bss： 此接口下辖的BSS 个数
struct hostapd_data **bss：BSS 列表，描述各BSS 的配置
struct hostapd_data (src/ap/hostapd.h)。在这个数据结构中，主要有以下字段：
struct hostapd_bss_config *conf：保存BSS 的配置信息（从配置文件hostapd.conf 中加载）
u8 own_addr[ETH_ALEN]：表示此BSS 的BSSID （ETH_ALEN 为6，u8 其实是unsigned char）
struct wpa_driver_ops *driver：指向一组驱动程序接口，用来和内核交互。（这里是用的nl80211）
说到这里，也许有人会问，实际源文件中有数十个字段，难道只知道这些就足够了吗？我的答案是肯定的——是的，只需要知道这么多。
二、hostapd 初始化
首先，我们打开hostapd/main.c，并找到主程序入口main()。直接跳转到大概659 行。看到如下代码：
for (i = 0; i < interfaces.count; i++) {
interfaces.iface[i] = hostapd_interface_init(&interfaces,argv[optind + i],debug);
if (!interfaces.iface[i]) {
wpa_printf(MSG_ERROR, "Failed to initialize interface");
goto out;
}
}
很明显， 这是对每个网络接口（ 或者干脆叫物理网卡也行） 的初始化。然后找到hostapd_interface_init 的定义（大概从main.c 的第234 行开始），我们看到了如下的一句话：
iface = hostapd_init(interfaces, config_fname);
嗯，看来，真正的初始化工作是在hostapd_init 函数中进行，并返回一个描述网络接口的结构体（struct hostapd_iface）。然后我们再深一层的挖掘，找到hostapd_init 的定义（从src/ap/hostapd.c 的第1416 行起）。我们先看那句
conf = interfaces->config_read_cb(hapd_iface->config_file);</span>
这个其实就是读取hostapd 的配置文件hostapd.conf 中的配置信息，并保存到hostapd_conf的结构体中去。之后紧接着就是为每个BSS 分配内存空间：
hapd_iface->num_bss = conf->num_bss; //从配置信息中获取BSS 的个数
hapd_iface->bss = os_calloc(conf->num_bss, sizeof(struct hostapd_data *)); //分配BSS 列表空间
if (hapd_iface->bss == NULL) //内存空间分配失败
goto fail;
for (i = 0; i < conf->num_bss; i++) {
hapd = hapd_iface->bss[i] = hostapd_alloc_bss_data(hapd_iface, conf, conf->bss[i]); //初始化每个BSS 数据结构
if (hapd == NULL) //内存空间分配失败
goto fail;
hapd->msg_ctx = hapd; //这句不知道啥意思，不过也无妨
}
OK，到这里，网络接口和每个BSS 的基本初始化（即为它们分配内存）的工作结束了。回到main，跳转到第715 行，我们看到了这句话：
if (hostapd_driver_init(interfaces.iface[i])|| hostapd_setup_interface(interfaces.iface[i]))
goto out;
从字面上理解，那就是“初始化每个网络接口的驱动程序”和“设置每个网络接口”。好吧，我们先看hostapd_driver_init 函数是如何定义的。最关键的是在第185 行到第204 行。代码如下：
params.bssid = b; //BSSID
params.ifname = hapd->conf->iface; //网络接口名称（比如wlan0）
params.ssid = hapd->conf->ssid.ssid; //SSID
params.ssid_len = hapd->conf->ssid.ssid_len; //SSID 长度
…………（这部分不重要。好吧，我承认我也不清楚是干嘛的……）
params.own_addr = hapd->own_addr; //网络接口的MAC 地址
hapd->drv_priv = hapd->driver->hapd_init(hapd, ¶ms); //将以上参数传递给驱动程序
那么，问题来了，hapd_init 是怎么定义的呢？由于笔者分析的hostapd 是基于nl80211 的，所以hapd_init 指向nl80211 的初始化函数i802_init（定义在src/drivers/nl80211_driver.c 中，本文只分析hostapd 在用户空间的工作原理，至于内核空间是如何工作的，不在本文讨论之列。有兴趣的读者可以查找有关Netlink 和mac80211 的资料。笔者以后也会推出关于mac80211 的学习笔记）。好了，驱动程序初始化完了，下面我们看如何设置每个网络接口。hostapd_setup_interface 函数定义在src/ap/hostapd.c，打开这个文件，跳到大概1315 行，里面就一句setup_interface……好吧，找到大概第1040 行，就是这个函数的定义。里面有一段话是这么说的：
/*
* Make sure that all BSSes get configured with a pointer to the same
* driver interface.
*/
for (i = 1; i < iface->num_bss; i++) {
iface->bss[i]->driver = hapd->driver;
iface->bss[i]->drv_priv = hapd->drv_priv;
}
还好有注释，就是确保每个BSS 都使用和物理网卡（我喜欢称呼BSS 为虚拟网卡）同一套驱动程序接口。然后直接看return 吧，哎？怎么又有个setup_interface2？好吧，去看
看setup_interface2 是怎么回事……找到大概第1113 行，就是它的定义了。这里面主要是设置网卡的硬件模式（ a,g,n 等等）， 再看return ， 我去， 咋还有个hostapd_setup_interface_complete 呢？（ 程序作者真磨叽） 好吧，既然说了complete，那应该就是最后一步了吧？那我就硬着头皮继续看看——跳到大概1162 行，就找到了它的定义。这个过程里面主要是设置网卡的信道，速率（根据硬件模式），RTS 参数等等。最后通过hostapd_setup_bss 函数配置每个BSS 。那我们就再看看
hostapd_setup_bss 是怎么个回事吧（ 无语） — — 再跳到大概687 行， 就找到了hostapd_setup_bss 的定义。这个函数需要两个参数，第一个是hostapd_data 结构
体，描述一个BSS 的配置信息，第二个参数first 则用来表示这个BSS 是否为第一个BSS（通常，第一个BSS 就是wlan0）。先看第一部分代码：
if (!first || first == -1) { //此BSS 不是第一个BSS 的情况
if (hostapd_mac_comp_empty(conf->bssid) == 0) { //配置文件没有为此BSS 指定BSSID
/* Allocate the next available BSSID. */
do {
//将上一个BSS 的BSSID 增加1 做为这个BSS 的BSSID，并且反复这一步骤直到不与其他BSSID 重复为止
inc_byte_array(hapd->own_addr, ETH_ALEN);
} while (mac_in_conf(hapd->iconf, hapd->own_addr));
} else { //配置文件已经为此BSS 指定BSSID 的情况
/* Allocate the configured BSSID. */
os_memcpy(hapd->own_addr, conf->bssid, ETH_ALEN);
if (hostapd_mac_comp(hapd->own_addr, hapd->iface->bss[0]->own_addr) ==0) {
wpa_printf(MSG_ERROR, "BSS '%s' may not have "
"BSSID set to the MAC address of "
"the radio", conf->iface);
return -1;
}
}
hapd->interface_added = 1; //不知道干嘛的
//在内核中为此BSS 创建一个interface（比如wlan0_0）
if (hostapd_if_add(hapd->iface->bss[0], WPA_IF_AP_BSS,
conf->iface, hapd->own_addr, hapd, &hapd->drv_priv, force_ifname, if_addr,
conf->bridge[0] ? conf->bridge : NULL, first == -1)) {
wpa_printf(MSG_ERROR, "Failed to add BSS (BSSID="
MACSTR ")", MAC2STR(hapd->own_addr));
hapd->interface_added = 0;
return -1;
}
}
再看第二部分：
…… //此部分是对这个BSS 的加密方式，SSID 等参数的设置
//将这个BSS 的interface 激活。（假设这个BSS 的interface 为wlan0_0 的话，那么这句话的意思就相当于在终端下执行“ifconfig wlan0_0 up”命令）
if (hapd->driver && hapd->driver->set_operstate)
hapd->driver->set_operstate(hapd->drv_priv, 1);
return 0;
啊，终于是return 0 了。好了，重新回到main。至此，网络接口和每个BSS 的初始化工作完成了。
未完待续……下一篇将详细讲解hostapd的工作机制。
hostapd源代码分析（二）：hostapd的工作机制
在我的上一篇文章《hostapd源代码分析（一）：网络接口和BSS的初始化》中，介绍了两个重要的数据结构hostapd_iface和hostapd_data以及网络接口和BSS的初始化设置的过程。下面，我要在这一篇文章中详细介绍hostapd的工作机制。hostapd的模块结构如下
从上图中可以看出，hostapd通过一个叫做“event_loop”的核心模块来处理来自各个模块的事件。一开始我觉得hostapd是以多线程的方式来异步处理各个事件的，但其实hostapd从头到尾都是单一线程——是的，我们的hostapd是移植到的MIPS的嵌入式系统上面（我们用的是RouterStation Pro），这么多的线程在嵌入式Linux上面是不现实的。其实，hostapd是通过socket来接受其他模块发来的消息的，并通过select()或者poll()系统调用来轮询各个socket的描述符，一旦发现众多socket描述符中有可用的描述符时，便调用相应的回调函数来处理相关事件。（关于select()或者poll()的用法，请各位读者参考《Advanced Programming in the UNIX Environment》和《UNIX network programming》等书籍中的相关介绍，本文不做赘述）
首先，我们来看几个关于event loop的数据结构。打开src/utils/eloop.c，部分代码如下：
//eloop_sock表示一个注册的socket
struct eloop_sock {
int sock; //socket的描述符
void *eloop_data; //回调函数的第一个参数
void *user_data; //回调函数的第二个参数
eloop_sock_handler handler; //当事件发生时调用的回调函数入口
....
};
//eloop_sock_table表示已经注册的socket列表
struct eloop_sock_table {
int count; //已注册的socket个数
struct eloop_sock *table; //具体的socket注册信息（描述符，回调函数参数，回调函数入口等）
....
};
//eloop_data表示所有的socket事件
struct eloop_data {
int max_sock; //所有socket描述符中的最大值
int count; /* sum of all table counts */
struct eloop_sock_table readers; //socket“读事件”列表
struct eloop_sock_table writers; //socket“写事件”列表
struct eloop_sock_table exceptions;//socket“意外事件”列表
....
};
再看几个关于event loop的函数：
int eloop_register_sock(int sock, eloop_event_type type,
eloop_sock_handler handler,
void *eloop_data, void *user_data)
{
struct eloop_sock_table *table;
assert(sock >= 0);
table = eloop_get_sock_table(type);
return eloop_sock_table_add_sock(table, sock, handler,
eloop_data, user_data);
}
void eloop_unregister_sock(int sock, eloop_event_type type)
{
struct eloop_sock_table *table;
table = eloop_get_sock_table(type);
eloop_sock_table_remove_sock(table, sock);
}
int eloop_register_read_sock(int sock, eloop_sock_handler handler,
void *eloop_data, void *user_data)
{
return eloop_register_sock(sock, EVENT_TYPE_READ, handler,
eloop_data, user_data);
}
void eloop_unregister_read_sock(int sock)
{
eloop_unregister_sock(sock, EVENT_TYPE_READ);
}
我们先看看eloop_register_read_sock函数。很明显，这个函数是把socket描述符和期相对应的回调函数注册到socket描述符表中去。这个函数会调用eloop_register_sock函数，并设置EVENT_TYPE_READ标志，表示这个socket主要用于“读”（也即“接收”）。同理，eloop_unregister_read_sock和eloop_unregister_sock是用来把某个socket描述符从表中删除（一般在hostapd退出的时候调用）。接下来再看eloop是如何执行的，找到eloop_run()函数：
void eloop_run(void)
{
fd_set *rfds, *wfds, *efds; //读、写、意外文件描述符集合
struct timeval _tv;
int res;
struct os_reltime tv, now;
rfds = os_malloc(sizeof(*rfds));
wfds = os_malloc(sizeof(*wfds));
efds = os_malloc(sizeof(*efds));
if (rfds == NULL || wfds == NULL || efds == NULL)
goto out;
while (!eloop.terminate &&
(!dl_list_empty(&eloop.timeout) || eloop.readers.count > 0 ||
eloop.writers.count > 0 || eloop.exceptions.count > 0)) {
struct eloop_timeout *timeout;
timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
list);
if (timeout) {
os_get_reltime(&now);
if (os_reltime_before(&now, &timeout->time))
os_reltime_sub(&timeout->time, &now, &tv);
else
tv.sec = tv.usec = 0;
_tv.tv_sec = tv.sec;
_tv.tv_usec = tv.usec;
}
//通过FD_SET宏设置“读”、“写”、“意外”的文件描述符集合
eloop_sock_table_set_fds(&eloop.readers, rfds);
eloop_sock_table_set_fds(&eloop.writers, wfds);
eloop_sock_table_set_fds(&eloop.exceptions, efds);
//通过select()检查各个文件描述符的状态
res = select(eloop.max_sock + 1, rfds, wfds, efds,
timeout ? &_tv : NULL);
if (res < 0 && errno != EINTR && errno != 0) {
wpa_printf(MSG_ERROR, "eloop: %s: %s", <span style="font-family: Arial, Helvetica, sans-serif;">"select"</span>, strerror(errno));
goto out;
}
eloop_process_pending_signals();
/* check if some registered timeouts have occurred */
//检查是否有超时发生
timeout = dl_list_first(&eloop.timeout, struct eloop_timeout,
list);
if (timeout) { //如果有超时发生，执行相应的回调函数处理超时事件
os_get_reltime(&now);
if (!os_reltime_before(&now, &timeout->time)) {
void *eloop_data = timeout->eloop_data;
void *user_data = timeout->user_data;
eloop_timeout_handler handler =
timeout->handler;
eloop_remove_timeout(timeout);
handler(eloop_data, user_data);
}
}
if (res <= 0)
continue;
//处理各个socket的事件
eloop_sock_table_dispatch(&eloop.readers, rfds);
eloop_sock_table_dispatch(&eloop.writers, wfds);
eloop_sock_table_dispatch(&eloop.exceptions, efds);
}
eloop.terminate = 0;
out:
os_free(rfds);
os_free(wfds);
os_free(efds);
return;
}
通过以上代码，我们知道了hostapd实际上是通过select()机制来轮询检查各个socket的状态，一旦发现某个socket描述符可读、可写、或者是意外的话，就会通过eloop_sock_table_dispach函数来调用相应的回调函数去处理相关事件。其实，源代码中还有用poll()机制的实现，他们的原理都差不多，各位有兴趣的读者可以自行查阅。对了，上面的代码提到了eloop_sock_table_dispatch函数来处理各个socket事件，那么它是怎么实现的呢？我们看一下下面的代码：
static void eloop_sock_table_dispatch(struct eloop_sock_table *table,
fd_set *fds)
{
int i;
if (table == NULL || table->table == NULL)
return;
table->changed = 0;
for (i = 0; i < table->count; i++) { //检查socket表中每个描述符是否可用（读、写、意外）
if (FD_ISSET(table->table[i].sock, fds)) {
//当某个socket描述符处于可用状态时，调用相应的回调函数来处理
table->table[i].handler(table->table[i].sock,
table->table[i].eloop_data,
table->table[i].user_data);
if (table->changed)
break;
}
}
}
怎么样？看到了熟悉的FD_ISSET宏了吧？
在eloop_run()中，不光处理了各个socket描述符的事件，还有信号（比如按下Ctrl+C），超时（timeout）等事件的处理。这里不再赘述。到此，读者应该理解了hostapd的event loop工作机制了吧？了解了event loop的工作机制以后，我们就可以对hostapd的功能进行扩展了。比如我做的关于OpenFlow AP项目，我把hostapd和控制器（controller）之间交换数据的socket描述符和对应的回调函数加入到socket描述符表中去，hostapd就可以接收来自控制器的指令，并处理OpenFlow协议了。
下一篇文章将介绍hostapd是如何处理IEEE802.11管理帧的。
hostapd源代码分析（三）：管理帧的收发和处理
这篇文章我来讲解一下hostapd是如何处理IEEE 802.11管理帧的。我们知道，hostapd主要负责管理工作站（station）认证和接入。因此，它只处理管理帧(Management Frame)，并不处理数据帧。802.11的管理帧主要有信标帧(beacon)、探测请求帧（probe request)、探测回应帧（probe response）、请求认证帧（authentication request）、认证回应帧（authentication response）、请求关联帧（association request）和关联回应帧（association response）等。hostapd在初始化的阶段，会将无线网卡转换为AP模式，并且建立监视接口（Monitor Interface，一般是mon.wlan0），这个监视接口主要负责接收802.11管理帧。内核收到管理帧后，就会把它送回用户空间的hostapd来处理。
一、建立监视接口
基于nl80211驱动的hostapd在初始化的时候，会调用位于src/driver/driver_nl80211.c的nl80211_create_monitor_interface来建立监视接口。
drv->monitor_ifidx = nl80211_create_iface(drv, buf, NL80211_IFTYPE_MONITOR, NULL, 0, NULL, NULL, 0); //通过Netlink通知内核新建一个监视接口
监视接口建立以后，通过socket来接收原始帧，并把socket注册到event loop中（关于event loop，请参考《hostapd源代码分析（二）：》）
//建立原始套接字
drv->monitor_sock = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
...
//把原始套接字的描述符和回调函数handle_monitor_read注册到event loop
if (eloop_register_read_sock(drv->monitor_sock, handle_monitor_read, drv, NULL)) {
wpa_printf(MSG_INFO, "nl80211: Could not register monitor read socket");
goto error;
}
二、接收和处理管理帧
当原始套接字接收到802.11管理帧后，会调用handle_monitor_read来进一步处理。handle_monitor_read中，会根据Rx或者Tx标志来调用handle_frame或者handle_tx_callback函数来处理。根据我的理解和分析，一般handle_frame处理“请求”帧，比如probe request帧，authentication request帧，等等；handle_tx_callback一般用来处理“回应”帧，比如，authentication response帧，association response帧等。handle_monitor_read函数的部分代码如下。
len = recv(sock, buf, sizeof(buf), 0); //读取从原始套接字接收的帧
...
while (1) {
ret = ieee80211_radiotap_iterator_next(&iter); //抽取radiotap报头
if (ret == -ENOENT)
break;
if (ret) {
wpa_printf(MSG_INFO, "nl80211: received invalid radiotap frame (%d)", ret);
return;
}
switch (iter.this_arg_index) {
case IEEE80211_RADIOTAP_FLAGS:
if (*iter.this_arg & IEEE80211_RADIOTAP_F_FCS)
len -= 4;
break;
case IEEE80211_RADIOTAP_RX_FLAGS: //接收(Rx)帧（一般是“请求帧”）
rxflags = 1;
break;
case IEEE80211_RADIOTAP_TX_FLAGS: //发送(Tx)帧（一般是“回应帧”）
injected = 1;
failed = le_to_host16((*(uint16_t *) iter.this_arg)) & IEEE80211_RADIOTAP_F_TX_FAIL;
break;
case IEEE80211_RADIOTAP_DATA_RETRIES:
break;
case IEEE80211_RADIOTAP_CHANNEL:
/* TODO: convert from freq/flags to channel number */
break;
case IEEE80211_RADIOTAP_RATE:
datarate = *iter.this_arg * 5;
break;
case IEEE80211_RADIOTAP_DBM_ANTSIGNAL:
ssi_signal = (s8) *iter.this_arg;
break;
}
}
if (rxflags && injected)
return;
if (!injected)
handle_frame(drv, buf + iter._max_length, len - iter._max_length, datarate, ssi_signal); //处理“请求帧”
else
handle_tx_callback(drv->ctx, buf + iter._max_length, len - iter._max_length, !failed); //处理“发送帧”
}
然后，进入handle_frame后，再调用wpa_supplicant_event（位于src/ap/drv_callbacks.c）来进一步处理。对于“请求帧”，会调用hostapd_mgmt_rx（位于src/ap/drv_callbacks.c）。hostapd_mgmt_rx的代码如下：
static int hostapd_mgmt_rx(struct hostapd_data *hapd, struct rx_mgmt *rx_mgmt)
{
struct hostapd_iface *iface = hapd->iface;
const struct ieee80211_hdr *hdr;
const u8 *bssid;
struct hostapd_frame_info fi;
int ret;
hdr = (const struct ieee80211_hdr *) rx_mgmt->frame;
bssid = get_hdr_bssid(hdr, rx_mgmt->frame_len); //获取该帧所属的BSSID
if (bssid == NULL)
return 0;
hapd = get_hapd_bssid(iface, bssid); //根据BSSID获取相应的BSS
if (hapd == NULL) { //相应的BSS不存在，则抛弃不处理。
u16 fc;
fc = le_to_host16(hdr->frame_control);
/*
* Drop frames to unknown BSSIDs except for Beacon frames which
* could be used to update neighbor information.
*/
if (WLAN_FC_GET_TYPE(fc) == WLAN_FC_TYPE_MGMT &&
WLAN_FC_GET_STYPE(fc) == WLAN_FC_STYPE_BEACON)
hapd = iface->bss[0];
else
return 0;
}
os_memset(&fi, 0, sizeof(fi));
fi.datarate = rx_mgmt->datarate;
fi.ssi_signal = rx_mgmt->ssi_signal;
if (hapd == HAPD_BROADCAST) { //广播帧
size_t i;
ret = 0;
//将广播帧发送给每一个BSS
for (i = 0; i < iface->num_bss; i++) {
/* if bss is set, driver will call this function for
* each bss individually. */
if (rx_mgmt->drv_priv &&
(iface->bss[i]->drv_priv != rx_mgmt->drv_priv))
continue;
if (ieee802_11_mgmt(iface->bss[i], rx_mgmt->frame,
rx_mgmt->frame_len, &fi) > 0)
ret = 1;
}
} else //单播帧
ret = ieee802_11_mgmt(hapd, rx_mgmt->frame, rx_mgmt->frame_len,
&fi);
random_add_randomness(&fi, sizeof(fi));
return ret;
}
接下来，继续调用ieee802_11_mgmt（位于src/ap/ieee80211.c），根据具体的帧来执行相应的操作。
AP模式中多重基础服务集（Multi-BSS）下帧的接收
我们知道，AP模式下的无线网卡可以创建多个基础服务集（Base Service Set, BSS），我们可以为每一个BSS赋予一个SSID，也可以为每一个BSS设置不同的加密方式和密码。通过多个创建多个BSS的方式，就可以让同一个无线路由器提供不同的无线上网服务。那么问题来了，当AP接收到一个帧的时候，如何判断这个帧是否属于这个AP呢？我一开始认为，当AP接收到一个帧的时候，驱动程序便会循环检查每一个BSS的BSSID，看看是否有和接收到的帧的BSSID字段一致的BSS——如果有就ACK，否则就drop掉。后来当在我阅读ath9k驱动程序源代码的时候，才发现我的想法太天真了——一个AP会不停的收到许多帧，如果每收到一个帧，就去轮询每个BSS来确定这个帧是否属于这个AP，那效率实在是太低了。原来AR5212或者以上的无线网卡驱动采用了一种叫做“BSSID掩码（BSSID masking）”的方式，来决定是否ACK接收到的帧。
假如我们的无线网卡的MAC地址是0001，并且创建了两个BSS（假设为BSS_1和BSS_2），其BSSID分别为0100和1001，那么BSSID掩码就是这样计算的：
mac = 0001 //无线网卡的MAC为0001
bssid_mask = 1111; //掩码的初始值为1111
bssid_1 = 0100 //BSS_1的BSSID为0100
bssid_2 = 1001 //BSS_2的BSSID为1001
bssid_mask = bssid_mask & ~(mac ^ bssid_1) //BSS_1被创建后的掩码
= 1111 & ~(0001 ^ 0100)
= 1111 & 1010
= 1010
bssid_mask = bssid_mask & ~(mac ^ bssid_2) //然后BSS_2被创建后的掩码
= 1010 & ~(0001 ^ 1001)
= 1010 & 0111
= 0010
即，最后的掩码为0010。意思就是，当接收到一个帧的时候，只需要注意它BSSID字段的倒数第二位。假如这个AP接收到一个帧，它的BSSID字段为0110，因为它的倒数第二位是1，那么这个帧就不属于这个AP，就可以直接drop了。算法如下：
iframe = 0110 //接收到的帧的BSSID字段是0100
allow = (ifame & bssid_mask) == (bssid_mask & mac) ? true : false
= (0110 & 0010) == (0010 & 0001) ? true : false
= 0010 == 0000 ? true : false
= false //这个帧不属于这个AP，直接drop！
再看另一个例子，假如接收到一个帧的BSSID字段为0001，用眼观察，它的倒数第二位是0，那就是属于这个AP的——实际是否如此呢？我们来计算一下：
ifame = 0001 //接收到的帧的BSSID字段是0001
allow = (ifame & bssid_mask) == (bssid_mask & mac) ? true : false
= (0001 & 0010) == (0010 & 0001) ? true : false
= 0000 == 0000 ? true : false
= true //这个帧属于这个AP，ACK它！
的确是这样的——通过BSSID掩码，驱动程序的作者用O(1)的算法秒杀了我之前幼稚又天真的O(n)算法！！
综上所述，每当AP建立一个BSS，便要更新一下BSSID掩码。当只有一个BSS的时候，掩码就是初始掩码1111。（通常MAC地址是48位，那么初始掩码就是ff:ff:ff:ff:ff:ff）掩码的计算方法为
bssid_mask = bssid_mask & ~(mac ^ bssid)
每当接收到一个帧的时候，通过如下的方法来确定这个帧是否属于此AP：
allow = (ifame & bssid_mask == bssid_mask & mac) ? true : false
那么，代码是如何实现的呢？在drivers/net/wireless/ath/ath9k/virtual.c中，有如下代码：
void ath9k_set_bssid_mask(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
{
struct ath_wiphy *aphy = hw->priv;
struct ath_softc *sc = aphy->sc;
struct ath_common *common = ath9k_hw_common(sc->sc_ah);
struct ath9k_vif_iter_data iter_data;
int i;
/*
* Use the hardware MAC address as reference, the hardware uses it
* together with the BSSID mask when matching addresses.
*/
iter_data.hw_macaddr = common->macaddr;
memset(&iter_data.mask, 0xff, ETH_ALEN);
if (vif)
ath9k_vif_iter(&iter_data, vif->addr, vif); //这个函数来计算掩码
/* Get list of all active MAC addresses */
spin_lock_bh(&sc->wiphy_lock);
ieee80211_iterate_active_interfaces_atomic(sc->hw, ath9k_vif_iter,
&iter_data);
for (i = 0; i < sc->num_sec_wiphy; i++) {
if (sc->sec_wiphy[i] == NULL)
continue;
ieee80211_iterate_active_interfaces_atomic(
sc->sec_wiphy[i]->hw, ath9k_vif_iter, &iter_data);
}
spin_unlock_bh(&sc->wiphy_lock);
memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
ath_hw_setbssidmask(common);
}
ath9k_vif_iter是这样的：
static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
{
struct ath9k_vif_iter_data *iter_data = data;
int i;
for (i = 0; i < ETH_ALEN; i++)
iter_data->mask[i] &= ~(iter_data->hw_macaddr[i] ^ mac[i]); //就是上面提到的算法
}
在drivers/net/wireless/ath/ath9k/main.c中，有个ath9k_add_interface函数，这个函数在创建一个BSS的时候会被调用，代码如下：
static int ath9k_add_interface(struct ieee80211_hw *hw,
struct ieee80211_vif *vif)
{
struct ath_wiphy *aphy = hw->priv;
struct ath_softc *sc = aphy->sc;
struct ath_hw *ah = sc->sc_ah;
struct ath_common *common = ath9k_hw_common(ah);
struct ath_vif *avp = (void *)vif->drv_priv;
enum nl80211_iftype ic_opmode = NL80211_IFTYPE_UNSPECIFIED;
int ret = 0;
mutex_lock(&sc->mutex);
switch (vif->type) {
case NL80211_IFTYPE_STATION:
ic_opmode = NL80211_IFTYPE_STATION;
break;
case NL80211_IFTYPE_WDS:
ic_opmode = NL80211_IFTYPE_WDS;
break;
case NL80211_IFTYPE_ADHOC:
case NL80211_IFTYPE_AP:
case NL80211_IFTYPE_MESH_POINT:
if (sc->nbcnvifs >= ATH_BCBUF) {
ret = -ENOBUFS;
goto out;
}
ic_opmode = vif->type;
break;
default:
ath_err(common, "Interface type %d not yet supported\n",
vif->type);
ret = -EOPNOTSUPP;
goto out;
}
ath_dbg(common, ATH_DBG_CONFIG,
"Attach a VIF of type: %d\n", ic_opmode);
/* Set the VIF opmode */
avp->av_opmode = ic_opmode;
avp->av_bslot = -1;
sc->nvifs++;
ath9k_set_bssid_mask(hw, vif); //计算新的BSSID掩码
if (sc->nvifs > 1)
goto out; /* skip global settings for secondary vif */
if (ic_opmode == NL80211_IFTYPE_AP) {
ath9k_hw_set_tsfadjust(ah, 1);
sc->sc_flags |= SC_OP_TSF_RESET;
}
/* Set the device opmode */
ah->opmode = ic_opmode;
/*
* Enable MIB interrupts when there are hardware phy counters.
* Note we only do this (at the moment) for station mode.
*/
if ((vif->type == NL80211_IFTYPE_STATION) ||
(vif->type == NL80211_IFTYPE_ADHOC) ||
(vif->type == NL80211_IFTYPE_MESH_POINT)) {
if (ah->config.enable_ani)
ah->imask |= ATH9K_INT_MIB;
ah->imask |= ATH9K_INT_TSFOOR;
}
ath9k_hw_set_interrupts(ah, ah->imask);
if (vif->type == NL80211_IFTYPE_AP ||
vif->type == NL80211_IFTYPE_ADHOC) {
sc->sc_flags |= SC_OP_ANI_RUN;
ath_start_ani(common);
}
out:
mutex_unlock(&sc->mutex);
return ret;
}
由此可见，驱动程序在每次创建一个BSS——驱动程序的层面上看就是一个网络接口（network interface）——便会更新一下BSSID掩码。
其实，BSSID掩码也是有缺陷的。还拿刚才的例子来说，MAC地址为0001的无线网卡有两个BSS，其BSSID分别为
0100和1001，根据上面的算法，计算的掩码为0010。假如此时收到一个BSSID字段为1100的帧，根据如下算法计算：
allow = (ifame_bssid & bssid_mask) == (bssid_mask & mac) ? true : false
= (1100 & 0010) == (0010 & 0001) ? true : false
= 0000 == 0000 ? true : false
= true
但是，此AP根本不存在BSSID为1100的BSS！假如此时在同一个信道里面，另一个AP恰好存在一个BSSID为1100的BSS的话，那么这两个AP将同时ACK这个帧，其后果就是哪个ACK帧也不可能被客户端接收到——客户端只好重新发送这个帧——从而形成恶性循环。但是除非是管理员故意这么设置，可能性不大——一般没有人会在同一个信道和覆盖范围里面设置多个AP吧。
---------------------
作者：手动阀隧道
来源：CSDN
原文：https://blog.csdn.net/tmwiajd/article/details/43737185
版权声明：本文为博主原创文章，转载请附上博文链接！