1987 lines
45 KiB
C
1987 lines
45 KiB
C
/****************************************************************************
|
|
* drivers/net/wifi_sim.c
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <debug.h>
|
|
#include <errno.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <fcntl.h>
|
|
#include <sys/stat.h>
|
|
#include <netinet/if_ether.h>
|
|
|
|
#include <nuttx/compiler.h>
|
|
#include <nuttx/kmalloc.h>
|
|
#include <nuttx/net/ip.h>
|
|
#include <nuttx/wireless/ieee80211/ieee80211.h>
|
|
#include <nuttx/virtio/virtio.h>
|
|
#include <netpacket/netlink.h>
|
|
#include <nuttx/net/netlink.h>
|
|
|
|
#include <nuttx/net/wifi_sim.h>
|
|
#include <nuttx/fs/fs.h>
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
#define BSS_FILE_NAME "bss"
|
|
#define BSS_FILE_PATH CONFIG_WIFI_SIM_CONFDIR "/" BSS_FILE_NAME
|
|
|
|
#define SSID_MAX_LEN 32
|
|
|
|
#define IEEE80211_CAP_PRIVACY 0x0010
|
|
|
|
/* Maximum number of supported rates (from both Supported Rates and Extended
|
|
* Supported Rates IEs).
|
|
*/
|
|
|
|
#define WLAN_SUPP_RATES_MAX 32
|
|
|
|
#define WLAN_DEFAULT_TXPOWER 20
|
|
|
|
#define LOWERDEV2WIFIDEV(dev) \
|
|
((FAR struct wifi_sim_s *)((FAR struct wifi_sim_lowerhalf_s *)dev)->wifi)
|
|
|
|
#define CHAN2G(freq) \
|
|
{ \
|
|
.band = WLAN_80211_BAND_2GHZ, \
|
|
.center_freq = (freq), \
|
|
}
|
|
|
|
#define CHAN5G(freq) \
|
|
{ \
|
|
.band = WLAN_80211_BAND_5GHZ, \
|
|
.center_freq = (freq), \
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Private Types
|
|
****************************************************************************/
|
|
|
|
enum WLAN_ALG_E
|
|
{
|
|
WLAN_ALG_NONE,
|
|
WLAN_ALG_WEP,
|
|
WLAN_ALG_TKIP,
|
|
WLAN_ALG_CCMP,
|
|
WLAN_ALG_BIP_CMAC_128,
|
|
WLAN_ALG_GCMP,
|
|
WLAN_ALG_SMS4,
|
|
WLAN_ALG_KRK,
|
|
WLAN_ALG_GCMP_256,
|
|
WLAN_ALG_CCMP_256,
|
|
WLAN_ALG_BIP_GMAC_128,
|
|
WLAN_ALG_BIP_GMAC_256,
|
|
WLAN_ALG_BIP_CMAC_256
|
|
};
|
|
|
|
enum WLAN_HW_MODE_E
|
|
{
|
|
WLAN_HW_MODE_IEEE80211B,
|
|
WLAN_HW_MODE_IEEE80211G,
|
|
WLAN_HW_MODE_IEEE80211A,
|
|
WLAN_HW_MODE_IEEE80211AD,
|
|
WLAN_HW_MODE_IEEE80211ANY,
|
|
WLAN_HW_MODES
|
|
};
|
|
|
|
/* enum WLAN_CHAN_WIDTH_E - Channel width definitions */
|
|
|
|
enum WLAN_CHAN_WIDTH_E
|
|
{
|
|
WLAN_CHAN_WIDTH_20_NOHT,
|
|
WLAN_CHAN_WIDTH_20,
|
|
WLAN_CHAN_WIDTH_40,
|
|
WLAN_CHAN_WIDTH_80,
|
|
WLAN_CHAN_WIDTH_80P80,
|
|
WLAN_CHAN_WIDTH_160,
|
|
WLAN_CHAN_WIDTH_2160,
|
|
WLAN_CHAN_WIDTH_4320,
|
|
WLAN_CHAN_WIDTH_6480,
|
|
WLAN_CHAN_WIDTH_8640,
|
|
WLAN_CHAN_WIDTH_320,
|
|
WLAN_CHAN_WIDTH_UNKNOWN
|
|
};
|
|
|
|
enum WLAN_80211_BAND_E
|
|
{
|
|
WLAN_80211_BAND_2GHZ,
|
|
WLAN_80211_BAND_5GHZ,
|
|
WLAN_80211_BAND_6GHZ,
|
|
WLAN_80211_BAND_NUMS
|
|
};
|
|
|
|
enum WLAN_SCAN_STATE_E
|
|
{
|
|
WLAN_SCAN_STATE_SCANNING,
|
|
WLAN_SCAN_STATE_DONE,
|
|
};
|
|
|
|
enum WLAN_STA_STATE_E
|
|
{
|
|
WLAN_STA_STATE_INIT,
|
|
WLAN_STA_STATE_CONNECTING,
|
|
WLAN_STA_STATE_CONNECTED,
|
|
};
|
|
|
|
enum WLAN_STA_CONNERR_E
|
|
{
|
|
WLAN_STA_CONNERR_NO_BSS,
|
|
WLAN_STA_CONNERR_NO_PSK,
|
|
WLAN_STA_CONNERR_WRONG_KEY,
|
|
WLAN_STA_CONNERR_FAILED,
|
|
};
|
|
|
|
/* for scan results */
|
|
|
|
struct iw_scan_result_s
|
|
{
|
|
int total_len;
|
|
int cur_len;
|
|
FAR char *buf; /* iwr->u.data.pointer */
|
|
};
|
|
|
|
/* channel */
|
|
|
|
struct wlan_channel_s
|
|
{
|
|
enum WLAN_80211_BAND_E band;
|
|
uint32_t center_freq;
|
|
};
|
|
|
|
struct wifi_sim_bss_s
|
|
{
|
|
char bssid[ETH_ALEN]; /* bss BSSID */
|
|
uint16_t capability; /* Capability information */
|
|
char ssid[SSID_MAX_LEN + 1]; /* Capability information */
|
|
uint8_t ssid_len; /* the length of ssid */
|
|
int16_t RSSI; /* receive signal strength (in dBm) */
|
|
int8_t phy_noise; /* noise (in dBm) */
|
|
int16_t snr; /* average SNR of during frame reception */
|
|
uint32_t freq; /* 802.11N BSS frequency */
|
|
uint8_t flags; /* flags */
|
|
char password[64]; /* password */
|
|
char security[128]; /* security type */
|
|
};
|
|
|
|
struct wifi_sim_sta_info_s
|
|
{
|
|
uint16_t aid;
|
|
char mac_addr[ETH_ALEN];
|
|
uint16_t capability; /* Capability information */
|
|
int auth_alg;
|
|
uint8_t supported_rates[WLAN_SUPP_RATES_MAX];
|
|
int supported_rates_len;
|
|
uint8_t qosinfo;
|
|
int16_t RSSI; /* receive signal strength (in dBm) */
|
|
uint32_t connected_time; /* units: seconds */
|
|
int16_t deauth_reason;
|
|
int16_t disassoc_reason;
|
|
};
|
|
|
|
struct wifi_sim_s
|
|
{
|
|
FAR struct netdev_lowerhalf_s *lower;
|
|
|
|
char ssid[SSID_MAX_LEN + 1];
|
|
char bssid[ETH_ALEN];
|
|
uint8_t mode; /* IW_MODE_INFRA/ IW_MODE_MASTER */
|
|
enum WLAN_HW_MODE_E hw_mode; /* for hw mode */
|
|
enum WLAN_CHAN_WIDTH_E band;
|
|
uint16_t channel;
|
|
uint32_t freq;
|
|
char password[64];
|
|
int key_mgmt;
|
|
int proto;
|
|
int auth_alg;
|
|
int pairwise_chiper;
|
|
int group_cipher;
|
|
|
|
uint32_t bitrate;
|
|
int32_t txpower;
|
|
char country[4];
|
|
int8_t sensitivity;
|
|
|
|
bool psk_flag; /* for psk, 0: unset, 1: set */
|
|
uint8_t ssid_flag; /* for ssid, 0: unset, 1: set ssid
|
|
* 2: set bssid */
|
|
enum WLAN_STA_STATE_E state;
|
|
enum WLAN_SCAN_STATE_E scan_state;
|
|
uint16_t status_code; /* status code */
|
|
uint16_t reason_code; /* deauth and disassoc reason */
|
|
uint16_t error_code; /* connect error reason */
|
|
|
|
FAR struct wifi_sim_bss_s *connected_ap; /* for sta mode */
|
|
};
|
|
|
|
/* for wireless event */
|
|
|
|
struct wireless_event_s
|
|
{
|
|
struct nlmsghdr hdr; /* netlink message header */
|
|
struct ifinfomsg iface; /* interface info */
|
|
|
|
struct rtattr attrevent; /* IFLA_WIRELESS */
|
|
struct iw_event event; /* wireless event */
|
|
};
|
|
|
|
struct wireless_event_list_s
|
|
{
|
|
sq_entry_t flink;
|
|
struct wireless_event_s payload;
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Function Prototypes
|
|
****************************************************************************/
|
|
|
|
static int wifidriver_connect(FAR struct netdev_lowerhalf_s *dev);
|
|
static int wifidriver_disconnect(FAR struct netdev_lowerhalf_s *dev);
|
|
static int wifidriver_essid(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_bssid(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_passwd(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_mode(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_auth(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_freq(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_bitrate(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_txpower(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_country(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_sensitivity(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_scan(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set);
|
|
static int wifidriver_range(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr);
|
|
|
|
static int wifidriver_get_bssinfo(FAR struct wifi_sim_bss_s *bss_info,
|
|
FAR char *buf, int len);
|
|
static int wifidriver_start_disconnect(FAR struct wifi_sim_s *wifidev);
|
|
|
|
/****************************************************************************
|
|
* Private Data
|
|
****************************************************************************/
|
|
|
|
static const struct wlan_channel_s wifi_sim_channels_2ghz[] =
|
|
{
|
|
CHAN2G(2412), /* Channel 1 */
|
|
CHAN2G(2417), /* Channel 2 */
|
|
CHAN2G(2422), /* Channel 3 */
|
|
CHAN2G(2427), /* Channel 4 */
|
|
CHAN2G(2432), /* Channel 5 */
|
|
CHAN2G(2437), /* Channel 6 */
|
|
CHAN2G(2442), /* Channel 7 */
|
|
CHAN2G(2447), /* Channel 8 */
|
|
CHAN2G(2452), /* Channel 9 */
|
|
CHAN2G(2457), /* Channel 10 */
|
|
CHAN2G(2462), /* Channel 11 */
|
|
CHAN2G(2467), /* Channel 12 */
|
|
CHAN2G(2472), /* Channel 13 */
|
|
CHAN2G(2484), /* Channel 14 */
|
|
};
|
|
|
|
static const struct wlan_channel_s wifi_sim_channels_5ghz[] =
|
|
{
|
|
CHAN5G(5180), /* Channel 36 */
|
|
CHAN5G(5200), /* Channel 40 */
|
|
CHAN5G(5220), /* Channel 44 */
|
|
CHAN5G(5240), /* Channel 48 */
|
|
CHAN5G(5260), /* Channel 52 */
|
|
CHAN5G(5280), /* Channel 56 */
|
|
CHAN5G(5300), /* Channel 60 */
|
|
CHAN5G(5320), /* Channel 64 */
|
|
CHAN5G(5745), /* Channel 149 */
|
|
CHAN5G(5765), /* Channel 153 */
|
|
CHAN5G(5785), /* Channel 157 */
|
|
CHAN5G(5805), /* Channel 161 */
|
|
CHAN5G(5825), /* Channel 165 */
|
|
};
|
|
|
|
static const struct wireless_ops_s g_iw_ops =
|
|
{
|
|
wifidriver_connect,
|
|
wifidriver_disconnect,
|
|
wifidriver_essid,
|
|
wifidriver_bssid,
|
|
wifidriver_passwd,
|
|
wifidriver_mode,
|
|
wifidriver_auth,
|
|
wifidriver_freq,
|
|
wifidriver_bitrate,
|
|
wifidriver_txpower,
|
|
wifidriver_country,
|
|
wifidriver_sensitivity,
|
|
wifidriver_scan,
|
|
wifidriver_range
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/* utils */
|
|
|
|
static int mac_addr_a2n(FAR unsigned char *mac_addr, FAR char *arg)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ETH_ALEN ; i++)
|
|
{
|
|
int temp;
|
|
FAR char *cp = strchr(arg, ':');
|
|
|
|
if (cp)
|
|
{
|
|
*cp = 0;
|
|
cp++;
|
|
}
|
|
|
|
if (sscanf(arg, "%x", &temp) != 1)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (temp < 0 || temp > 255)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
mac_addr[i] = temp;
|
|
if (!cp)
|
|
{
|
|
break;
|
|
}
|
|
|
|
arg = cp;
|
|
}
|
|
|
|
if (i < ETH_ALEN - 1)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static void mac_addr_n2a(FAR char *mac_addr, FAR unsigned char *arg)
|
|
{
|
|
int i;
|
|
int l;
|
|
|
|
for (l = 0, i = 0; i < ETH_ALEN; i++)
|
|
{
|
|
if (i == 0)
|
|
{
|
|
sprintf(mac_addr + l, "%02x", arg[i]);
|
|
l += 2;
|
|
}
|
|
else
|
|
{
|
|
sprintf(mac_addr + l, ":%02x", arg[i]);
|
|
l += 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* wifi interfaces */
|
|
|
|
static int wifi_send_event(FAR struct wifi_sim_s *wifidev,
|
|
unsigned int cmd, FAR union iwreq_data *wrqu)
|
|
{
|
|
FAR struct net_driver_s *dev = &wifidev->lower->netdev;
|
|
FAR struct wireless_event_list_s *alloc;
|
|
FAR struct wireless_event_s *wev;
|
|
|
|
DEBUGASSERT(dev != NULL);
|
|
|
|
int up = IFF_IS_UP(dev->d_flags);
|
|
|
|
/* Allocate the response buffer */
|
|
|
|
alloc = (FAR struct wireless_event_list_s *)
|
|
kmm_zalloc(RTA_SPACE(sizeof(struct wireless_event_list_s)));
|
|
if (alloc == NULL)
|
|
{
|
|
nerr("ERROR: Failed to allocate wifi event buffer.\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* Initialize the response buffer */
|
|
|
|
wev = &alloc->payload;
|
|
|
|
wev->hdr.nlmsg_len = sizeof(struct wireless_event_s);
|
|
wev->hdr.nlmsg_type = up ? RTM_NEWLINK : RTM_DELLINK;
|
|
wev->hdr.nlmsg_flags = 0;
|
|
wev->hdr.nlmsg_seq = 0;
|
|
wev->hdr.nlmsg_pid = 0;
|
|
|
|
wev->iface.ifi_family = AF_UNSPEC;
|
|
wev->iface.ifi_type = ARPHRD_IEEE80211;
|
|
#ifdef CONFIG_NETDEV_IFINDEX
|
|
wev->iface.ifi_index = dev->d_ifindex;
|
|
#endif
|
|
wev->iface.ifi_flags = dev->d_flags;
|
|
wev->iface.ifi_change = 0;
|
|
|
|
/* add wireless event info */
|
|
|
|
wev->attrevent.rta_len = RTA_SPACE(sizeof(struct iw_event));
|
|
wev->attrevent.rta_type = IFLA_WIRELESS;
|
|
wev->event.len = sizeof(union iwreq_data);
|
|
wev->event.cmd = cmd;
|
|
|
|
memset(&wev->event.u, 0, sizeof(union iwreq_data));
|
|
memcpy(&wev->event.u, ((FAR char *) wrqu), sizeof(union iwreq_data));
|
|
|
|
netlink_add_broadcast(RTNLGRP_LINK,
|
|
(FAR struct netlink_response_s *)alloc);
|
|
return OK;
|
|
}
|
|
|
|
static int read_bss_config(FAR char *buf, size_t len, FAR char *path)
|
|
{
|
|
struct file filep;
|
|
int ret;
|
|
|
|
ret = file_open(&filep, path, O_RDONLY);
|
|
if (ret < 0)
|
|
{
|
|
nerr("open error");
|
|
return ret;
|
|
}
|
|
|
|
ret = file_read(&filep, buf, len);
|
|
if (ret == len)
|
|
{
|
|
ret = -E2BIG;
|
|
}
|
|
else if (ret > 0)
|
|
{
|
|
buf[ret] = '\0';
|
|
ninfo("content: %s", buf);
|
|
}
|
|
|
|
file_close(&filep);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#if 0
|
|
uint32_t wifi_chan_to_freq_mhz(int chan, enum WLAN_80211_BAND_E band)
|
|
{
|
|
/* see 802.11 17.3.8.3.2 and Annex J
|
|
* there are overlapping channel numbers in 5GHz and 2GHz bands
|
|
*/
|
|
|
|
if (chan <= 0)
|
|
{
|
|
return 0; /* not supported */
|
|
}
|
|
|
|
switch (band)
|
|
{
|
|
case WLAN_80211_BAND_2GHZ:
|
|
if (chan == 14)
|
|
{
|
|
return (2484);
|
|
}
|
|
else if (chan < 14)
|
|
{
|
|
return (2407 + chan * 5);
|
|
}
|
|
break;
|
|
case WLAN_80211_BAND_5GHZ:
|
|
if (chan >= 182 && chan <= 196)
|
|
{
|
|
return (4000 + chan * 5);
|
|
}
|
|
else
|
|
{
|
|
return (5000 + chan * 5);
|
|
}
|
|
break;
|
|
case WLAN_80211_BAND_6GHZ:
|
|
|
|
/* see 802.11ax D6.1 27.3.23.2 */
|
|
|
|
if (chan == 2)
|
|
{
|
|
return (5935);
|
|
}
|
|
|
|
if (chan <= 233)
|
|
{
|
|
return (5950 + chan * 5);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0; /* not supported */
|
|
}
|
|
#endif
|
|
|
|
static int freq_to_channel(uint16_t freq)
|
|
{
|
|
int channel = 0;
|
|
|
|
/* If the freq is a valid channel, we think that
|
|
* user wants to directly configure the channel.
|
|
*/
|
|
|
|
if ((freq >= 1 && freq <= 14) ||
|
|
(freq >= 36 && freq <= 165) ||
|
|
(freq >= 182 && freq <= 196))
|
|
{
|
|
channel = freq;
|
|
return channel;
|
|
}
|
|
|
|
if (freq >= 2412 && freq <= 2484)
|
|
{
|
|
if (freq == 2484)
|
|
{
|
|
channel = 14;
|
|
}
|
|
else
|
|
{
|
|
channel = freq - 2407;
|
|
if (channel % 5)
|
|
{
|
|
return OK;
|
|
}
|
|
|
|
channel /= 5;
|
|
}
|
|
|
|
return channel;
|
|
}
|
|
|
|
if (freq >= 5005 && freq < 5900)
|
|
{
|
|
if (freq % 5)
|
|
{
|
|
return OK;
|
|
}
|
|
|
|
channel = (freq - 5000) / 5;
|
|
return channel;
|
|
}
|
|
|
|
if (freq >= 4905 && freq < 5000)
|
|
{
|
|
if (freq % 5)
|
|
{
|
|
return OK;
|
|
}
|
|
|
|
channel = (freq - 4000) / 5;
|
|
return channel;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static FAR const char *get_cipherstr(int cipher)
|
|
{
|
|
switch (cipher)
|
|
{
|
|
case IW_AUTH_CIPHER_NONE:
|
|
return "NONE";
|
|
|
|
case IW_AUTH_CIPHER_WEP40:
|
|
return "WEP40";
|
|
|
|
case IW_AUTH_CIPHER_WEP104:
|
|
return "WEP104";
|
|
|
|
case IW_AUTH_CIPHER_TKIP:
|
|
return "TKIP";
|
|
|
|
case IW_AUTH_CIPHER_CCMP:
|
|
return "CCMP";
|
|
|
|
case IW_AUTH_CIPHER_AES_CMAC:
|
|
return "AES-128-CMAC";
|
|
|
|
default:
|
|
nerr("ERROR: Failed to transfer wifi cipher: %d", cipher);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static FAR const char *get_authstr(int auth)
|
|
{
|
|
switch (auth)
|
|
{
|
|
case IW_AUTH_WPA_VERSION_DISABLED:
|
|
return NULL;
|
|
|
|
case IW_AUTH_WPA_VERSION_WPA:
|
|
return "WPA";
|
|
|
|
case IW_AUTH_WPA_VERSION_WPA2:
|
|
return "WPA2";
|
|
default:
|
|
nerr("ERROR: Failed to transfer wifi auth: %d", auth);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* implement iw_ops */
|
|
|
|
static FAR struct wifi_sim_bss_s *select_bss(FAR struct wifi_sim_s *sta,
|
|
FAR char *bss_buf)
|
|
{
|
|
char bss[256];
|
|
FAR char *s;
|
|
FAR char *p;
|
|
struct wifi_sim_bss_s bss_info;
|
|
FAR struct wifi_sim_bss_s *sbss = NULL;
|
|
bool bss_found = false;
|
|
|
|
for (p = bss_buf; *p != '\0'; p++)
|
|
{
|
|
s = p;
|
|
while (*p != '\n')
|
|
{
|
|
p++;
|
|
}
|
|
|
|
memset(bss, 0, sizeof(bss));
|
|
memcpy(bss, s, p - s + 1);
|
|
wifidriver_get_bssinfo(&bss_info, bss, strlen(bss));
|
|
|
|
/* compare bssid or essid, and security */
|
|
|
|
if ((sta->ssid_flag == 2 && !memcmp(sta->bssid, bss_info.bssid, 6)) ||
|
|
(sta->ssid_flag == 1 && !memcmp(sta->ssid, bss_info.ssid, 32)))
|
|
{
|
|
/* cmp security */
|
|
|
|
if (sta->psk_flag == 0)
|
|
{
|
|
if (!strstr(bss_info.security, "WPA") &&
|
|
!strstr(bss_info.security, "WEP"))
|
|
{
|
|
bss_found = true;
|
|
}
|
|
else
|
|
{
|
|
nerr("security doesn't match");
|
|
}
|
|
|
|
break;
|
|
}
|
|
else if (get_cipherstr(sta->pairwise_chiper) &&
|
|
strstr(bss_info.security,
|
|
get_cipherstr(sta->pairwise_chiper)))
|
|
{
|
|
bss_found = true;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
nerr("security doesn't match");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bss_found)
|
|
{
|
|
sbss = malloc(sizeof(struct wifi_sim_bss_s));
|
|
if (sbss == NULL)
|
|
{
|
|
nerr("select bss malloc failed!");
|
|
return NULL;
|
|
}
|
|
|
|
memcpy(sbss, &bss_info, sizeof(struct wifi_sim_bss_s));
|
|
}
|
|
else
|
|
{
|
|
nerr("No BSS match.");
|
|
}
|
|
|
|
return sbss;
|
|
}
|
|
|
|
static int verify_password(FAR struct wifi_sim_s *sta,
|
|
FAR struct wifi_sim_bss_s *bss)
|
|
{
|
|
int ret = ERROR;
|
|
|
|
if (sta->psk_flag == 0)
|
|
{
|
|
ret = OK;
|
|
}
|
|
else if (!strncmp(sta->password, bss->password, sizeof(sta->password)))
|
|
{
|
|
ret = OK;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int get_bss_from_file(FAR char **rbuf)
|
|
{
|
|
int ret;
|
|
int size = 4096;
|
|
FAR char *p;
|
|
|
|
*rbuf = malloc(size * sizeof(char));
|
|
if (*rbuf == NULL)
|
|
{
|
|
nerr("malloc failed!\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
redo:
|
|
ret = read_bss_config(*rbuf, size, BSS_FILE_PATH);
|
|
if (ret == -E2BIG)
|
|
{
|
|
size += 1024;
|
|
p = realloc(*rbuf, size);
|
|
if (p == NULL)
|
|
{
|
|
nerr("read bss faied in realloc!\n");
|
|
free(*rbuf);
|
|
*rbuf = NULL;
|
|
return -ENOMEM;
|
|
}
|
|
|
|
*rbuf = p;
|
|
goto redo;
|
|
}
|
|
else if (ret < 0)
|
|
{
|
|
nerr("read bss failed\n");
|
|
return ret;
|
|
}
|
|
|
|
(*rbuf)[ret] = '\0';
|
|
|
|
return ret;
|
|
}
|
|
|
|
static bool wifidriver_sta_is_connected(FAR struct wifi_sim_s *wifidev)
|
|
{
|
|
return (wifidev->state == WLAN_STA_STATE_CONNECTED);
|
|
}
|
|
|
|
static int wifidriver_start_connect(FAR struct wifi_sim_s *wifidev)
|
|
{
|
|
int ret;
|
|
FAR char *bss_buf = NULL;
|
|
FAR struct wifi_sim_bss_s *bss_info;
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
/* If wlan is connected, should be disconnect before connectting. */
|
|
|
|
/* 1. check and disconnect */
|
|
|
|
if (wifidev->state == WLAN_STA_STATE_CONNECTED)
|
|
{
|
|
wifidriver_start_disconnect(wifidev);
|
|
wifidev->state = WLAN_STA_STATE_CONNECTING;
|
|
}
|
|
|
|
/* 2. get_bss, match (bssid/essid, security) */
|
|
|
|
ret = get_bss_from_file(&bss_buf);
|
|
if (ret < 0 || bss_buf == NULL)
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
bss_info = select_bss(wifidev, bss_buf);
|
|
if (bss_info == NULL)
|
|
{
|
|
nerr("select no bss.");
|
|
wifidev->error_code = WLAN_STA_CONNERR_NO_BSS;
|
|
|
|
ret = ERROR;
|
|
goto error;
|
|
}
|
|
|
|
/* 3. verify the password and connect to the bss */
|
|
|
|
ret = verify_password(wifidev, bss_info);
|
|
if (ret == OK)
|
|
{
|
|
union iwreq_data wrqu;
|
|
|
|
wifidev->state = WLAN_STA_STATE_CONNECTED;
|
|
wifidev->status_code = WLAN_STATUS_SUCCESS;
|
|
wifidev->connected_ap = bss_info;
|
|
|
|
memset(&wrqu, 0, sizeof(wrqu));
|
|
memcpy(wrqu.ap_addr.sa_data, bss_info->bssid, ETH_ALEN);
|
|
wifi_send_event(wifidev, SIOCGIWAP, &wrqu);
|
|
|
|
/* If connect the AP with the bssid, copy the essid from bss */
|
|
|
|
if (wifidev->ssid_flag == 2)
|
|
{
|
|
memcpy(wifidev->ssid, bss_info->ssid,
|
|
strlen(bss_info->ssid));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wifidev->reason_code = WLAN_REASON_DEAUTH_LEAVING;
|
|
wifidev->error_code = WLAN_STA_CONNERR_WRONG_KEY;
|
|
free(bss_info);
|
|
|
|
ret = WLAN_REASON_CIPHER_SUITE_REJECTED;
|
|
}
|
|
|
|
error:
|
|
if (bss_buf)
|
|
{
|
|
free(bss_buf);
|
|
}
|
|
|
|
if (ret != OK)
|
|
{
|
|
wifidev->state = WLAN_STA_STATE_INIT;
|
|
}
|
|
|
|
wifidev->ssid_flag = 0;
|
|
|
|
/* Enshure that the default is non-encrypted. */
|
|
|
|
if (wifidev->psk_flag)
|
|
{
|
|
wifidev->psk_flag = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
default:
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_start_disconnect(FAR struct wifi_sim_s *wifidev)
|
|
{
|
|
union iwreq_data wrqu;
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
if (wifidev->state == WLAN_STA_STATE_CONNECTED)
|
|
{
|
|
/* free the connected_ap */
|
|
|
|
free(wifidev->connected_ap);
|
|
|
|
memset(&wrqu, 0, sizeof(wrqu));
|
|
wrqu.ap_addr.sa_family = ARPHRD_ETHER;
|
|
wifi_send_event(wifidev, SIOCGIWAP, &wrqu);
|
|
}
|
|
|
|
netdev_lower_carrier_off(wifidev->lower);
|
|
|
|
if (wifidev->psk_flag == 0)
|
|
{
|
|
memset(wifidev->password, 0, sizeof(wifidev->password));
|
|
wifidev->pairwise_chiper = IW_AUTH_CIPHER_NONE;
|
|
}
|
|
|
|
wifidev->state = WLAN_STA_STATE_INIT;
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_get_mode(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
case IW_MODE_MASTER:
|
|
{
|
|
pwrq->u.mode = wifidev->mode;
|
|
ninfo("get %s mode", wifidev->lower->netdev.d_ifname);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_set_mode(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (pwrq->u.mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
case IW_MODE_MASTER:
|
|
{
|
|
wifidev->mode = pwrq->u.mode;
|
|
|
|
/* default country code CN */
|
|
|
|
memcpy(wifidev->country, "CN", 2);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_set_country(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
case IW_MODE_MASTER:
|
|
{
|
|
memcpy(wifidev->country, pwrq->u.data.pointer,
|
|
pwrq->u.data.length);
|
|
ninfo("set country is %s\n", wifidev->country);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_get_country(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
case IW_MODE_MASTER:
|
|
{
|
|
pwrq->u.data.length = strlen(wifidev->country);
|
|
memcpy(pwrq->u.data.pointer, wifidev->country,
|
|
pwrq->u.data.length);
|
|
ninfo("set country is %s\n", wifidev->country);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_get_sensitivity(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
case IW_MODE_MASTER:
|
|
{
|
|
if (wifidriver_sta_is_connected(wifidev))
|
|
{
|
|
pwrq->u.sens.value = -wifidev->connected_ap->RSSI;
|
|
}
|
|
|
|
ninfo("get rssi is %" PRId32 "\n", pwrq->u.sens.value);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
int wifidriver_set_freq(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
int ret;
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
case IW_MODE_MASTER:
|
|
{
|
|
ret = freq_to_channel(pwrq->u.freq.m);
|
|
if (ret > 0)
|
|
{
|
|
wifidev->channel = ret;
|
|
wifidev->freq = pwrq->u.freq.m;
|
|
ninfo("set channel is %d\n", ret);
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_get_freq(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
if (wifidriver_sta_is_connected(wifidev))
|
|
{
|
|
pwrq->u.freq.flags = IW_FREQ_FIXED;
|
|
pwrq->u.freq.e = 0;
|
|
pwrq->u.freq.m = wifidev->connected_ap->freq;
|
|
}
|
|
else
|
|
{
|
|
pwrq->u.freq.flags = IW_FREQ_AUTO;
|
|
pwrq->u.freq.e = 0;
|
|
pwrq->u.freq.m = 2412;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
{
|
|
pwrq->u.freq.flags = IW_FREQ_FIXED;
|
|
pwrq->u.freq.e = 0;
|
|
pwrq->u.freq.m = wifidev->freq;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
int wifidriver_set_txpower(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
int ret = OK;
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
case IW_MODE_MASTER:
|
|
wifidev->txpower = pwrq->u.txpower.value;
|
|
break;
|
|
|
|
default:
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_get_txpower(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
pwrq->u.txpower.value = wifidev->txpower ? wifidev->txpower :
|
|
WLAN_DEFAULT_TXPOWER;
|
|
|
|
pwrq->u.txpower.fixed = 0;
|
|
pwrq->u.txpower.disabled = 0;
|
|
pwrq->u.txpower.flags = IW_TXPOW_DBM;
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
break;
|
|
default:
|
|
return -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_get_bitrate(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
if (wifidev->state != WLAN_STA_STATE_CONNECTED)
|
|
{
|
|
pwrq->u.bitrate.fixed = IW_FREQ_AUTO;
|
|
}
|
|
else
|
|
{
|
|
pwrq->u.bitrate.fixed = IW_FREQ_FIXED;
|
|
|
|
/* default 2streams 40MHz */
|
|
|
|
pwrq->u.bitrate.value = 150;
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
default:
|
|
return -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_get_range(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
int k;
|
|
int i;
|
|
FAR struct iw_range *range = (FAR struct iw_range *)pwrq->u.data.pointer;
|
|
|
|
/* default in china. */
|
|
|
|
/* Add 2.4G channel */
|
|
|
|
range->num_frequency = nitems(wifi_sim_channels_2ghz);
|
|
for (k = 1; k <= range->num_frequency; k++)
|
|
{
|
|
range->freq[k - 1].i = k;
|
|
range->freq[k - 1].e = 0;
|
|
range->freq[k - 1].m = wifi_sim_channels_2ghz[k - 1].center_freq;
|
|
}
|
|
|
|
/* Add 5GHz channels */
|
|
|
|
range->num_frequency += nitems(wifi_sim_channels_5ghz);
|
|
for (i = 0; k <= range->num_frequency; k++)
|
|
{
|
|
range->freq[k - 1].i = k;
|
|
range->freq[k - 1].e = 0;
|
|
range->freq[k - 1].m = wifi_sim_channels_5ghz[i++].center_freq;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_start_scan(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
wifidev->scan_state = WLAN_SCAN_STATE_SCANNING;
|
|
ninfo("scan %s\n", BSS_FILE_PATH);
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
default:
|
|
return -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int copy_scan_results(FAR struct iw_scan_result_s *scan_req,
|
|
FAR struct wifi_sim_bss_s *info)
|
|
{
|
|
int need_len;
|
|
FAR char *pointer;
|
|
FAR struct iw_event *iwe;
|
|
|
|
need_len = IW_EV_LEN(ap_addr) + IW_EV_LEN(qual) +
|
|
IW_EV_LEN(freq) + IW_EV_LEN(data) + IW_EV_LEN(essid);
|
|
|
|
if (scan_req->cur_len + need_len > scan_req->total_len)
|
|
{
|
|
scan_req->cur_len += need_len;
|
|
return -E2BIG;
|
|
}
|
|
|
|
/* Copy scan result */
|
|
|
|
pointer = scan_req->buf + scan_req->cur_len;
|
|
|
|
/* 1.Copy BSSID */
|
|
|
|
iwe = (FAR struct iw_event *)pointer;
|
|
iwe->cmd = SIOCGIWAP;
|
|
iwe->u.ap_addr.sa_family = ARPHRD_ETHER;
|
|
memcpy(&iwe->u.ap_addr.sa_data, info->bssid, IFHWADDRLEN);
|
|
iwe->len = IW_EV_LEN(ap_addr);
|
|
pointer += iwe->len;
|
|
|
|
/* 2.Copy ESSID */
|
|
|
|
iwe = (FAR struct iw_event *)pointer;
|
|
iwe->cmd = SIOCGIWESSID;
|
|
iwe->u.essid.flags = 0;
|
|
iwe->u.essid.length = MIN(info->ssid_len, 32);
|
|
iwe->u.essid.pointer = (FAR void *)sizeof(iwe->u.essid);
|
|
memcpy(&iwe->u.essid + 1, info->ssid, iwe->u.essid.length);
|
|
iwe->len = IW_EV_LEN(essid) + ((iwe->u.essid.length + 3) & ~3);
|
|
pointer += iwe->len;
|
|
|
|
/* 3.Copy link quality info */
|
|
|
|
iwe = (FAR struct iw_event *)pointer;
|
|
iwe->cmd = IWEVQUAL;
|
|
iwe->u.qual.qual = info->snr;
|
|
iwe->u.qual.level = info->RSSI;
|
|
iwe->u.qual.noise = info->phy_noise;
|
|
iwe->u.qual.updated = IW_QUAL_DBM | IW_QUAL_ALL_UPDATED;
|
|
iwe->len = IW_EV_LEN(qual);
|
|
pointer += iwe->len;
|
|
|
|
/* 4.Copy AP control channel */
|
|
|
|
iwe = (FAR struct iw_event *)pointer;
|
|
iwe->cmd = SIOCGIWFREQ;
|
|
iwe->u.freq.e = -1;
|
|
iwe->u.freq.m = info->freq * 10;
|
|
iwe->len = IW_EV_LEN(freq);
|
|
pointer += iwe->len;
|
|
|
|
/* 5.Copy AP encryption mode */
|
|
|
|
iwe = (FAR struct iw_event *)pointer;
|
|
iwe->cmd = SIOCGIWENCODE;
|
|
iwe->u.data.flags = info->capability & IEEE80211_CAP_PRIVACY ?
|
|
IW_ENCODE_ENABLED | IW_ENCODE_NOKEY :
|
|
IW_ENCODE_DISABLED;
|
|
iwe->u.data.length = 0;
|
|
iwe->u.essid.pointer = NULL;
|
|
iwe->len = IW_EV_LEN(data);
|
|
pointer += iwe->len;
|
|
|
|
scan_req->cur_len = pointer - scan_req->buf;
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_get_bssinfo(FAR struct wifi_sim_bss_s *bss_info,
|
|
FAR char *buf, int len)
|
|
{
|
|
unsigned char bssid[ETH_ALEN];
|
|
char str[128];
|
|
FAR char *p = NULL;
|
|
FAR char *s = NULL;
|
|
int i = 0;
|
|
|
|
memset(bss_info, 0, sizeof(*bss_info));
|
|
for (i = 0, p = buf; p - buf < len; p++, i++)
|
|
{
|
|
ninfo(" var_idx%d: ", i);
|
|
s = p;
|
|
while (*p != '\n' && *p != ',' && *p != '\0')
|
|
{
|
|
p++;
|
|
}
|
|
|
|
memset(str, 0, sizeof(str));
|
|
memcpy(str, s, p - s);
|
|
ninfo("%s", str);
|
|
|
|
switch (i)
|
|
{
|
|
case 0:
|
|
{
|
|
/* bssid */
|
|
|
|
mac_addr_a2n(bssid, str);
|
|
memcpy(bss_info->bssid, bssid, IFHWADDRLEN);
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
{
|
|
/* freq */
|
|
|
|
bss_info->freq = atoi(str);
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
/* signal */
|
|
|
|
bss_info->RSSI = atoi(str);
|
|
}
|
|
break;
|
|
|
|
case 3:
|
|
{
|
|
/* security */
|
|
|
|
bss_info->capability |= strlen(str) > strlen("[ESS]") ?
|
|
IEEE80211_CAP_PRIVACY : 0x01;
|
|
memcpy(bss_info->security, str, p - s);
|
|
}
|
|
break;
|
|
|
|
case 4:
|
|
{
|
|
/* ssid */
|
|
|
|
memcpy(bss_info->ssid, str, p - s);
|
|
bss_info->ssid_len = p - s;
|
|
}
|
|
break;
|
|
|
|
case 5:
|
|
{
|
|
/* password */
|
|
|
|
memcpy(bss_info->password, str, p - s);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
ninfo("\n");
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int get_scan_results(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iw_scan_result_s *scan_reqs)
|
|
{
|
|
int ret;
|
|
FAR char *rbuf;
|
|
FAR char *p;
|
|
FAR char *s;
|
|
struct wifi_sim_bss_s bss_info;
|
|
|
|
ret = get_bss_from_file(&rbuf);
|
|
if (ret < 0)
|
|
{
|
|
if (rbuf)
|
|
{
|
|
free(rbuf);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
ret = -EAGAIN;
|
|
for (p = rbuf; *p != '\0'; p++)
|
|
{
|
|
s = p;
|
|
while (*p != '\n')
|
|
{
|
|
p++;
|
|
}
|
|
|
|
wifidriver_get_bssinfo(&bss_info, s, p - s + 1);
|
|
ret = copy_scan_results(scan_reqs, &bss_info);
|
|
if (ret < 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
free(rbuf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_scan_result(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
struct iw_scan_result_s scan_req;
|
|
int ret = 0;
|
|
|
|
if (wifidev->mode == IW_MODE_MASTER)
|
|
{
|
|
return OK;
|
|
}
|
|
else if (wifidev->mode == IW_MODE_INFRA)
|
|
{
|
|
if (wifidev->scan_state == WLAN_SCAN_STATE_SCANNING)
|
|
{
|
|
wifidev->scan_state = WLAN_SCAN_STATE_DONE;
|
|
return -EAGAIN;
|
|
}
|
|
|
|
scan_req.buf = pwrq->u.data.pointer;
|
|
scan_req.total_len = pwrq->u.data.length;
|
|
scan_req.cur_len = 0;
|
|
|
|
ret = get_scan_results(wifidev, &scan_req);
|
|
|
|
pwrq->u.data.length = scan_req.cur_len;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_set_essid(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
case IW_MODE_MASTER:
|
|
{
|
|
memset(wifidev->ssid, 0, sizeof(wifidev->ssid));
|
|
memcpy(wifidev->ssid, pwrq->u.essid.pointer, pwrq->u.essid.length);
|
|
wifidev->ssid_flag = 1;
|
|
ninfo("set essid = %s\n", wifidev->ssid);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_get_essid(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
FAR struct iw_point *essid = &pwrq->u.essid;
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
/* get essid */
|
|
|
|
pwrq->u.essid.length = strlen(wifidev->ssid);
|
|
memcpy(pwrq->u.essid.pointer, wifidev->ssid, pwrq->u.essid.length);
|
|
|
|
ninfo("get essid = %s\n", wifidev->ssid);
|
|
|
|
/* get state */
|
|
|
|
if (wifidev->state == WLAN_STA_STATE_CONNECTED)
|
|
{
|
|
essid->flags = IW_ESSID_ON;
|
|
}
|
|
else
|
|
{
|
|
essid->flags = IW_ESSID_OFF;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_set_bssid(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
FAR struct sockaddr *sockaddr = &pwrq->u.ap_addr;
|
|
FAR unsigned char *pdata = (FAR unsigned char *)sockaddr->sa_data;
|
|
char bssid_str[20];
|
|
int ret;
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
memcpy(wifidev->bssid, pdata, ETH_ALEN);
|
|
mac_addr_n2a(bssid_str, pdata);
|
|
ninfo("set bssid = %s\n", bssid_str);
|
|
|
|
wifidev->ssid_flag = 2;
|
|
ret = OK;
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
ret = -ENOSYS;
|
|
break;
|
|
|
|
default:
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_get_bssid(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
FAR struct sockaddr *sockaddr = &pwrq->u.ap_addr;
|
|
FAR unsigned char *pdata = (FAR unsigned char *)sockaddr->sa_data;
|
|
int ret;
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
if (wifidriver_sta_is_connected(wifidev))
|
|
{
|
|
memcpy(pdata, wifidev->connected_ap->bssid, ETH_ALEN);
|
|
ret = OK;
|
|
}
|
|
else
|
|
{
|
|
ret = -ENOTTY;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
ret = -ENOSYS;
|
|
break;
|
|
|
|
default:
|
|
ret = -EINVAL;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_set_auth(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
int flag = pwrq->u.param.flags & IW_AUTH_INDEX;
|
|
int value = pwrq->u.param.value;
|
|
|
|
if (wifidev->mode != IW_MODE_INFRA)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
switch (flag)
|
|
{
|
|
case IW_AUTH_WPA_VERSION:
|
|
{
|
|
/* record the value */
|
|
|
|
wifidev->proto = value >> 1;
|
|
|
|
ninfo("proto=%s\n", get_authstr(value));
|
|
}
|
|
break;
|
|
|
|
case IW_AUTH_CIPHER_PAIRWISE:
|
|
{
|
|
/* record the value */
|
|
|
|
wifidev->pairwise_chiper = value;
|
|
|
|
ninfo("pairwise=%s\n", get_cipherstr(value));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
nerr("ERROR: Unknown cmd %d\n", flag);
|
|
return -ENOSYS;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_get_auth(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
break;
|
|
case IW_MODE_MASTER:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
static int wifidriver_set_psk(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
FAR struct iw_encode_ext *ext;
|
|
int ret = OK;
|
|
|
|
ext = (FAR struct iw_encode_ext *)pwrq->u.encoding.pointer;
|
|
|
|
/* set auth_alg */
|
|
|
|
switch (ext->alg)
|
|
{
|
|
case IW_ENCODE_ALG_TKIP:
|
|
case IW_ENCODE_ALG_CCMP:
|
|
break;
|
|
case IW_ENCODE_ALG_NONE:
|
|
case IW_ENCODE_ALG_WEP:
|
|
default:
|
|
return -ENOSYS;
|
|
}
|
|
|
|
wifidev->auth_alg = ext->alg;
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
{
|
|
wifidev->auth_alg = ext->alg;
|
|
memset(wifidev->password, 0, sizeof(wifidev->password));
|
|
memcpy(wifidev->password, ext->key, ext->key_len);
|
|
|
|
ninfo("psk=%s, key_len= %d, alg=%u\n", wifidev->password,
|
|
ext->key_len, ext->alg);
|
|
|
|
/* Set the psk flag for security ap. */
|
|
|
|
wifidev->psk_flag = 1;
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
default:
|
|
ret = -ENOSYS;
|
|
break;
|
|
}
|
|
|
|
return ret ;
|
|
}
|
|
|
|
static int wifidriver_get_psk(FAR struct wifi_sim_s *wifidev,
|
|
FAR struct iwreq *pwrq)
|
|
{
|
|
FAR struct iw_encode_ext *ext;
|
|
int ret = OK;
|
|
int len;
|
|
int size;
|
|
|
|
ext = (FAR struct iw_encode_ext *)pwrq->u.encoding.pointer;
|
|
len = pwrq->u.encoding.length - sizeof(*ext);
|
|
|
|
switch (wifidev->mode)
|
|
{
|
|
case IW_MODE_INFRA:
|
|
size = strnlen(wifidev->password, 64);
|
|
if (len < size)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
else
|
|
{
|
|
ext->key_len = size;
|
|
memcpy(ext->key, wifidev->password, ext->key_len);
|
|
ext->alg = wifidev->auth_alg;
|
|
}
|
|
break;
|
|
|
|
case IW_MODE_MASTER:
|
|
default:
|
|
ret = -ENOSYS;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
/* iw_ops */
|
|
|
|
static int wifidriver_connect(FAR struct netdev_lowerhalf_s *dev)
|
|
{
|
|
int ret;
|
|
|
|
ret = wifidriver_start_connect(LOWERDEV2WIFIDEV(dev));
|
|
if (ret == OK)
|
|
{
|
|
netdev_lower_carrier_on(dev);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_disconnect(FAR struct netdev_lowerhalf_s *dev)
|
|
{
|
|
return wifidriver_start_disconnect(LOWERDEV2WIFIDEV(dev));
|
|
}
|
|
|
|
static int wifidriver_essid(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return wifidriver_set_essid(wifidev, iwr);
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_essid(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_bssid(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
int ret;
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
ret = wifidriver_set_bssid(wifidev, iwr);
|
|
}
|
|
else
|
|
{
|
|
ret = wifidriver_get_bssid(wifidev, iwr);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int wifidriver_passwd(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
if (set)
|
|
{
|
|
return wifidriver_set_psk(LOWERDEV2WIFIDEV(dev), iwr);
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_psk(LOWERDEV2WIFIDEV(dev), iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_mode(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return wifidriver_set_mode(wifidev, iwr);
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_mode(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_auth(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return wifidriver_set_auth(wifidev, iwr);
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_auth(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_freq(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return wifidriver_set_freq(wifidev, iwr);
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_freq(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_bitrate(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return -ENOTTY;
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_bitrate(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_txpower(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return wifidriver_set_txpower(wifidev, iwr);
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_txpower(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_country(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return wifidriver_set_country(wifidev, iwr);
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_country(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_sensitivity(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return -ENOTTY;
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_get_sensitivity(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_scan(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr, bool set)
|
|
{
|
|
FAR struct wifi_sim_s *wifidev = LOWERDEV2WIFIDEV(dev);
|
|
|
|
if (set)
|
|
{
|
|
return wifidriver_start_scan(wifidev, iwr);
|
|
}
|
|
else
|
|
{
|
|
return wifidriver_scan_result(wifidev, iwr);
|
|
}
|
|
}
|
|
|
|
static int wifidriver_range(FAR struct netdev_lowerhalf_s *dev,
|
|
FAR struct iwreq *iwr)
|
|
{
|
|
return wifidriver_get_range(LOWERDEV2WIFIDEV(dev), iwr);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: wifi_sim_init
|
|
****************************************************************************/
|
|
|
|
int wifi_sim_init(FAR struct wifi_sim_lowerhalf_s *netdev)
|
|
{
|
|
FAR struct wifi_sim_s *priv;
|
|
|
|
priv = kmm_zalloc(sizeof(*priv));
|
|
if (priv == NULL)
|
|
{
|
|
nerr("virt wifi driver priv alloc failed\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
netdev->lower.iw_ops = &g_iw_ops;
|
|
priv->lower = &netdev->lower;
|
|
netdev->wifi = priv;
|
|
|
|
return OK;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Name: wifi_sim_remove
|
|
****************************************************************************/
|
|
|
|
void wifi_sim_remove(FAR struct wifi_sim_lowerhalf_s *netdev)
|
|
{
|
|
FAR struct wifi_sim_s *sta = (FAR struct wifi_sim_s *)netdev->wifi;
|
|
|
|
if (sta && sta->state == WLAN_STA_STATE_CONNECTED)
|
|
{
|
|
wifidriver_start_disconnect(sta);
|
|
}
|
|
|
|
kmm_free(netdev->wifi);
|
|
}
|
|
|