/* * Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the * distribution. * 3. Neither the name of XRADIO TECHNOLOGY CO., LTD. nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifdef CONFIG_WLAN #include "cmd_util.h" #include "common/framework/net_ctrl.h" #include "net/wlan/wlan_ext_req.h" #include "net/wlan/wlan_defs.h" #include "net/wlan/wlan.h" #include "net/wlan/wlan_frame.h" #include "common/framework/sysinfo.h" #include "math.h" #if PRJCONF_NET_EN #define LOW_POWER_IP_SERVICE 1 #define NONCONNECT_SNIFF 0 #define MONITOR_RX_HT40_PHY_INFO 0 #define AP_SNIFFER 0 #define BEACON_TX 0 #define CMD_WLAN_NETIF wlan_netif_get(WLAN_MODE_NONE) static enum cmd_status cmd_wlan_stop_exec(char *cmd) { if (net_sys_stop() != 0) { return CMD_STATUS_FAIL; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_start_exec(char *cmd) { struct sysinfo *sysinfo = sysinfo_get(); if (sysinfo == NULL) { CMD_ERR("failed to get sysinfo %p\n", sysinfo); return CMD_STATUS_FAIL; } if (net_sys_start(sysinfo->wlan_mode) != 0) { return CMD_STATUS_FAIL; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_fast_join(char *cmd) { int ret; int enable_fast_join; int cnt = cmd_sscanf(cmd, "e=%d", &enable_fast_join); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_SET_FAST_JOIN, enable_fast_join); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_pm_dtim(char *cmd) { int ret, cnt; uint32_t period; cnt = cmd_sscanf(cmd, "p=%d", &period); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_PM_DTIM, period); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_ps_mode(char *cmd) { int ret, cnt; uint32_t ps_mode; uint32_t ps_ip = 0; uint32_t ps_cp = 0; wlan_ext_ps_cfg_t ps_cfg; if (cmd_strncmp(cmd, "enable", 6) == 0) { ps_mode = 1; cnt = cmd_sscanf((cmd + 6), " ip=%d cp=%d", &ps_ip, &ps_cp); if (cnt != 2) { ps_ip = 0; ps_cp = 0; CMD_ERR("cnt %d\n", cnt); } } else if (cmd_strncmp(cmd, "ps_enable", 9) == 0) { ps_mode = 2; cnt = cmd_sscanf((cmd + 9), " ip=%d cp=%d", &ps_ip, &ps_cp); if (cnt != 2) { ps_ip = 0; ps_cp = 0; CMD_ERR("cnt %d\n", cnt); } } else if (cmd_strncmp(cmd, "disable", 7) == 0) { ps_mode = 0; } else { CMD_ERR("invalid argument '%s'\n", cmd); return CMD_STATUS_INVALID_ARG; } cmd_memset(&ps_cfg, 0, sizeof(wlan_ext_ps_cfg_t)); ps_cfg.ps_mode = ps_mode; ps_cfg.ps_idle_period = ps_ip; ps_cfg.ps_change_period = ps_cp; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_PS_CFG, (uint32_t)&ps_cfg); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_ampdu(char *cmd) { int ret, cnt; int num; cnt = cmd_sscanf(cmd, "l=%d", &num); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_AMPDU_TXNUM, num); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_retry(char *cmd) { int ret; int retry_cnt, cnt; cnt = cmd_sscanf(cmd, "n=%d", &retry_cnt); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_TX_RETRY_CNT, retry_cnt); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_pm_tx_null_period(char *cmd) { int ret; int period, cnt; cnt = cmd_sscanf(cmd, "p=%d", &period); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_PM_TX_NULL_PERIOD, period); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } #define SUPPORT_BCN_AUTO_OFFSET 0 static enum cmd_status cmd_wlan_get_bcn_stat(char *cmd) { int ret, i; unsigned int sum_cnt = 0; int sum_avg = 0; struct netif *nif; wlan_ext_bcn_status_t bcn_status; #if SUPPORT_BCN_AUTO_OFFSET wlan_ext_bcn_auto_offset_t bcn_auto_offset_info; #endif char dly_info[][20] = { "(<0 )", "(<500us )", "(<1000us )", "(<2000us )", "(<4000us )", "(<8000us )", "(<16000us)", "(>16000us)", }; cmd_memset(&bcn_status, 0, sizeof(wlan_ext_bcn_status_t)); #if SUPPORT_BCN_AUTO_OFFSET cmd_memset(&bcn_auto_offset_info, 0, sizeof(wlan_ext_bcn_auto_offset_t)); #endif nif = CMD_WLAN_NETIF; ret = wlan_ext_request(nif, WLAN_EXT_CMD_GET_BCN_STATUS, (uint32_t)&bcn_status); if (ret == -2) { CMD_ERR("%s: WLAN_EXT_CMD_GET_BCN_STATUS command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: WLAN_EXT_CMD_GET_BCN_STATUS command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } #if SUPPORT_BCN_AUTO_OFFSET ret = wlan_ext_request(nif, WLAN_EXT_CMD_AUTO_BCN_OFFSET_READ, (uint32_t)&bcn_auto_offset_info); if (ret == -2) { CMD_ERR("%s: WLAN_EXT_CMD_AUTO_BCN_OFFSET_READ command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: WLAN_EXT_CMD_AUTO_BCN_OFFSET_READ command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } #endif CMD_LOG(1, "\nAPP AP Beacon Delay Stat Info=================\n"); for (i = 0; i < 8; i++) { CMD_LOG(1, "cnt %d %s: %d\n", i, dly_info[i], bcn_status.bcn_delay_cnt[i]); sum_cnt += bcn_status.bcn_delay_cnt[i]; } if (sum_cnt) sum_avg = bcn_status.bcn_delay_sum / sum_cnt; CMD_LOG(1, "Dur: %d, Max: %d, Rxed: %d, Missed: %d\n", bcn_status.bcn_duration, bcn_status.bcn_delay_max, bcn_status.bcn_rx_cnt, bcn_status.bcn_miss_cnt); CMD_LOG(1, "Sum: %d, Cnt: %d, Ava: %d\n", bcn_status.bcn_delay_sum, sum_cnt, sum_avg); #if SUPPORT_BCN_AUTO_OFFSET CMD_LOG(1, "\nAPP Beacon Auto Offset Info===================\n"); for (i = 0; i < BCN_AUTO_OFFSET_DLY_TIME_CNT; i++) { CMD_LOG(1, "Bcn Dly Time(us) %d: \t%d\n", i, bcn_auto_offset_info.bcn_dly_time[i]); } CMD_LOG(1, "Bcn Auto Offset Open Cnt: %d\n", bcn_auto_offset_info.bcn_auto_offset_open_cnt); CMD_LOG(1, "APP Beacon Auto Offset Info===================\n"); #endif CMD_LOG(1, "APP AP Beacon Delay Stat Info=================\n"); return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_bcn_win_us(char *cmd) { int ret; int bcn_win, cnt; cnt = cmd_sscanf(cmd, "w=%d", &bcn_win); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_BCN_WIN_US, bcn_win); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_cur_tx_rate(char *cmd) { int ret; int rate; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_GET_TX_RATE, (int)(&rate)); CMD_LOG(1, "current rate:%d\n", rate); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_pm_dtim(char *cmd) { int ret; wlan_ext_pm_dtim_t dtim; cmd_memset(&dtim, 0, sizeof(wlan_ext_pm_dtim_t)); ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_GET_PM_DTIM, (int)(&dtim)); CMD_LOG(1, "AP DTIM set:%d, STA DTIM set:%d\n", dtim.pm_join_dtim_period, dtim.pm_dtim_period_extend); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_cur_signal(char *cmd) { int ret; wlan_ext_signal_t signal; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_GET_SIGNAL, (int)(&signal)); CMD_LOG(1, "current rssi:%d(snr, 0.5db), noise:%d(dbm), level:%d(dbm)\n", signal.rssi, signal.noise, signal.rssi / 2 + signal.noise); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_scan_param(char *cmd) { int ret, cnt; int num_probes; int probe_delay; int min_dwell; int max_dwell; wlan_ext_scan_param_t param; cnt = cmd_sscanf(cmd, "n=%d d=%d min=%d max=%d", &num_probes, &probe_delay, &min_dwell, &max_dwell); if (cnt != 4) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } memset(¶m, 0, sizeof(wlan_ext_scan_param_t)); param.num_probes = num_probes; param.probe_delay = probe_delay; param.min_dwell = min_dwell; param.max_dwell = max_dwell; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SCAN_PARAM, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_listen_interval(char *cmd) { int ret, cnt; uint32_t listen_interval; cnt = cmd_sscanf(cmd, "l=%d", &listen_interval); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_LISTEN_INTERVAL, listen_interval); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_hidden_ap(char *cmd) { int cnt, enable, ret; cnt = cmd_sscanf(cmd, "e=%d", &enable); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_ap_hiden_ssid(enable); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_mixrate(char *cmd) { int ret, cnt; int enable; cnt = cmd_sscanf(cmd, "e=%d", &enable); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_MIXRATE, enable); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } #if LOW_POWER_IP_SERVICE #include #include #include #include "netif/etharp.h" #include static enum cmd_status cmd_wlan_set_auto_scan(char *cmd) { int ret, cnt; int enable; int interval; wlan_ext_auto_scan_param_t param; if (cmd_strncmp(cmd, "enable", 6) == 0) { enable = 1; cnt = cmd_sscanf((cmd + 6), " i=%d", &interval); if (cnt != 1) { interval = 0; CMD_ERR("cnt %d\n", cnt); } } else if (cmd_strncmp(cmd, "disable", 7) == 0) { enable = 0; interval = 0; } else { CMD_ERR("invalid argument '%s'\n", cmd); return CMD_STATUS_INVALID_ARG; } memset(¶m, 0, sizeof(wlan_ext_auto_scan_param_t)); param.auto_scan_enable = enable; param.auto_scan_interval = interval; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_AUTO_SCAN, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_ap_mac(char *cmd) { int cnt; uint32_t dest_ip[4]; uint8_t eth_ret[6]; #ifdef CONFIG_LWIP_VER_1_4_1 ip_addr_t da; #else ip4_addr_t da; #endif cnt = cmd_sscanf(cmd, "%d.%d.%d.%d", &dest_ip[0], &dest_ip[1], &dest_ip[2], &dest_ip[3]); if (cnt != 4) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } da.addr = (dest_ip[0] << 0) + (dest_ip[1] << 8) + (dest_ip[2] << 16) + (dest_ip[3] << 24); #ifdef CONFIG_LWIP_VER_1_4_1 if (etharp_get_mac_from_ip((ip_addr_t *)&(da.addr), (struct eth_addr *)eth_ret)) #else if (etharp_get_mac_from_ip((ip4_addr_t *)&(da.addr), (struct eth_addr *)eth_ret)) #endif CMD_LOG(1, "get mac:%02X:%02X:%02X:%02X:%02X:%02X\n", eth_ret[0], eth_ret[1], eth_ret[2], eth_ret[3], eth_ret[4], eth_ret[5]); else CMD_LOG(1, "mac not found!!\n"); return CMD_STATUS_OK; } #define CONNECTION_DATA "hello!" #define P2P_WAKEUP_PACKET_DATA "for wakeup packet!" #define P2P_KEEP_ALIVE_DATA "for keeping alive!" #define EXIT_DATA "exit!" #define MAX_DATA_SIZE 128 int ser_udp_flag; int sock_ser; int sock_remote; struct sockaddr_in remote_addr; socklen_t addr_len = sizeof(remote_addr); static enum cmd_status cmd_wlan_server_start(char *cmd) { struct sockaddr_in local_addr; int port, cnt, ret; cnt = cmd_sscanf(cmd, "port=%d udp=%d", &port, &ser_udp_flag); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); //return CMD_STATUS_INVALID_ARG; } if (ser_udp_flag) { sock_ser = socket(AF_INET, SOCK_DGRAM, 0); } else { sock_ser = socket(AF_INET, SOCK_STREAM, 0); } int tmp = 1; ret = setsockopt(sock_ser, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(int)); if (ret != 0) { CMD_ERR("setsockopt(SO_REUSEADDR) failed, err %d\n", (int)OS_GetErrno); closesocket(sock_ser); return -1; } /* bind socket to port */ memset(&local_addr, 0, sizeof(struct sockaddr_in)); local_addr.sin_addr.s_addr = htonl(INADDR_ANY); local_addr.sin_port = htons(port); local_addr.sin_family = AF_INET; ret = bind(sock_ser, (struct sockaddr *)&local_addr, sizeof(struct sockaddr_in)); if (ret < 0) { CMD_ERR("Failed to bind socket %d, err %d\n", sock_ser, (int)OS_GetErrno); closesocket(sock_ser); return CMD_STATUS_ACKED; } if (ser_udp_flag) { uint32_t data_len; uint8_t *data_buf = NULL; data_buf = cmd_malloc(MAX_DATA_SIZE); if (data_buf == NULL) { CMD_ERR("malloc() failed!\n"); return CMD_STATUS_ACKED; } printf("UDP bind with port %d\n", port); cmd_memset(data_buf, 0, MAX_DATA_SIZE); data_len = recvfrom(sock_ser, data_buf, MAX_DATA_SIZE, 0, (struct sockaddr *)&remote_addr, &addr_len); if (data_len > 0) { printf("UDP recv connection from %s:%d\n", inet_ntoa(remote_addr.sin_addr), ntohs(remote_addr.sin_port)); } else { printf("fail to recv connection from remote socket\n"); } cmd_free(data_buf); } else { printf("TCP listen at port %d\n", port); ret = listen(sock_ser, 1); if (ret < 0) { CMD_ERR("Failed to listen socket %d, err %d\n", sock_ser, (int)OS_GetErrno); closesocket(sock_ser); return CMD_STATUS_ACKED; } ret = sizeof(struct sockaddr_in); while (1) { sock_remote = accept(sock_ser, (struct sockaddr *)&remote_addr, (socklen_t *)&ret); if (sock_remote >= 0) break; } } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_server_send(char *cmd) { int cnt, ret, i; int send_cnt, period, len; uint8_t *data_buf = NULL; cnt = cmd_sscanf(cmd, "cnt=%d p=%d l=%d", &send_cnt, &period, &len); if (cnt != 3) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (len > MAX_DATA_SIZE) { CMD_ERR("invalid length %d, should be small than %d\n", len, MAX_DATA_SIZE); return CMD_STATUS_INVALID_ARG; } data_buf = cmd_malloc(len); for (i = 0; i < len; i++) { data_buf[i] = i; } //UDP remote_addr was set when receive before printf("%s send to %s:%d\n", ser_udp_flag ? "UDP" : "TCP", inet_ntoa(remote_addr.sin_addr), ntohs(remote_addr.sin_port)); for (i = 0; i < send_cnt; i++) { printf("cnt:%d send data %d bytes\n", i, len); if (ser_udp_flag) { ret = sendto(sock_ser, data_buf, len, 0, (struct sockaddr *)&remote_addr, addr_len); } else { ret = send(sock_remote, data_buf, len, 0); } if (ret <= 0) { printf("send return %d, err %d\n", ret, (int)OS_GetErrno); break; } OS_MSleep(period); } cmd_free(data_buf); return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_server_recv(char *cmd) { int cnt, recv_cnt; uint32_t data_len; uint8_t *data_buf = NULL; cnt = cmd_sscanf(cmd, "cnt=%d", &recv_cnt); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } data_buf = cmd_malloc(MAX_DATA_SIZE); if (data_buf == NULL) { CMD_ERR("malloc() failed!\n"); return CMD_STATUS_ACKED; } if (ser_udp_flag) { int i = 0; printf("UDP recv from %s:%d\n", inet_ntoa(remote_addr.sin_addr), ntohs(remote_addr.sin_port)); while (1) { cmd_memset(data_buf, 0, MAX_DATA_SIZE); data_len = recvfrom(sock_ser, data_buf, MAX_DATA_SIZE, 0, (struct sockaddr *)&remote_addr, &addr_len); if (data_len > 0) { printf("cnt:%d recv data %d bytes\n", i, data_len); i++; if (i >= recv_cnt) break; } else { data_len = 0; } } } else { printf("TCP recv from %s:%d\n", inet_ntoa(remote_addr.sin_addr), ntohs(remote_addr.sin_port)); for (int i = 0; i < recv_cnt; i++) { cmd_memset(data_buf, 0, MAX_DATA_SIZE); data_len = recv(sock_remote, data_buf, MAX_DATA_SIZE, 0); if (data_len) { printf("cnt:%d recv data %d bytes\n", i, data_len); } } } cmd_free(data_buf); return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_server_stop(char *cmd) { printf("close server socket!\n"); closesocket(sock_ser); return CMD_STATUS_OK; } int cli_udp_flag; int sock_cli; int ser_port; uint32_t ser_ip[4]; struct sockaddr_in ser_addr; socklen_t ser_addr_len = sizeof(ser_addr); static enum cmd_status cmd_wlan_client_start(char *cmd) { int cnt, ret; uint8_t str_ip_addr[100]; uint8_t prio_value = TCP_PRIO_MAX - 2; cnt = cmd_sscanf(cmd, "ser=%d.%d.%d.%d port=%d udp=%d", &ser_ip[0], &ser_ip[1], &ser_ip[2], &ser_ip[3], &ser_port, &cli_udp_flag); if (cnt != 6) { CMD_ERR("cnt %d\n", cnt); //return CMD_STATUS_INVALID_ARG; } memset(str_ip_addr, 0, 100); sprintf((char *)str_ip_addr, "%d.%d.%d.%d", ser_ip[0], ser_ip[1], ser_ip[2], ser_ip[3]); if (cli_udp_flag) { sock_cli = socket(AF_INET, SOCK_DGRAM, 0); } else { sock_cli = socket(AF_INET, SOCK_STREAM, 0); } ser_addr.sin_family = AF_INET; ser_addr.sin_addr.s_addr = inet_addr((char *)str_ip_addr); ser_addr.sin_port = htons(ser_port); if (cli_udp_flag) { printf("send connection to %s:%d...\n", str_ip_addr, ser_port); ret = sendto(sock_cli, CONNECTION_DATA, sizeof(CONNECTION_DATA), 0, (struct sockaddr *)&ser_addr, ser_addr_len); } else { printf("try to connect %s:%d...\n", str_ip_addr, ser_port); printf("set tcp prio --> %d\n",prio_value); if(lwip_setsockopt(sock_cli, IPPROTO_TCP, TCP_PRIO, &prio_value, sizeof(prio_value)) < 0) printf("set tcp prio failed.\n"); ret = connect(sock_cli, (struct sockaddr *)&ser_addr, sizeof(struct sockaddr)); if (ret < 0) printf("Connect failed! ret = %d\n", ret); else { printf("Connect OK!\n"); } } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_client_send(char *cmd) { int cnt, ret, i; int send_cnt, period, len; uint8_t *data_buf = NULL; cnt = cmd_sscanf(cmd, "cnt=%d p=%d l=%d", &send_cnt, &period, &len); if (cnt != 3) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (len > MAX_DATA_SIZE) { CMD_ERR("invalid length %d, should be small than %d\n", len, MAX_DATA_SIZE); return CMD_STATUS_INVALID_ARG; } data_buf = cmd_malloc(len); for (i = 0; i < len; i++) { data_buf[i] = i; } //ser_addr was set when client start printf("%s send to %s:%d\n", cli_udp_flag?"UDP":"TCP", inet_ntoa(ser_addr.sin_addr), ntohs(ser_addr.sin_port)); for (i = 0; i < send_cnt; i++) { printf("cnt:%d send data %d bytes\n", i, len); if (cli_udp_flag) { ret = sendto(sock_cli, data_buf, len, 0, (struct sockaddr *)&ser_addr, ser_addr_len); } else { ret = send(sock_cli, data_buf, len, 0); } if (ret <= 0) { printf("send return %d, err %d\n", ret, (int)OS_GetErrno); break; } OS_MSleep(period); } cmd_free(data_buf); return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_client_recv(char *cmd) { int cnt, recv_cnt; uint32_t data_len; uint8_t *data_buf = NULL; cnt = cmd_sscanf(cmd, "cnt=%d", &recv_cnt); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } data_buf = malloc(MAX_DATA_SIZE); if (data_buf == NULL) { CMD_ERR("malloc() failed!\n"); return CMD_STATUS_ACKED; } if (cli_udp_flag) { int i = 0; printf("UDP recv from %s:%d\n", inet_ntoa(ser_addr.sin_addr), ntohs(ser_addr.sin_port)); while (1) { cmd_memset(data_buf, 0, MAX_DATA_SIZE); data_len = recvfrom(sock_cli, data_buf, MAX_DATA_SIZE, 0, (struct sockaddr *)&ser_addr, &ser_addr_len); if (data_len > 0) { printf("cnt:%d recv data %d bytes\n", i, data_len); i++; if (i >= recv_cnt) break; } else { data_len = 0; } } } else { printf("TCP recv from %s:%d\n", inet_ntoa(ser_addr.sin_addr), ntohs(ser_addr.sin_port)); for (int i = 0; i < recv_cnt; i++) { cmd_memset(data_buf, 0, MAX_DATA_SIZE); data_len = recv(sock_cli, data_buf, MAX_DATA_SIZE, 0); if (data_len) { printf("cnt:%d recv data %d bytes\n", i, data_len); } } } cmd_free(data_buf); return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_client_stop(char *cmd) { //send(sock_cli_tcp, EXIT_DATA, strlen(EXIT_DATA), 0); printf("close client socket!\n"); closesocket(sock_cli); return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_p2p_server(char *cmd) { int ret, cnt, i; int mac[6]; int ser_num, enable; int udp_flag = 0; wlan_ext_p2p_svr_set_t svr; struct sockaddr_in local_addr; socklen_t len = sizeof(struct sockaddr); struct netif *nif; cnt = cmd_sscanf(cmd, "s=%d e=%d udp=%d mac=%x:%x:%x:%x:%x:%x", &ser_num, &enable, &udp_flag, &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5]); if (cnt != 9) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } //set server param if (ser_num > 2) { CMD_ERR("invalid server number %d, should be 0 to 2\n", ser_num); return CMD_STATUS_INVALID_ARG; } nif = CMD_WLAN_NETIF; cmd_memset(&svr, 0, sizeof(wlan_ext_p2p_svr_set_t)); #if LWIP_IPV4 && LWIP_IPV6 cmd_memcpy(svr.SrcIPv4Addr, &(nif->ip_addr.u_addr), 4); #else cmd_memcpy(svr.SrcIPv4Addr, &(nif->ip_addr.addr), 4); #endif getsockname(sock_cli, (struct sockaddr *)&local_addr, &len); svr.P2PServerCfgs[ser_num].DstPort = ser_port; svr.P2PServerCfgs[ser_num].SrcPort = ntohs(local_addr.sin_port); for (i = 0; i < 4; i++) { svr.P2PServerCfgs[ser_num].DstIPv4Addr[i] = ser_ip[i]; } //ret = etharp_find_addr(nif, (const ip4_addr_t *)&(server_addr.sin_addr.s_addr), // ðaddr_ret, (const ip4_addr_t **)&ipaddr_ret); for (i = 0; i < 6; i++) { svr.P2PServerCfgs[ser_num].DstMacAddr[i] = mac[i]; } svr.P2PServerCfgs[ser_num].TcpSeqInit = getsockack(sock_cli); svr.P2PServerCfgs[ser_num].TcpAckInit = getsockseq(sock_cli); svr.P2PServerCfgs[ser_num].IPIdInit = 1; svr.P2PServerCfgs[ser_num].Enable = enable; svr.P2PServerCfgs[ser_num].TcpOrUdp = udp_flag?0x02:0x01; ret = wlan_ext_request(nif, WLAN_EXT_CMD_SET_P2P_SVR, (int)(&svr)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_p2p_wkpacket(char *cmd) { int ret, cnt, i; int ser_num, enable, payload_len; wlan_ext_p2p_wkp_param_set_t wkp_param; cnt = cmd_sscanf(cmd, "s=%d e=%d pl=%d", &ser_num, &enable, &payload_len); if (cnt != 3) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } //set wakeup packet param if (ser_num > 2) { CMD_ERR("invalid server number %d, should be 0 to 2\n", ser_num); return CMD_STATUS_INVALID_ARG; } cmd_memset(&wkp_param, 0, sizeof(wlan_ext_p2p_wkp_param_set_t)); wkp_param.P2PWkpParamCfgs[ser_num].Enable = enable; wkp_param.P2PWkpParamCfgs[ser_num].PayloadLen = payload_len; for (i = 0; i < payload_len; i++) { wkp_param.P2PWkpParamCfgs[ser_num].Payload[i] = i; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_P2P_WKP_CFG, (int)(&wkp_param)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_p2p_wakeupip(char *cmd) { int ret, cnt, i, j; int ser_num, enable, ip[4]; wlan_ext_p2p_wkp_param_set_t wkp_param; cnt = cmd_sscanf(cmd, "s=%d e=%d ser=%d.%d.%d.%d", &ser_num, &enable, &ip[0], &ip[1], &ip[2], &ip[3]); if (cnt != 6) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } //set wakeup packet param if (ser_num > 7) { CMD_ERR("invalid server number %d, should be 0 to 7\n", ser_num); return CMD_STATUS_INVALID_ARG; } cmd_memset(&wkp_param, 0, sizeof(wlan_ext_p2p_wkp_param_set_t)); wkp_param.Enable = enable; for (i = 0; i < 4; i++) { wkp_param.P2PIpv4FilterCfgs[ser_num].Ipv4Filter[i] = ip[i]; } for (i = 0; i < IPC_P2P_IPV4_FILTER_NUM_MAX; i++) { if ( wkp_param.P2PIpv4FilterCfgs[i].Ipv4Filter[0] + wkp_param.P2PIpv4FilterCfgs[i].Ipv4Filter[1] + \ wkp_param.P2PIpv4FilterCfgs[i].Ipv4Filter[2] + wkp_param.P2PIpv4FilterCfgs[i].Ipv4Filter[3] == 0) { for (j = 0; j < 4; j++) wkp_param.P2PIpv4FilterCfgs[i].Ipv4Filter[j] = 0xff; } } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_P2P_WKP_CFG, (int)(&wkp_param)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_p2p_kpalive(char *cmd) { int ret, cnt, i; int ser_num, enable; int period, timeout, retry, payload_len; wlan_ext_p2p_kpalive_param_set_t param; cnt = cmd_sscanf(cmd, "s=%d e=%d p=%d t=%d r=%d pl=%d", &ser_num, &enable, &period, &timeout, &retry, &payload_len); if (cnt != 6) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } //set keep alive param if (ser_num > 2) { CMD_ERR("invalid server number %d, should be 0 to 2\n", ser_num); return CMD_STATUS_INVALID_ARG; } cmd_memset(¶m, 0, sizeof(wlan_ext_p2p_kpalive_param_set_t)); param.KeepAlivePeriod_s = period; param.TxTimeOut_s = timeout; param.TxRetryLimit = retry; param.P2PKeepAliveParamCfgs[ser_num].Enable = enable; param.P2PKeepAliveParamCfgs[ser_num].PayloadLen = payload_len; for (i = 0; i < payload_len; i++) { param.P2PKeepAliveParamCfgs[ser_num].Payload[i] = i; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_P2P_KPALIVE_CFG, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_p2p_hostsleep(char *cmd) { int ret, cnt; int hostsleep; cnt = cmd_sscanf(cmd, "%d", &hostsleep); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_P2P_HOST_SLEEP, hostsleep); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } wlan_ext_p2p_keepalive_param_t P2P_KeepAlive; /* eg:net wlan p2p_kpalive_start s=0 e=0x0f c=1 ip=192.168.1.1 port=5008 udp=0 //create client and set keepalive param eg:net wlan p2p_kpalive_start s=0 e=0x01 c=0 ip=192.168.1.1 port=5008 udp=0 //1-enable p2p server,0-disable eg:net wlan p2p_kpalive_start s=0 e=0x02 c=0 ip=192.168.1.1 port=5008 udp=0 //1-enable keepalive packet,0-disable eg:net wlan p2p_kpalive_start s=0 e=0x04 c=0 ip=192.168.1.1 port=5008 udp=0 //1-enable wakeup packet,0-disable eg:net wlan p2p_kpalive_start s=0 e=0x08 c=0 ip=192.168.1.1 port=5008 udp=0 //1-enable wakeup IP,0-disable */ static enum cmd_status cmd_wlan_p2p_keepalive_start(char *cmd) { int ret, cnt, i; int enable, ser_num, create; int udp_flag = 0; int ip_addr[4], port; uint8_t dest_mac[6]; int fd; wlan_ext_p2p_keepalive_socket_t *pSocket; #ifdef CONFIG_LWIP_VER_1_4_1 ip_addr_t da; #else ip4_addr_t da; #endif cnt = cmd_sscanf(cmd, "s=%d e=%x c=%d ip=%d.%d.%d.%d port=%d udp=%d", &ser_num, &enable, &create, &ip_addr[0], &ip_addr[1], &ip_addr[2], &ip_addr[3], &port, &udp_flag); if (cnt != 9) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (ser_num > 2) { CMD_ERR("invalid server number %d, should be 0 to 2\n", ser_num); return CMD_STATUS_INVALID_ARG; } pSocket = &P2P_KeepAlive.Socket[ser_num]; if (create) { uint8_t str_ip_addr[100]; struct sockaddr_in dest_addr; socklen_t socklen = sizeof(struct sockaddr); cmd_memset(pSocket, 0, sizeof(wlan_ext_p2p_keepalive_socket_t)); cmd_memset(str_ip_addr, 0, 100); sprintf((char *)str_ip_addr, "%d.%d.%d.%d", ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]); if (udp_flag) { fd = socket(AF_INET, SOCK_DGRAM, 0); } else { fd = socket(AF_INET, SOCK_STREAM, 0); } CMD_DBG("create socket(%d)...%s\n", fd, strerror(errno)); dest_addr.sin_family = AF_INET; dest_addr.sin_addr.s_addr = inet_addr((char *)str_ip_addr); dest_addr.sin_port = htons(port); pSocket->fd = fd; if (udp_flag) { CMD_DBG("send connection to %s:%d...\n", str_ip_addr, port); ret = sendto(fd, CONNECTION_DATA, sizeof(CONNECTION_DATA), 0, (struct sockaddr *)&dest_addr, socklen); } else { CMD_DBG("try to connect %s:%d...\n", str_ip_addr, port); ret = connect(fd, (struct sockaddr *)&dest_addr, socklen); if (ret < 0) { CMD_ERR("Connect failed! ret = %d\n", ret); return CMD_STATUS_INVALID_ARG; } else { CMD_DBG("Connect OK!\n"); } } } if (enable & IPC_P2P_KEEPALIVE_ENABLE) { pSocket->Enable = 1; pSocket->Port = port; pSocket->udp_flag = udp_flag; for (i = 0; i < 4; i++) { pSocket->DstIPv4Addr[i] = ip_addr[i]; } da.addr = (ip_addr[0] << 0) + (ip_addr[1] << 8) + (ip_addr[2] << 16) + (ip_addr[3] << 24); #ifdef CONFIG_LWIP_VER_1_4_1 if (etharp_get_mac_from_ip((ip_addr_t *)&(da.addr), (struct eth_addr *)dest_mac)) #else if (etharp_get_mac_from_ip((ip4_addr_t *)&(da.addr), (struct eth_addr *)dest_mac)) #endif for (i = 0; i < 6; i++) { pSocket->DstMacAddr[i] = dest_mac[i]; } //keepalive param set if (enable & IPC_P2P_KEEPALIVE_CFG) { P2P_KeepAlive.KeepAlive.Period = 5; P2P_KeepAlive.KeepAlive.TxTimeOut = 3; P2P_KeepAlive.KeepAlive.TxRetryLimit = 3; //server number keepalive packet set pSocket->KeepAliveCfg.Enable = 1; pSocket->KeepAliveCfg.PayloadLen = IPC_P2P_KPALIVE_PAYLOAD_LEN_MAX; for (i = 0; i < IPC_P2P_KPALIVE_PAYLOAD_LEN_MAX; i++) pSocket->KeepAliveCfg.Payload[i] = i; } else { pSocket->KeepAliveCfg.Enable = 0; pSocket->KeepAliveCfg.PayloadLen = 0; cmd_memset(pSocket->KeepAliveCfg.Payload, 0, IPC_P2P_KPALIVE_PAYLOAD_LEN_MAX); } //server number wakeup packet set if (enable & IPC_P2P_WAKEUP_PACKET) { pSocket->WakeupPkt.Enable = 1; pSocket->WakeupPkt.PayloadLen = IPC_P2P_WUP_PAYLOAD_LEN_MAX; for (i = 0; i < IPC_P2P_WUP_PAYLOAD_LEN_MAX; i++) pSocket->WakeupPkt.Payload[i] = i; } else { pSocket->WakeupPkt.Enable = 0; pSocket->WakeupPkt.PayloadLen = 0; cmd_memset(pSocket->WakeupPkt.Payload, 0, IPC_P2P_KPALIVE_PAYLOAD_LEN_MAX); } //server number wakeup ip set if (enable & IPC_P2P_WAKEUP_IP) { pSocket->WakeupIp.Enable = 1; for (i = 0; i < 4; i++) pSocket->WakeupIp.Ipv4Filter[i] = ip_addr[i]; } else { pSocket->WakeupIp.Enable = 0; cmd_memset(pSocket->WakeupIp.Ipv4Filter, 0, 4); } } else { pSocket->Enable = 0; cmd_memset(pSocket, 0, sizeof(wlan_ext_p2p_keepalive_socket_t)); } ret = wlan_ext_p2p_keepalive_default(CMD_WLAN_NETIF, &P2P_KeepAlive); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } /* eg:net wlan p2p_kpalive_stop s=0 */ static enum cmd_status cmd_wlan_p2p_keepalive_stop(char *cmd) { int ser_num; int ret, cnt; cnt = cmd_sscanf(cmd, "s=%d", &ser_num); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (ser_num > 2) { CMD_ERR("invalid server number %d, should be 0 to 2\n", ser_num); return CMD_STATUS_INVALID_ARG; } closesocket(P2P_KeepAlive.Socket[ser_num].fd); CMD_DBG("close keepalive client socket!\n"); cmd_memset(&P2P_KeepAlive.Socket[ser_num], 0, sizeof(wlan_ext_p2p_keepalive_socket_t)); ret = wlan_ext_p2p_keepalive_default(CMD_WLAN_NETIF, &P2P_KeepAlive); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } #endif const char *wmm_type[] = { "AC_VO", "AC_VI", "AC_BE", "AC_BK", }; const char *wmm_phymode[] = { "auto", "11b", "11g", "11ng", "all", }; static enum cmd_status cmd_wlan_set_edca_param(char *cmd) { int ret, cnt; int temp_type, temp_cwmax, temp_cwmin, temp_aifsn, temp_mode; cnt = cmd_sscanf(cmd, "type=%d mode=%d max=%d min=%d n=%d", &temp_type, &temp_mode, &temp_cwmax, &temp_cwmin, &temp_aifsn); if (cnt != 5) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } wlan_ext_edca_param_t param; cmd_memset(¶m, 0, sizeof(wlan_ext_edca_param_t)); param.type = temp_type; CMD_LOG(1, "target type = %s\n", wmm_type[param.type]); param.mode = temp_mode; CMD_LOG(1, "target mode = %s\n", wmm_phymode[param.mode]); param.cwmax = temp_cwmax; CMD_LOG(1, "target cwmax = %d\n", ((int)pow(2, param.cwmax) - 1)); param.cwmin = temp_cwmin; CMD_LOG(1, "target cwmin = %d\n", ((int)pow(2, param.cwmin) - 1)); param.aifsn = temp_aifsn; CMD_LOG(1, "target aifsn = %d\n", param.aifsn); ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_SET_EDCA_PARAM, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_edca_param(char *cmd) { wlan_ext_edca_param_t param; int ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_GET_EDCA_PARAM, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } #if NONCONNECT_SNIFF static enum cmd_status cmd_wlan_set_rcv_special_frm(char *cmd) { int ret; uint32_t enable, type; wlan_ext_rcv_spec_frm_param_set_t param; int cnt; cnt = cmd_sscanf(cmd, "e=%d t=0x%x", &enable, &type); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); } memset(¶m, 0, sizeof(wlan_ext_rcv_spec_frm_param_set_t)); param.Enable = enable; param.u32RecvSpecFrameCfg = type; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_RCV_SPECIAL_FRM, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_send_raw_frm_cfg(char *cmd) { int ret, cnt; uint32_t cfg, enable; wlan_ext_send_raw_frm_param_set_t param; cnt = cmd_sscanf(cmd, "e=%d c=0x%x", &enable, &cfg); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } memset(¶m, 0, sizeof(wlan_ext_send_raw_frm_param_set_t)); param.Enable = enable; param.u16SendRawFrameCfg = cfg; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SEND_RAW_FRM_CFG, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_switch_channel_cfg(char *cmd) { int ret, cnt; uint32_t band, flag, channel, sc_time; wlan_ext_switch_channel_param_set_t param; cnt = cmd_sscanf(cmd, "b=%d f=0x%x c=%d t=%d", &band, &flag, &channel, &sc_time); if (cnt != 4) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } memset(¶m, 0, sizeof(wlan_ext_switch_channel_param_set_t)); param.Enable = 1; param.Band = band; param.Flag = flag; param.ChannelNum = channel; param.SwitchChannelTime = sc_time; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SWITCH_CHN_CFG, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_cur_channel(char *cmd) { int ret; uint32_t channel; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_GET_CURRENT_CHN, (int)(&channel)); printf("current channel is %d\n", channel); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_sniff_kp_active(char *cmd) { int ret, cnt; uint32_t enable, cfg; wlan_ext_sniff_kp_active_set_t param; cnt = cmd_sscanf(cmd, "e=%d c=0x%x", &enable, &cfg); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } memset(¶m, 0, sizeof(wlan_ext_sniff_kp_active_set_t)); param.Enable = enable; param.u32Config = cfg; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SNIFF_KP_ACTIVE, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_sniff_auto_wakeup_host(char *cmd) { int ret, cnt; int cfg, type, enable, wkp_time, kp_time, flag, start_time, channel; wlan_ext_sniff_sync_param_set_t param; cnt = cmd_sscanf(cmd, "cfg=0x%x t=0x%x e=%d c=%d wt=%d kt=%d f=0x%x st=%d", &cfg, &type, &enable, &channel, &wkp_time, &kp_time, &flag, &start_time); if (cnt != 8) { printf("cnt %d\n", cnt); //return CMD_STATUS_INVALID_ARG; } param.Enable = enable; param.ChannelNum = channel; param.SyncFrameType = type;//data param.u32SniffSyncCfg = cfg;// | SNIFF_SYNC_DISABLE_TIMER; param.time_sync_at_host.WakeupPeriod_ms = wkp_time;//ms param.time_sync_at_host.KeepActivePeriod_ms = kp_time;//ms param.time_sync_at_host.Flag = flag;//SNIFF_AUTO_WAKEUP_FRAME_SEND_TO_HOST; param.time_sync_at_host.StartTime = start_time;//us ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SNIFF_SYNC_CFG, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_sniff_auto_wakeup_wifi(char *cmd) { int ret, cnt; int cfg, type, channel, flag, SyncDTIM, MaxLostSyncPacket; int TSFOffset, AdaptiveExpansion, KeepActiveNumAfterLostSync, ActiveTime, MaxAdaptiveExpansionLimit; int MaxKeepAliveTime; wlan_ext_sniff_sync_param_set_t param; cnt = cmd_sscanf(cmd, "cfg=0x%x t=0x%x c=%d f=0x%x d=%d ml=%d tsf=%d ae=%d kaa=%d at=%d ma=%d mk=%d", &cfg, &type, &channel, &flag, &SyncDTIM, &MaxLostSyncPacket, &TSFOffset, &AdaptiveExpansion, &KeepActiveNumAfterLostSync, &ActiveTime, &MaxAdaptiveExpansionLimit, &MaxKeepAliveTime); if (cnt != 12) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } param.Enable = 1; param.ChannelNum = channel; param.SyncFrameType = type; param.u32SniffSyncCfg = cfg;//s param.time_sync_at_wifi.Flag = flag; param.time_sync_at_wifi.SyncDTIM = SyncDTIM; param.time_sync_at_wifi.MaxLostSyncPacket = MaxLostSyncPacket; param.time_sync_at_wifi.TSFOffset = TSFOffset; param.time_sync_at_wifi.AdaptiveExpansion = AdaptiveExpansion; param.time_sync_at_wifi.KeepActiveNumAfterLostSync = KeepActiveNumAfterLostSync; param.time_sync_at_wifi.ActiveTime = ActiveTime; param.time_sync_at_wifi.MaxAdaptiveExpansionLimit = MaxAdaptiveExpansionLimit; param.time_sync_at_wifi.MaxKeepAliveTime = MaxKeepAliveTime; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SNIFF_SYNC_CFG, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static wlan_ext_frm_filter_set_t g_frm_filter; static enum cmd_status cmd_wlan_rcv_frm_filter_mac(char *cmd) { int ret = 0, cnt, i, filter; uint32_t A1[6]; uint32_t A2[6]; uint32_t A3[6]; cnt = cmd_sscanf(cmd, "f=%d a1=%x:%x:%x:%x:%x:%x a2=%x:%x:%x:%x:%x:%x a3=%x:%x:%x:%x:%x:%x", &filter, &A1[0], &A1[1], &A1[2], &A1[3], &A1[4], &A1[5], &A2[0], &A2[1], &A2[2], &A2[3], &A2[4], &A2[5], &A3[0], &A3[1], &A3[2], &A3[3], &A3[4], &A3[5]); if (cnt != 19) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (filter == 1) { for (i = 0; i < 6; i++) { g_frm_filter.Filter1.MacAddrA1[i] = (uint8_t)A1[i]; g_frm_filter.Filter1.MacAddrA2[i] = (uint8_t)A2[i]; g_frm_filter.Filter1.MacAddrA3[i] = (uint8_t)A3[i]; } } else if (filter == 2) { for (i = 0; i < 6; i++) { g_frm_filter.Filter2.MacAddrA1[i] = (uint8_t)A1[i]; g_frm_filter.Filter2.MacAddrA2[i] = (uint8_t)A2[i]; g_frm_filter.Filter2.MacAddrA3[i] = (uint8_t)A3[i]; } } else { CMD_ERR("%s: invalid filter type:%d\n", __func__, filter); return CMD_STATUS_ACKED; } if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_frm_filter(char *cmd) { int ret; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_FRM_FILTER, (int)(&g_frm_filter)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_rcv_frm_filter1_ie_cfg(char *cmd) { int ret = 0, cnt, i; rcv_frm_filter_t *param; param = &(g_frm_filter.Filter1); int enable, filter, and_mask, or_mask, frm_type, mac_mask, ie_id, ie_len; uint32_t oui[10]; cnt = cmd_sscanf(cmd, "e=%d f=0x%x am=0x%x om=0x%x t=0x%x mm=0x%x ii=%d il=%d oui=%x %x %x %x %x %x %x %x %x %x ", &enable, &filter, &and_mask, &or_mask, &frm_type, &mac_mask, &ie_id, &ie_len, &oui[0], &oui[1], &oui[2], &oui[3], &oui[4], &oui[5], &oui[6], &oui[7], &oui[8], &oui[9]); if (cnt != 18) { printf("cnt %d\n", cnt); if ((cnt == 6) || (cnt == 1)) { ie_len = 0; } else { return CMD_STATUS_INVALID_ARG; } } if (enable == 0) { g_frm_filter.Filter1Cfg = 0; cmd_memset(param, 0, sizeof(rcv_frm_filter_t)); return CMD_STATUS_OK; } g_frm_filter.Filter1Cfg = 1; param->FilterEnable = filter; param->AndOperationMask = and_mask; param->OrOperationMask = or_mask; param->FrameType = frm_type; param->MacAddrMask = mac_mask; param->IeCfg.ElementId = ie_id; param->IeCfg.Length = ie_len; if (cnt >= 8) { //CMD_WRN("IE Id:%d, Len:%d\n", ie_id, ie_len); for (i = 0; i < ie_len; i++) { param->IeCfg.OUI[i] = (uint8_t)oui[i]; //printf("OUI: num:%d origin::%x, set:%x\n", i, oui[i], param->IeCfg.OUI[i]); } } if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_rcv_frm_filter2_ie_cfg(char *cmd) { int ret = 0, cnt, i; rcv_frm_filter_t *param; param = &(g_frm_filter.Filter2); int enable, filter, and_mask, or_mask, frm_type, mac_mask, ie_id, ie_len; uint32_t oui[10]; cnt = cmd_sscanf(cmd, "e=%d f=0x%x am=0x%x om=0x%x t=0x%x mm=0x%x ii=%d il=%d oui=%x %x %x %x %x %x %x %x %x %x ", &enable, &filter, &and_mask, &or_mask, &frm_type, &mac_mask, &ie_id, &ie_len, &oui[0], &oui[1], &oui[2], &oui[3], &oui[4], &oui[5], &oui[6], &oui[7], &oui[8], &oui[9]); if (cnt != 18) { printf("cnt %d\n", cnt); //return CMD_STATUS_INVALID_ARG; } if (enable == 0) { g_frm_filter.Filter2Cfg = 0; cmd_memset(param, 0, sizeof(rcv_frm_filter_t)); return CMD_STATUS_OK; } g_frm_filter.Filter2Cfg = 1; param->FilterEnable = filter; param->AndOperationMask = and_mask; param->OrOperationMask = or_mask; param->FrameType = frm_type; param->MacAddrMask = mac_mask; param->IeCfg.ElementId = ie_id; param->IeCfg.Length = ie_len; for (i = 0; i < ie_len; i++) param->IeCfg.OUI[i] = (uint8_t)oui[i]; if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_rcv_frm_filter1_pl_cfg(char *cmd) { int ret = 0, cnt, i; rcv_frm_filter_t *param; param = &(g_frm_filter.Filter1); int enable, filter, and_mask, or_mask, frm_type, mac_mask, pl_offset, pl_len; uint32_t payload[10]; cnt = cmd_sscanf(cmd, "e=%d f=0x%x am=0x%x om=0x%x t=0x%x mm=0x%x po=%d pl=%d p=%x %x %x %x %x %x %x %x %x %x ", &enable, &filter, &and_mask, &or_mask, &frm_type, &mac_mask, &pl_offset, &pl_len, &payload[0], &payload[1], &payload[2], &payload[3], &payload[4], &payload[5], &payload[6], &payload[7], &payload[8], &payload[9]); if (cnt != 18) { printf("cnt %d\n", cnt); //return CMD_STATUS_INVALID_ARG; } if (enable == 0) { g_frm_filter.Filter1Cfg = 0; cmd_memset(param, 0, sizeof(rcv_frm_filter_t)); return CMD_STATUS_ACKED; } g_frm_filter.Filter1Cfg = 1; param->FilterEnable = filter; param->AndOperationMask = and_mask; param->OrOperationMask = or_mask; param->FrameType = frm_type; param->MacAddrMask = mac_mask; param->PayloadCfg.PayloadOffset = pl_offset; param->PayloadCfg.PayloadLength = pl_len; for (i = 0; i < pl_len; i++) param->PayloadCfg.Payload[i] = (uint8_t)payload[i]; if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_rcv_frm_filter2_pl_cfg(char *cmd) { int ret = 0, cnt, i; rcv_frm_filter_t *param; param = &(g_frm_filter.Filter2); int enable, filter, and_mask, or_mask, frm_type, mac_mask, pl_offset, pl_len; uint32_t payload[10]; cnt = cmd_sscanf(cmd, "e=%d f=0x%x am=0x%x om=0x%x t=0x%x mm=0x%x po=%d pl=%d p=%x %x %x %x %x %x %x %x %x %x ", &enable, &filter, &and_mask, &or_mask, &frm_type, &mac_mask, &pl_offset, &pl_len, &payload[0], &payload[1], &payload[2], &payload[3], &payload[4], &payload[5], &payload[6], &payload[7], &payload[8], &payload[9]); if (cnt != 18) { printf("cnt %d\n", cnt); //return CMD_STATUS_INVALID_ARG; } if (enable == 0) { g_frm_filter.Filter2Cfg = 0; cmd_memset(param, 0, sizeof(rcv_frm_filter_t)); return CMD_STATUS_ACKED; } g_frm_filter.Filter2Cfg = 1; param->FilterEnable = filter; param->AndOperationMask = and_mask; param->OrOperationMask = or_mask; param->FrameType = frm_type; param->MacAddrMask = mac_mask; param->PayloadCfg.PayloadOffset = pl_offset; param->PayloadCfg.PayloadLength = pl_len; for (i = 0; i < pl_len; i++) param->PayloadCfg.Payload[i] = (uint8_t)payload[i]; if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } #define FRM_TYPE_ASRQ (0) #define FRM_TYPE_ASRSP (1) #define FRM_TYPE_RSRQ (2) #define FRM_TYPE_RSRSP (3) #define FRM_TYPE_PBRQ (4) #define FRM_TYPE_PBRSP (5) #define FRM_TYPE_BCN (6) #define FRM_TYPE_ATIM (7) #define FRM_TYPE_DAS (8) #define FRM_TYPE_AUTH (9) #define FRM_TYPE_DAUTH (10) #define FRM_TYPE_ACTION (11) #define FRM_TYPE_NULLDATA (12) #define FRM_TYPE_DATA (13) #define FRM_TYPE_QOSDATA (14) #define FRM_TYPE_ARPREQ (15) #define FRM_TYPE_SA_QUERY (16) #define FRM_TYPE_MANAGER (17) #define FRM_TYPE_ALL_DATA (18) #define FRM_TYPE_MAX (19) static wlan_ext_temp_frm_set_t frm; static uint8_t bssid[6] = {0x14, 0x72, 0x58, 0x36, 0x90, 0xaa}; static uint8_t src_mac[6] = {0x14, 0x72, 0x58, 0x36, 0x90, 0xaa}; static uint8_t dest_mac[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; static const char *ssid = "AP_test"; static uint8_t ap_channel = 1; static uint8_t src_ip[4] = {192, 168, 51, 123}; void buf_dump(unsigned char *buf, int len) { int i; for (i = 1; i < len + 1; i++) { printf("%02X ", buf[i-1]); if (i % 16 == 0) printf("\n"); } } void construct_frame(int frm_type) { switch (frm_type) { case FRM_TYPE_ASRQ: frm.FrmLength = wlan_construct_assocreq((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid, (uint8_t *)ssid, strlen(ssid)); printf("send raw frame associate req (%d)\n", frm.FrmLength); break; case FRM_TYPE_ASRSP: frm.FrmLength = wlan_construct_assocrsp((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame associate rsp (%d)\n", frm.FrmLength); break; case FRM_TYPE_RSRQ: frm.FrmLength = wlan_construct_reassocreq((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid, (uint8_t *)ssid, strlen(ssid)); printf("send raw frame reassociate req (%d)\n", frm.FrmLength); break; case FRM_TYPE_RSRSP: frm.FrmLength = wlan_construct_reassocrsp((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame reassociate rsp (%d)\n", frm.FrmLength); break; case FRM_TYPE_PBRQ: frm.FrmLength = wlan_construct_probereq((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid, (uint8_t *)ssid, strlen(ssid)); printf("send raw frame probe req (%d)\n", frm.FrmLength); break; case FRM_TYPE_PBRSP: frm.FrmLength = wlan_construct_probersp((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid, (uint8_t *)ssid, strlen(ssid), ap_channel); printf("send raw frame probe rsp (%d)\n", frm.FrmLength); break; case FRM_TYPE_BCN: frm.FrmLength = wlan_construct_beacon((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid, (uint8_t *)ssid, strlen(ssid), ap_channel); printf("send raw frame beacon (%d)\n", frm.FrmLength); break; case FRM_TYPE_ATIM: frm.FrmLength = wlan_construct_atim((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame atim (%d)\n", frm.FrmLength); break; case FRM_TYPE_DAS: frm.FrmLength = wlan_construct_disassocreq((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame disassociate req (%d)\n", frm.FrmLength); break; case FRM_TYPE_AUTH: frm.FrmLength = wlan_construct_auth((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame auth (%d)\n", frm.FrmLength); break; case FRM_TYPE_DAUTH: frm.FrmLength = wlan_construct_deauth((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame deauth (%d)\n", frm.FrmLength); break; case FRM_TYPE_ACTION: frm.FrmLength = wlan_construct_action((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame action (%d)\n", frm.FrmLength); break; case FRM_TYPE_NULLDATA: frm.FrmLength = wlan_construct_nulldata((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame nulldata (%d)\n", frm.FrmLength); break; case FRM_TYPE_DATA: frm.FrmLength = wlan_construct_data((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame data (%d)\n", frm.FrmLength); break; case FRM_TYPE_QOSDATA: frm.FrmLength = wlan_construct_qosdata((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame qosdata (%d)\n", frm.FrmLength); break; case FRM_TYPE_ARPREQ: frm.FrmLength = wlan_construct_arpreq((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid, src_ip); printf("send raw frame arp req (%d)\n", frm.FrmLength); break; case FRM_TYPE_SA_QUERY: frm.FrmLength = wlan_construct_sa_query((uint8_t *)frm.Frame, MAX_FRM_LEN, src_mac, dest_mac, bssid); printf("send raw frame sa query (%d)\n", frm.FrmLength); break; } } static enum cmd_status cmd_wlan_set_temp_frm(char *cmd) { int ret, cnt, frm_type; cnt = cmd_sscanf(cmd, "t=%d", &frm_type); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } construct_frame(frm_type); if (frm_type != FRM_TYPE_BCN && frm_type != FRM_TYPE_PBRSP) { printf("force add TSF\n"); for (int i = 0; i < frm.FrmLength - 24; i++) { frm.Frame[frm.FrmLength - 1 - i + 10] = frm.Frame[frm.FrmLength - 1 - i]; } frm.Frame[32] = 0x64; frm.Frame[33] = 0; frm.FrmLength += 10; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_TEMP_FRM, (int)(&frm)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_send_sync_frm(char *cmd) { int ret, cnt; uint32_t bcn_intvl, enable; wlan_ext_send_sync_frm_set_t param; cnt = cmd_sscanf(cmd, "e=%d b=%d", &enable, &bcn_intvl); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } memset(¶m, 0, sizeof(wlan_ext_send_sync_frm_set_t)); param.Enable = enable; param.BcnInterval = bcn_intvl; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SYNC_FRM_SEND, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_send_raw_frm(char *cmd) { int ret = 0, i, j, cnt, ext_ch, cur_ch, tmp_ch; int frm_cnt, frm_period, frm_type; uint32_t mac_sa[6]; uint32_t mac_da[6]; uint32_t mac_bssid[6]; struct netif *nif; cnt = cmd_sscanf(cmd, "c=%d p=%d t=%d ec=%d da=%x:%x:%x:%x:%x:%x sa=%x:%x:%x:%x:%x:%x bssid=%x:%x:%x:%x:%x:%x", &frm_cnt, &frm_period, &frm_type, &ext_ch, &mac_da[0], &mac_da[1], &mac_da[2], &mac_da[3], &mac_da[4], &mac_da[5], &mac_sa[0], &mac_sa[1], &mac_sa[2], &mac_sa[3], &mac_sa[4], &mac_sa[5], &mac_bssid[0], &mac_bssid[1], &mac_bssid[2], &mac_bssid[3], &mac_bssid[4], &mac_bssid[5]); if (cnt < 4) { CMD_ERR("invalid param cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (cnt >= 10) { for (i = 0; i < 6; i++) dest_mac[i] = (uint8_t)mac_da[i]; } if (cnt >= 16) { for (i = 0; i < 6; i++) src_mac[i] = (uint8_t)mac_sa[i]; } if (cnt == 22) { for (i = 0; i < 6; i++) bssid[i] = (uint8_t)mac_bssid[i]; } printf("dest mac address:%02x:%02x:%02x:%02x:%02x:%02x\n", dest_mac[0], dest_mac[1], dest_mac[2], dest_mac[3], dest_mac[4], dest_mac[5]); printf("src mac address:%02x:%02x:%02x:%02x:%02x:%02x\n", src_mac[0], src_mac[1], src_mac[2], src_mac[3], src_mac[4], src_mac[5]); printf("bssid address:%02x:%02x:%02x:%02x:%02x:%02x\n", bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]); nif = CMD_WLAN_NETIF; switch (frm_type) { case FRM_TYPE_MANAGER: printf("send all manager frame\n"); cnt = 0; for (i = 0; i < frm_cnt; i++) { for (j = 0; j < 12; j++) { cmd_memset((uint8_t *)frm.Frame, 0, MAX_FRM_LEN); construct_frame(j); wlan_send_raw_frame(nif, IEEE80211_FC_STYPE_AUTH, (uint8_t *)frm.Frame, frm.FrmLength); OS_MSleep(frm_period); printf("******************************** cnt:%d ********************************\n", cnt++); } } return CMD_STATUS_OK; case FRM_TYPE_ALL_DATA: printf("send all data frame\n"); cnt = 0; for (i = 0; i < frm_cnt; i++) { for (j = 0; j < 6; j++) dest_mac[j] = (uint8_t)mac_da[j]; for (j = 12; j < 15; j++) { cmd_memset((uint8_t *)frm.Frame, 0, MAX_FRM_LEN); construct_frame(j); wlan_send_raw_frame(nif, IEEE80211_FC_STYPE_AUTH, (uint8_t *)frm.Frame, frm.FrmLength); OS_MSleep(frm_period); printf("******************************** cnt:%d ********************************\n", cnt++); } //send broadcast data frame cmd_memset(dest_mac, 0xff, 6); cmd_memset((uint8_t *)frm.Frame, 0, MAX_FRM_LEN); construct_frame(FRM_TYPE_DATA); wlan_send_raw_frame(nif, IEEE80211_FC_STYPE_AUTH, (uint8_t *)frm.Frame, frm.FrmLength); OS_MSleep(frm_period); printf("******************************** cnt:%d ********************************\n", cnt++); } return CMD_STATUS_OK; case FRM_TYPE_MAX: { printf("send all frame\n"); wlan_ext_request(nif, WLAN_EXT_CMD_GET_CURRENT_CHN, (int)(&cur_ch)); wlan_ext_switch_channel_param_set_t param1; memset(¶m1, 0, sizeof(wlan_ext_switch_channel_param_set_t)); param1.Enable = 1; param1.SwitchChannelTime = 5000;//SEND_RAW_FRAME_MAX_SWITCH_CHANNEL_TIME; cnt = 0; for (i = 0; i < frm_cnt; i++) { for (j = 0; j < 6; j++) dest_mac[j] = (uint8_t)mac_da[j]; for (j = 0; j < 17; j++) { cmd_memset((uint8_t *)frm.Frame, 0, MAX_FRM_LEN); construct_frame(j); wlan_send_raw_frame(nif, IEEE80211_FC_STYPE_AUTH, (uint8_t *)frm.Frame, frm.FrmLength); OS_MSleep(frm_period); if (ext_ch) { param1.ChannelNum = ext_ch; wlan_ext_request(nif, WLAN_EXT_CMD_SET_SWITCH_CHN_CFG, (int)(¶m1)); do { OS_MSleep(10); wlan_ext_request(nif, WLAN_EXT_CMD_GET_CURRENT_CHN, (int)(&tmp_ch)); } while (tmp_ch != ext_ch); printf("switch to channel %d\n", ext_ch); wlan_send_raw_frame(nif, IEEE80211_FC_STYPE_AUTH, (uint8_t *)frm.Frame, frm.FrmLength); OS_MSleep(100); param1.ChannelNum = cur_ch; wlan_ext_request(nif, WLAN_EXT_CMD_SET_SWITCH_CHN_CFG, (int)(¶m1)); do { OS_MSleep(5); wlan_ext_request(nif, WLAN_EXT_CMD_GET_CURRENT_CHN, (int)(&tmp_ch)); } while (tmp_ch != cur_ch); printf("switch to channel %d\n", cur_ch); OS_MSleep(frm_period); } printf("******************************** cnt:%d ********************************\n", cnt++); } cmd_memset(dest_mac, 0xff, 6); cmd_memset((uint8_t *)frm.Frame, 0, MAX_FRM_LEN); construct_frame(FRM_TYPE_DATA); wlan_send_raw_frame(nif, IEEE80211_FC_STYPE_AUTH, (uint8_t *)frm.Frame, frm.FrmLength); OS_MSleep(frm_period); if (ext_ch) { param1.ChannelNum = ext_ch; wlan_ext_request(nif, WLAN_EXT_CMD_SET_SWITCH_CHN_CFG, (int)(¶m1)); do { OS_MSleep(10); wlan_ext_request(nif, WLAN_EXT_CMD_GET_CURRENT_CHN, (int)(&tmp_ch)); } while (tmp_ch != ext_ch); printf("switch to channel %d\n", ext_ch); wlan_send_raw_frame(nif, IEEE80211_FC_STYPE_AUTH, (uint8_t *)frm.Frame, frm.FrmLength); OS_MSleep(100); param1.ChannelNum = cur_ch; wlan_ext_request(nif, WLAN_EXT_CMD_SET_SWITCH_CHN_CFG, (int)(¶m1)); do { OS_MSleep(5); wlan_ext_request(nif, WLAN_EXT_CMD_GET_CURRENT_CHN, (int)(&tmp_ch)); } while (tmp_ch != cur_ch); printf("switch to channel %d\n", cur_ch); OS_MSleep(frm_period); } printf("******************************** cnt:%d ********************************\n", cnt++); } } return CMD_STATUS_OK; default: construct_frame(frm_type); break; } buf_dump((uint8_t *)frm.Frame, frm.FrmLength); for (i = 0; i < frm_cnt; i++) { ret = wlan_send_raw_frame(nif, IEEE80211_FC_STYPE_AUTH, (uint8_t *)frm.Frame, frm.FrmLength); printf("cnt:%d\n", i+1); if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } OS_MSleep(frm_period); } if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_sniff_ext_param(char *cmd) { int ret, cnt; int enable, retry, expenRight, dtim; wlan_ext_sniff_extern_param_set_t param; cnt = cmd_sscanf(cmd, "e=0x%x r=%d er=%d d=%d", &enable, &retry, &expenRight, &dtim); if (cnt != 4) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } param.SniffExtFuncEnable = enable; param.SniffRetryAfterLostSync = retry; param.SniffAdaptiveExpenRight = expenRight; param.SniffRetryDtim = dtim; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SNIFF_EXTERN_CFG, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_rcv_stat(char *cmd) { int ret, i; unsigned int sum_cnt = 0; int sum_avg = 0; wlan_ext_bcn_status_t bcn_status; char dly_info[][20] = { "(<0 )", "(<500us )", "(<1000us )", "(<2000us )", "(<4000us )", "(<8000us )", "(<16000us)", "(>16000us)", }; cmd_memset(&bcn_status, 0, sizeof(wlan_ext_bcn_status_t)); ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_GET_SNIFF_STAT, (uint32_t)&bcn_status); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } printf("\nAPP AP Beacon Delay Stat Info=================\n"); for (i = 0; i < 8; i++) { printf("cnt %d %s: %d\n", i, dly_info[i], bcn_status.bcn_delay_cnt[i]); sum_cnt += bcn_status.bcn_delay_cnt[i]; } if (sum_cnt) sum_avg = bcn_status.bcn_delay_sum / sum_cnt; printf("Dur: %d, Max: 0x%X, Rxed: %d, Missed: 0x%X\n", bcn_status.bcn_duration, bcn_status.bcn_delay_max, bcn_status.bcn_rx_cnt, bcn_status.bcn_miss_cnt); printf("Sum: %d, Cnt: %d, Ava: %d\n", bcn_status.bcn_delay_sum, sum_cnt, sum_avg); printf("APP AP Beacon Delay Stat Info=================\n"); return CMD_STATUS_OK; } static uint32_t g_frm_rcv_cnt = 0; static uint32_t g_frm_rcv_mac_cnt = 0; void sta_rx_cb(uint8_t *data, uint32_t len, void *info) { if (!info) { printf("%s(), info NULL\n", __func__); return; } struct ieee80211_frame *wh; uint8_t filter_mac[6] = {0x14, 0x72, 0x58, 0x36, 0x90, 0xaa}; wh = (struct ieee80211_frame *)data; g_frm_rcv_cnt++; if (memcmp(wh->i_addr3, filter_mac, 6) == 0) { g_frm_rcv_mac_cnt++; } char *str_frm_type; switch (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) { case IEEE80211_FC0_TYPE_MGT: switch (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) { case IEEE80211_FC_STYPE_ASSOC_REQ: str_frm_type = "association req"; break; case IEEE80211_FC_STYPE_ASSOC_RESP: str_frm_type = "association resp"; break; case IEEE80211_FC_STYPE_REASSOC_REQ: str_frm_type = "reassociation req"; break; case IEEE80211_FC_STYPE_REASSOC_RESP: str_frm_type = "reassociation resp"; break; case IEEE80211_FC_STYPE_PROBE_REQ: str_frm_type = "probe req"; break; case IEEE80211_FC_STYPE_PROBE_RESP: str_frm_type = "probe resp"; break; case IEEE80211_FC_STYPE_BEACON: str_frm_type = "beacon"; break; case IEEE80211_FC_STYPE_ATIM: str_frm_type = "atim"; break; case IEEE80211_FC_STYPE_DISASSOC: str_frm_type = "disassociation"; break; case IEEE80211_FC_STYPE_AUTH: str_frm_type = "authentication"; break; case IEEE80211_FC_STYPE_DEAUTH: str_frm_type = "deauthentication"; break; case IEEE80211_FC_STYPE_ACTION: str_frm_type = "action"; break; default: str_frm_type = "unknown mgmt"; break; } break; case IEEE80211_FC0_TYPE_CTL: str_frm_type = "control"; break; case IEEE80211_FC0_TYPE_DATA: #if 0 switch (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) { case IEEE80211_FC0_SUBTYPE_DATA: str_frm_type = "data"; break; case IEEE80211_FC0_SUBTYPE_QOS: str_frm_type = "qos data"; break; case IEEE80211_FC0_SUBTYPE_NODATA: str_frm_type = "null data"; break; default: str_frm_type = "unknown data"; break; } #else str_frm_type = "data"; #endif break; default: str_frm_type = "unknown"; break; } printf("recv pack type:%s cnt:%d, mac cnt:%d, len:%d\n", str_frm_type, g_frm_rcv_cnt, g_frm_rcv_mac_cnt, len); } static enum cmd_status cmd_wlan_set_rcv_cb(char *cmd) { int cnt, enable; cnt = cmd_sscanf(cmd, "e=%d", &enable); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (enable) wlan_monitor_set_rx_cb(CMD_WLAN_NETIF, sta_rx_cb); else wlan_monitor_set_rx_cb(CMD_WLAN_NETIF, NULL); return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_even_ie(char *cmd) { int cnt, enable; uint8_t ie[7] = {0xDD, 0x05, 0x00, 0x50, 0xF2, 0x05, 0x01}; cnt = cmd_sscanf(cmd, "e=%d", &enable); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (enable) { ie[6]++; printf("Set event beacon!\n"); wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_UPDATE_TEMP_IE, (int)(ie)); } else { printf("Set normal beacon!\n"); wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_UPDATE_TEMP_IE, (int)(ie)); } return CMD_STATUS_OK; } #endif static enum cmd_status cmd_wlan_set_bcn_win_cfg(char *cmd) { int ret, cnt; int start_num, stop_num, amp_us, max_num; wlan_ext_bcn_win_param_set_t param; cnt = cmd_sscanf(cmd, "start=%d stop=%d amp=%d max=%d", &start_num, &stop_num, &_us, &max_num); if (cnt != 4) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } param.BeaconWindowAdjStartNum = start_num; param.BeaconWindowAdjStopNum = stop_num; param.BeaconWindowAdjAmpUs = amp_us; param.BeaconWindowMaxStartNum = max_num; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_BCN_WIN_CFG, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } // net wlan scan_freq n=1 c=7 // net wlan scan_freq n=4 c=1 6 7 14 static enum cmd_status cmd_wlan_scan_freq(char *cmd) { int ret, cnt; int num; int chn[14]; int freq[14]; wlan_ext_scan_freq_t param; cnt = cmd_sscanf(cmd, "n=%d c=%d %d %d %d %d %d %d %d %d %d %d %d %d %d", &num, &chn[0], &chn[1], &chn[2], &chn[3], &chn[4], &chn[5], &chn[6], &chn[7], &chn[8], &chn[9], &chn[10], &chn[11], &chn[12], &chn[13]); if (cnt < 2 || cnt > 15) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } if (num != cnt - 1) { CMD_ERR("%s: invalid num:%d\n", __func__, num); return CMD_STATUS_ACKED; } for (int i = 0; i < num; i++) { if (chn[i] == 14) { freq[i] = 2484; } else { freq[i] = 2407 + 5 * chn[i]; } } param.freq_num = num; param.freq_list = freq; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_SCAN_FREQ, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_pm(char *cmd) { int ret, cnt; int enable; cnt = cmd_sscanf(cmd, "e=%d", &enable); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_set_ps_mode(CMD_WLAN_NETIF, enable); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_temp_volt(char *cmd) { int ret; wlan_ext_temp_volt_get_t param; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_GET_TEMP_VOLT, (int)(¶m)); CMD_LOG(1, "Temperature:%.02f°C\n", (float)param.Temperature / 16); CMD_LOG(1, "Voltage:%.02fV\n", (float)param.Voltage / 16); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_temp_volt_auto_upload(char *cmd) { int ret, cnt; int enable, period; cnt = cmd_sscanf(cmd, "e=%d p=%d", &enable, &period); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } wlan_ext_temp_volt_auto_upload_set_t param; cmd_memset(¶m, 0, sizeof(wlan_ext_temp_volt_auto_upload_set_t)); param.Enable = enable; param.UploadPeriod = period; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_TEMP_VOLT_AUTO_UPLOAD, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_temp_volt_thresh(char *cmd) { int ret, cnt; int temp_high_en, temp_low_en, volt_high_en, volt_low_en; float temp_high_th, temp_low_th, volt_high_th, volt_low_th; cnt = cmd_sscanf(cmd, "THe=%d TH=%f TLe=%d TL=%f VHe=%d VH=%f VLe=%d VL=%f", &temp_high_en, &temp_high_th, &temp_low_en, &temp_low_th, &volt_high_en, &volt_high_th, &volt_low_en, &volt_low_th); if (cnt != 8) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } wlan_ext_temp_volt_thresh_set_t param; cmd_memset(¶m, 0, sizeof(wlan_ext_temp_volt_thresh_set_t)); param.TempHighEn = temp_high_en; param.TempHighThresh = temp_high_th * 16; param.TempLowEn = temp_low_en; param.TempLowThresh = temp_low_th * 16; param.VoltHighEn = volt_high_en; param.VoltHighThresh = volt_high_th * 16; param.VoltLowEn = volt_low_en; param.VoltLowThresh = volt_low_th * 16; param.TempVoltIndPeriod = 5; //param.TempVoltFallbackIndEn = 1; //param.TempUseDeltaEn = 1; //param.TempVoltFixedRefEn = 1; //param.TempJitterCnt = 50; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_TEMP_VOLT_THRESH, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_bcn_freq_offs_time(char *cmd) { int ret, cnt; int time; cnt = cmd_sscanf(cmd, "t=%d", &time); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_BCN_FREQ_OFFS_TIME, time); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_lfclock_param(char *cmd) { int ret, cnt; int type, freq, count; cnt = cmd_sscanf(cmd, "t=%d f=%d c=%d", &type, &freq, &count); if (cnt != 3) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } wlan_ext_lfclock_param_t param; cmd_memset(¶m, 0, sizeof(wlan_ext_lfclock_param_t)); param.SysLfclockType = type; param.SysLfclockFreq = freq; param.PwrCalibCount = count; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_LFCLOCK_PARAM, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_bcn_rx_11b_only(char *cmd) { int ret, cnt; uint32_t bcn_rx_11b_only_en; cnt = cmd_sscanf(cmd, "e=%d", &bcn_rx_11b_only_en); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_BCN_RX_11B_ONLY, (uint32_t)bcn_rx_11b_only_en); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } /* eg: net wlan bcn_lost_comp e=1 dl=1 ci=1 cc=5 */ static enum cmd_status cmd_wlan_set_bcn_lost_comp(char *cmd) { int ret, cnt; int enable; int dtim_lost; int comp_interval; int comp_count; wlan_ext_bcn_lost_comp_set_t param; cnt = cmd_sscanf(cmd, "e=%d dl=%d ci=%d cc=%d", &enable, &dtim_lost, &comp_interval, &comp_count); if (cnt != 4) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } memset(¶m, 0, sizeof(wlan_ext_bcn_lost_comp_set_t)); param.Enable = enable; param.DtimLostNum = dtim_lost; param.CompInterval = comp_interval; param.CompCnt = comp_count; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_BCN_LOST_COMP, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_ACKED; } /* eg: net wlan arp_reply_keep_alive p=48 senIp=192.168.51.100 tarIp=192.168.51.1 tarMac=xx:xx:xx:xx:xx:xx */ static enum cmd_status cmd_wlan_arp_reply_keep_alive(char *cmd) { int ret, cnt; uint32_t ArpKeepAlivePeriod; uint32_t sernder_ip[4]; uint32_t target_ip[4]; uint32_t target_mac[6]; cnt = cmd_sscanf(cmd, "p=%d senIp=%d.%d.%d.%d tarIp=%d.%d.%d.%d tarMac=%x:%x:%x:%x:%x:%x", &ArpKeepAlivePeriod, &sernder_ip[0], &sernder_ip[1], &sernder_ip[2], &sernder_ip[3], &target_ip[0], &target_ip[1], &target_ip[2], &target_ip[3], &target_mac[0], &target_mac[1], &target_mac[2], &target_mac[3], &target_mac[4], &target_mac[5]); if (cnt != 15) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } wlan_ext_arp_kpalive_set_t param; memset(¶m, 0, sizeof(wlan_ext_arp_kpalive_set_t)); param.ArpKeepAlivePeriod = (uint16_t)ArpKeepAlivePeriod; for (int i = 0; i < 4; i++) { param.SenderIpv4IpAddress[i] = (uint8_t)sernder_ip[i]; param.TargetIpv4IpAddress[i] = (uint8_t)target_ip[i]; } for (int i = 0; i < 6; i++) { param.TargetMacAddress[i] = (uint8_t)target_mac[i]; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_ARP_KPALIVE, (uint32_t)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_ACKED; } /* net wlan set_bcn_auto m= t= p= l= * net wlan set_bcn_auto_offset m=7 b=6 t=2 p=20 l=2 * : [0-7], 0: close auto offset awlays, 1: 1000us-2000us, 2: 2000us-3000us, 3: 3000us-4000us ... * : [0-255], the number of statistics beacons * : [0-255], the threshold for open Auto Offset Function * : [0-255], the percentage of adjust * : [0-255], the number of consecutively lost beacon */ #if SUPPORT_BCN_AUTO_OFFSET static enum cmd_status cmd_wlan_set_bcn_auto_offset(char *cmd) { int ret, cnt; uint32_t auto_offset_mode; uint32_t bcn_statistics; uint32_t auto_offset_open_threshold; uint32_t auto_offset_percentage; uint32_t bcn_lost_max_num; wlan_ext_bcn_auto_offset_t bcn_auto_offset; struct netif *nif; cnt = cmd_sscanf(cmd, "m=%d b=%d t=%d p=%d l=%d", &auto_offset_mode, &bcn_statistics, &auto_offset_open_threshold, &auto_offset_percentage, &bcn_lost_max_num); if (cnt != 5) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } bcn_auto_offset.auto_offset_mode = (uint8_t)auto_offset_mode; bcn_auto_offset.bcn_statistics = (uint8_t)bcn_statistics; bcn_auto_offset.auto_offset_open_threshold = (uint8_t)auto_offset_open_threshold; bcn_auto_offset.auto_offset_percentage = (uint8_t)auto_offset_percentage; bcn_auto_offset.bcn_lost_max_num = (uint8_t)bcn_lost_max_num; nif = CMD_WLAN_NETIF; ret = wlan_ext_request(nif, WLAN_EXT_CMD_AUTO_BCN_OFFSET_SET, (uint32_t)&bcn_auto_offset); if (ret == -2) { CMD_ERR("%s: WLAN_EXT_CMD_AUTO_BCN_OFFSET_SET command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: WLAN_EXT_CMD_AUTO_BCN_OFFSET_SET command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } ret = wlan_ext_request(nif, WLAN_EXT_CMD_AUTO_BCN_OFFSET_READ, (uint32_t)&bcn_auto_offset); if (ret == -2) { CMD_ERR("%s: WLAN_EXT_CMD_AUTO_BCN_OFFSET_READ command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: WLAN_EXT_CMD_AUTO_BCN_OFFSET_READ command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } CMD_LOG(1, "mode:%d, statistics:%d, threshold:%d, percentage:%d%%, BcnlostMax:%d\n", bcn_auto_offset.auto_offset_mode, bcn_auto_offset.bcn_statistics, bcn_auto_offset.auto_offset_open_threshold, bcn_auto_offset.auto_offset_percentage, bcn_auto_offset.bcn_lost_max_num); return CMD_STATUS_OK; } #endif static enum cmd_status cmd_wlan_set_pre_rx_bcn(char *cmd) { int ret, cnt; uint32_t enable, flag, stop_num; wlan_ext_pre_rx_bcn_t param; cnt = cmd_sscanf(cmd, "e=%d f=0x%x s=%d", &enable, &flag, &stop_num); if (cnt != 3) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } param.enable = enable; param.flags = flag; param.stop_num = stop_num; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_PRE_RX_BCN, (uint32_t)¶m); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_stay_awake_tmo(char *cmd) { int ret, cnt; uint32_t tmo; cnt = cmd_sscanf(cmd, "t=%d", &tmo); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_SET_STAY_AWAKE_TMO, tmo); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_auto_power(char *cmd) { int ret, cnt; float pwr_step; uint32_t period, rssi_thres, max_rssi, min_rssi; wlan_ext_auto_power_t param; cnt = cmd_sscanf(cmd, "p=%d s=%f t=%d max=%d min=%d", &period, &pwr_step, &rssi_thres, &max_rssi, &min_rssi); if (cnt != 5) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } param.period = period; param.pwr_step = pwr_step * 10; param.rssi_thres = rssi_thres; param.max_rssi = max_rssi; param.min_rssi = min_rssi; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_AUTO_POWER, (uint32_t)¶m); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_chk_bcn_without_data(char *cmd) { int ret, cnt; uint32_t enable, count; wlan_ext_chk_bcn_without_data_set_t param; cnt = cmd_sscanf(cmd, "e=%d c=%d", &enable, &count); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } param.enable = enable; param.beacon_count = count; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_BCN_WITHOUT_DATA, (uint32_t)¶m); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_bcn_tim_no_data_tmo(char *cmd) { int ret, cnt; uint32_t enable, tmo; wlan_ext_bcn_tim_no_data_tmo_set_t param; cnt = cmd_sscanf(cmd, "e=%d t=%d", &enable, &tmo); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } param.enable = enable; param.timeout_ms = tmo; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_BCN_TIM_NO_DATA_TMO, (uint32_t)¶m); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } /* eg: net wlan set_filter_type ft=0x1 :FW filter AP BAR frame after Host standby net wlan set_filter_type ft=0x2 :FW filter AP PING frame after Host standby net wlan set_filter_type ft=0x3 :FW filter AP BAR frame and Ping after Host standby net wlan set_filter_type ft=0x0 :disable filter */ static enum cmd_status cmd_wlan_set_filter_type(char *cmd) { int ret; uint32_t type; int cnt; cnt = cmd_sscanf(cmd, "ft=0x%x", &type); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_SET_FILTER_TYPE, type); CMD_LOG(1, "set_filter_type:%x\n", type); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_low_power_param(char *cmd) { int ret, cnt; uint32_t period; cnt = cmd_sscanf(cmd, "p=%d", &period); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_low_power_param_set_default(period); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_stats_code(char *cmd) { int ret; wlan_ext_stats_code_get_t param; ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_GET_STATS_CODE, (uint32_t)(¶m)); CMD_LOG(1, "reason code:%d status code:%d\n", param.reason_code, param.status_code); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } /* eg: net wlan set_auth_tmo_and_tries tmo=100 tries=10 */ static enum cmd_status cmd_wlan_set_auth_tmo_and_tries(char *cmd) { int ret; int cnt; int tmo, tries; wlan_ext_mgmt_timeout_and_tries_set_t param; cnt = cmd_sscanf(cmd, "tmo=%d tries=%d", &tmo, &tries); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } cmd_memset(¶m, 0, sizeof(wlan_ext_mgmt_timeout_and_tries_set_t)); param.timeout = tmo; param.tries = tries; ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_SET_AUTH_TMO_AND_TRIES, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } /* eg: net wlan set_assoc_tmo_and_tries tmo=100 tries=10 */ static enum cmd_status cmd_wlan_set_assoc_tmo_and_tries(char *cmd) { int ret; int cnt; int tmo, tries; wlan_ext_mgmt_timeout_and_tries_set_t param; cnt = cmd_sscanf(cmd, "tmo=%d tries=%d", &tmo, &tries); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } cmd_memset(¶m, 0, sizeof(wlan_ext_mgmt_timeout_and_tries_set_t)); param.timeout = tmo; param.tries = tries; ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_SET_ASSOC_TMO_AND_TRIES, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_set_bss_loss_thold(char *cmd) { int ret, cnt; uint32_t bss_loss_thold, link_loss_thold; wlan_ext_bss_loss_thold_set_t param; cnt = cmd_sscanf(cmd, "b=%d l=%d", &bss_loss_thold, &link_loss_thold); if (cnt != 2) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } cmd_memset(¶m, 0, sizeof(wlan_ext_bss_loss_thold_set_t)); param.bss_loss_thold = bss_loss_thold; param.link_loss_thold = link_loss_thold; ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_SET_BSS_LOSS_THOLD, (int)(¶m)); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } #if MONITOR_RX_HT40_PHY_INFO int enable_rx_ext_frame(void) /* fw only monitor work*/ { int ret = 0; MIB_SET_RX_EXT_FRAME ext_frame_param; memset(&ext_frame_param, 0, sizeof(MIB_SET_RX_EXT_FRAME)); ext_frame_param.rx_enable = 1; ext_frame_param.filter_en = RX_EXT_FRAME_FILTER_SIZE; ext_frame_param.size_min = 24; ext_frame_param.size_max = 600; /* 9bit data, 512*/ struct netif *nif = CMD_WLAN_NETIF; if (nif == NULL) { CMD_ERR("%s, %d, warning: netif is null\n", __func__, __LINE__); return -1; } ret = wlan_ext_request(nif, WLAN_EXT_CMD_SET_MIMO_PARAM, (uint32_t)&ext_frame_param); if (ret == -2) { CMD_ERR("invalid arg\n"); } else if (ret == -1) { CMD_ERR("exec failed\n"); } return ret; } int disable_rx_ext_frame(void) /* fw only monitor work*/ { int ret = 0; MIB_SET_RX_EXT_FRAME ext_frame_param; memset(&ext_frame_param, 0, sizeof(MIB_SET_RX_EXT_FRAME)); ext_frame_param.rx_enable = 0; struct netif *nif = CMD_WLAN_NETIF; if (nif == NULL) { CMD_ERR("%s, %d, warning: netif is null\n", __func__, __LINE__); return -1; } ret = wlan_ext_request(nif, WLAN_EXT_CMD_SET_MIMO_PARAM, (uint32_t)&ext_frame_param); if (ret == -2) { CMD_ERR("invalid arg\n"); } else if (ret == -1) { CMD_ERR("exec failed\n"); } return ret; } static enum cmd_status cmd_mimo_start_exec(char *cmd) { enable_rx_ext_frame(); return CMD_STATUS_OK; } /* $ sniffer_stop */ static enum cmd_status cmd_mimo_stop_exec(char *cmd) { disable_rx_ext_frame(); return CMD_STATUS_OK; } #endif #if AP_SNIFFER static uint32_t sniffer_rx_total_cnt; static uint32_t statistics_start_time; static uint32_t statistics_end_time; static int pkt_print_enable; //#define AUTH_FRAME_OPEN_LEN 30 #define AUTH_FRAME_OPEN_LEN 38 #define BEACON_FRAME_LEN 256 static uint8_t auth_frame_open[AUTH_FRAME_OPEN_LEN]; static uint8_t beacon_frame_buf[BEACON_FRAME_LEN]; typedef struct { uint8_t *data; uint32_t len; } frame_data; static frame_data auth_frame; static uint8_t auth_tx_cnt; static uint8_t monitor_run = 0; static OS_Thread_t monitor_thread; static uint8_t assist_test_ap_chan; static uint8_t assist_test_ap_mac[6] = {0x6c, 0x59, 0x40, 0x9d, 0x68, 0x6a}; static uint8_t sniffer_run = 0; static uint8_t sniffer_channels[] = { 1, 6, 11, 7, 13, 2, 3, 4, 5, 8, 9, 10, 12, 14 }; static OS_Thread_t sniffer_thread; extern enum cmd_status cmd_lmac_exec(char *cmd); extern int wlan_send_raw_frame(struct netif *nif, int type, uint8_t *buffer, int len); static int char2hex(char c, u8_t *x) { if (c >= '0' && c <= '9') { *x = c - '0'; } else if (c >= 'a' && c <= 'f') { *x = c - 'a' + 10; } else if (c >= 'A' && c <= 'F') { *x = c - 'A' + 10; } else { return -EINVAL; } return 0; } static int addr_from_str(char *str, uint8_t *addr) { int i, j; uint8_t tmp; if (strlen(str) != 17U) { return -EINVAL; } for (i = 0, j = 1; *str != '\0'; str++, j++) { if (!(j % 3) && (*str != ':')) { return -EINVAL; } else if (*str == ':') { i++; continue; } addr[i] = addr[i] << 4; if (char2hex(*str, &tmp) < 0) { return -EINVAL; } addr[i] |= tmp; } return 0; } static enum cmd_status cmd_sniffer_set_assist_test_ap_addr_exec(char *cmd) { char buf[35] = {0}; char buf1[50] = {0}; int len = 0; char *str = "addr ap "; len = strlen(str); sprintf(buf1, str); cmd_sscanf(cmd, "%s", buf); sprintf(&buf1[len], buf); addr_from_str(buf, assist_test_ap_mac); CMD_DBG("assist_test_ap_addr %02x:%02x:%02x:%02x:%02x:%02x\n", assist_test_ap_mac[0], assist_test_ap_mac[1], assist_test_ap_mac[2], assist_test_ap_mac[3], assist_test_ap_mac[4], assist_test_ap_mac[5]); cmd_lmac_exec(buf1); return CMD_STATUS_OK; } static void auth_frame_creat(void) { auth_frame_open[0] = 0xB0; /* auth frame */ auth_frame_open[2] = 0x3A; /* duartion */ auth_frame_open[3] = 0x01; memcpy(&auth_frame_open[10], CMD_WLAN_NETIF->hwaddr, IEEE80211_ADDR_LEN); auth_frame_open[22] = 0x06; /* seq number */ //auth_frame_open[24] = 0x0; /* open system */ auth_frame_open[26] = 0x01; /* auth seq num */ auth_frame_open[30] = 221; /* auth special ie */ auth_frame_open[31] = 1; auth_frame_open[32] = auth_tx_cnt; //printf("cnt %d\n", auth_cnt); auth_tx_cnt++; if (auth_tx_cnt == 255) auth_tx_cnt = 0; //auth_frame_open[32] = 'f'; //auth_frame_open[33] = 'i'; //auth_frame_open[34] = 'l'; //auth_frame_open[35] = 't'; //auth_frame_open[36] = 'e'; //auth_frame_open[37] = 'r'; struct ieee80211_frame *frame = NULL; frame = (struct ieee80211_frame *)auth_frame_open; auth_frame.data = (uint8_t *)frame; memcpy(frame->i_addr1, assist_test_ap_mac, IEEE80211_ADDR_LEN); memcpy(frame->i_addr3, assist_test_ap_mac, IEEE80211_ADDR_LEN); auth_frame.len = AUTH_FRAME_OPEN_LEN; } static void send_auth_frame(void) { wlan_send_raw_frame(CMD_WLAN_NETIF, IEEE80211_FC_STYPE_AUTH, auth_frame.data, auth_frame.len); } #if BEACON_TX static uint8_t beacon_addr[6]; static uint8_t beacon_chan; static char beacon_ssid[32]; static uint32_t beacon_len; static frame_data beacon_frame; static void beacon_frame_creat(void) { wlan_ap_config_t config; cmd_memset(&config, 0, sizeof(config)); config.field = WLAN_AP_FIELD_SSID; if (wlan_ap_get_config(&config) != 0) { CMD_ERR("get config failed\n"); return; } CMD_DBG("ssid:%s,ssid_len %d\n", config.u.ssid.ssid, config.u.ssid.ssid_len); memcpy(beacon_ssid, config.u.ssid.ssid, config.u.ssid.ssid_len); memcpy(beacon_addr, CMD_WLAN_NETIF->hwaddr, IEEE80211_ADDR_LEN); beacon_len = wlan_construct_beacon(beacon_frame_buf, BEACON_FRAME_LEN, beacon_addr, NULL, beacon_addr, (uint8_t *)beacon_ssid, config.u.ssid.ssid_len, beacon_chan); beacon_frame.data = beacon_frame_buf; beacon_frame.len = beacon_len; CMD_DBG("beacon_len %d\n", beacon_len); } static void send_beacon_frame(void) { wlan_send_raw_frame(CMD_WLAN_NETIF, IEEE80211_FC_STYPE_AUTH, beacon_frame.data, beacon_frame.len); } #endif static int wifi_set_channel(uint8_t chan) { struct netif *nif = CMD_WLAN_NETIF; if (nif == NULL) { CMD_ERR("%s, %d, warning: netif is null\n", __func__, __LINE__); return 0; } enum wlan_mode mode = wlan_netif_get_mode(nif); //CMD_DBG("chann %d\n", chan); if (mode == WLAN_MODE_HOSTAP) { wlan_ext_sniffer_param_t sniffer; if (chan == 0) { sniffer.dwell_time = 0; } else { sniffer.dwell_time = 120 * 1000 * 1000; //more time for geting ssid and pwd } sniffer.channel = chan; if (wlan_ext_request(nif, WLAN_EXT_CMD_SET_SNIFFER, (uint32_t)&sniffer) != 0) { CMD_ERR("set sniffer fail, chan %u, dwell time %u\r\n", sniffer.channel, sniffer.dwell_time); return -1; } if (chan != 0) { if (chan == assist_test_ap_chan) { auth_frame_creat(); send_auth_frame(); } } return 0; } return -1; } static void recv_rawframe(uint8_t *data, uint32_t len, void *info) { struct frame_info *p; struct ieee80211_frame *frame; p = (struct frame_info *)info; #if MONITOR_RX_HT40_PHY_INFO if (p->type == 0xff) { RX_EXT_FRAMES_IND *frame_ind; frame_ind = (RX_EXT_FRAMES_IND *)data; if (pkt_print_enable == 1) {/* rx 40M pkt print */ CMD_DBG("40M:frame %d, drop %d\n", frame_ind->frame_num, frame_ind->frame_drop); int i = 0; for (i = 0; i < frame_ind->frame_num; i++) { CMD_DBG("40M:chan=%d, rate=%d, size=%d, flag=0x%04x rssi=%d," "reserved=0x%04x\n", frame_ind->frames[i].chanNumber, frame_ind->frames[i].rxedRate, frame_ind->frames[i].frame_size, frame_ind->frames[i].flags, frame_ind->frames[i].Rssi, frame_ind->frames[i].reserved); } } return; } //return ; /* for ht40/mimo test only, delete ht20 pkt */ #endif if (pkt_print_enable == 1) {/* rx 20M pkt print */ CMD_LOG(1, "20M:rx data %p, len %u, ", data, len); if (p) { CMD_LOG(1, "20M:type 0x%02x, rx ch %d, ap ch %d, rssi %u, alg %d\n", p->type, p->recv_channel, p->ap_channel, p->rssi, p->alg); } else { CMD_LOG(1, "info NULL\n"); } } frame = (struct ieee80211_frame *)data; #if 0 // ####broadcast pkt print###### //ap forward pkt //addr1 bd: ff:ff:ff:ff:ff:ff rx //addr2 #32ap 88:25:93:66:da:aa tx //addr3 mate9 44:c3:46:45:5f:4f src if (((frame->i_addr2[0] == 0x88 && frame->i_addr2[1] == 0x25 && frame->i_addr2[2] == 0x93) && (frame->i_addr3[0] == 0x44 && frame->i_addr3[1] == 0xc3 && frame->i_addr3[2] == 0x46)) && ((frame->i_addr1[0] == 0xff && frame->i_addr1[1] == 0xff && frame->i_addr1[2] == 0xff))) { //printf("ap:len %d, seq %d\n", len, ((*(uint16_t *)(&frame->i_seq[0])) >> 4)); } //mate9 to #32ap //addr1 #32ap 88:25:93:66:da:aa rx //addr2 mate9 44:c3:46:45:5f:4f tx //addr3 bd: ff:ff:ff:ff:ff:ff dst if (((frame->i_addr1[0] == 0x88 && frame->i_addr1[1] == 0x25 && frame->i_addr1[2] == 0x93) && (frame->i_addr2[0] == 0x44 && frame->i_addr2[1] == 0xc3 && frame->i_addr2[2] == 0x46)) && ((frame->i_addr3[0] == 0xff && frame->i_addr3[1] == 0xff && frame->i_addr3[2] == 0xff))) { //printf("sta:len %d, seq %d\n", len, ((*(uint16_t *)(&frame->i_seq[0])) >> 4)); } //####multicast pkt print###### //ap forward pkt //addr1 bd: 01:00:5e:xx:xx:xx rx //addr2 #32ap 88:25:93:66:da:aa tx //addr3 mate9 44:c3:46:45:5f:4f src if (((frame->i_addr2[0] == 0x88 && frame->i_addr2[1] == 0x25 && frame->i_addr2[2] == 0x93) && (frame->i_addr3[0] == 0x44 && frame->i_addr3[1] == 0xc3 && frame->i_addr3[2] == 0x46)) && ((frame->i_addr1[0] == 0x01 && frame->i_addr1[1] == 0x00 && frame->i_addr1[2] == 0x5e))) { //printf("ap m:len %d, seq %d\n", len, ((*(uint16_t *)(&frame->i_seq[0])) >> 4)); } //mate9 to #32ap //addr1 #32ap 88:25:93:66:da:aa rx //addr2 mate9 44:c3:46:45:5f:4f tx //addr3 bd: 01:00:5e:xx:xx:xx dst if (((frame->i_addr1[0] == 0x88 && frame->i_addr1[1] == 0x25 && frame->i_addr1[2] == 0x93) && (frame->i_addr2[0] == 0x44 && frame->i_addr2[1] == 0xc3 && frame->i_addr2[2] == 0x46)) && ((frame->i_addr3[0] == 0x01 && frame->i_addr3[1] == 0x00 && frame->i_addr3[2] == 0x5e))) { printf("sta m:len %d, seq %d\n", len, ((*(uint16_t *)(&frame->i_seq[0])) >> 4)); } #endif sniffer_rx_total_cnt++; if (info) { if ((p->type == IEEE80211_FC_STYPE_BEACON) || (p->type == IEEE80211_FC_STYPE_PROBE_RESP)) { if (!memcmp(assist_test_ap_mac, frame->i_addr2, 6)) { assist_test_ap_chan = p->ap_channel; //printf("assist_test_ap_chan %d\n", assist_test_ap_chan); } if (p->ap_channel > 14 || p->ap_channel < 1) { CMD_DBG("p->ap_channel=%d\r\n", p->ap_channel); return; } } uint16_t auth_transaction = *((uint16_t *)(&data[26])); if (frame) { if (p->type == IEEE80211_FC_STYPE_AUTH) { if (auth_transaction == 2) { //auth_transaction=2, auth seq num, auth resp return; } else if (auth_transaction == 1) { //auth req if (memcmp(frame->i_addr1, CMD_WLAN_NETIF->hwaddr, 6) == 0) { CMD_DBG("rx sta con req\n"); if (wifi_set_channel(0) != 0) { CMD_ERR("wifi_set_channel() 0 fail\n"); } sniffer_run = 0; } } } } } } static int wifi_set_promisc(int enable) { enum wlan_mode mode; struct netif *nif = CMD_WLAN_NETIF; if (nif == NULL) { CMD_ERR("%s, %d, warning: netif is null\n", __func__, __LINE__); return -1; } mode = wlan_netif_get_mode(nif); if (mode != WLAN_MODE_HOSTAP && mode != WLAN_MODE_MONITOR) { CMD_ERR("wlan mode is wrong\n"); return -1; } return wlan_monitor_set_rx_cb(nif, enable ? recv_rawframe : NULL); } static int wifi_softap_set_sniffer(int enable) { return wifi_set_promisc(enable); } static enum cmd_status sniffer_chan_test(char *cmd) { int chan; cmd_sscanf(cmd, "c=%d", &chan); CMD_DBG("set sniffer test chan %d\n", chan); wlan_ap_config_t config; cmd_memset(&config, 0, sizeof(config)); config.field = WLAN_AP_FIELD_CHANNEL; if (wlan_ap_get_config(&config) != 0) { CMD_ERR("get config failed\n"); return CMD_STATUS_FAIL; } CMD_DBG("softap channel: %d\n", config.u.channel); #if MONITOR_RX_HT40_PHY_INFO enable_rx_ext_frame(); #endif // init sniffer mode, register sniffer callback if (wifi_softap_set_sniffer(1) != 0) { CMD_ERR("wifi_softap_set_sniffer() fail\n"); } if (wifi_set_channel(chan) != 0) { CMD_ERR("wifi_set_channel() %u fail\n", chan); } return CMD_STATUS_OK; } static void sniffer_task(void *arg) { int i; char *ssid = "ap_sniffer"; int ssid_len = strlen(ssid); char *pwd = "12345678"; wlan_ap_config_t config; uint32_t sniffer_time = ((uint32_t)arg) & 0xffff; uint32_t softap_time = (((uint32_t)arg) >> 16) & 0xffff; CMD_DBG("sniffer time %u ms, softap time %u ms\n", sniffer_time, softap_time); wlan_ap_disable(); if (wlan_ap_set((uint8_t *)ssid, ssid_len, (uint8_t *)pwd)) { CMD_ERR("creat ap failed\n"); } config.field = WLAN_AP_FIELD_MAX_NUM_STA; config.u.max_num_sta = 4; wlan_ap_set_config(&config); config.field = WLAN_AP_FIELD_CHANNEL; config.u.channel = 6; /* 6 channel */ wlan_ap_set_config(&config); config.field = WLAN_AP_FIELD_BEACON_INT; config.u.beacon_int = 1000; /* beacon interval 1s */ wlan_ap_set_config(&config); wlan_ap_enable(); OS_MSleep(500); cmd_memset(&config, 0, sizeof(config)); config.field = WLAN_AP_FIELD_CHANNEL; if (wlan_ap_get_config(&config) != 0) { CMD_ERR("get config failed\n"); return; } #if BEACON_TX beacon_chan = config.u.channel; beacon_frame_creat(); #endif CMD_DBG("softap channel: %d\n", config.u.channel); #if MONITOR_RX_HT40_PHY_INFO enable_rx_ext_frame(); #endif // init sniffer mode, register sniffer callback if (wifi_softap_set_sniffer(1) != 0) { CMD_ERR("wifi_softap_set_sniffer() fail\n"); } while (sniffer_run) { for (i = 0; i < nitems(sniffer_channels); ++i) { if (!sniffer_run) { break; } // switch to sniffer mode if (wifi_set_channel(sniffer_channels[i]) != 0) { CMD_ERR("wifi_set_channel() %u fail\n", sniffer_channels[i]); } OS_MSleep(sniffer_time); // switch back to softap mode if (wifi_set_channel(0) != 0) { CMD_ERR("wifi_set_channel() 0 fail\n"); } #if BEACON_TX send_beacon_frame(); #endif OS_MSleep(softap_time); } } CMD_DBG("sniffer task stop\n"); #if MONITOR_RX_HT40_PHY_INFO disable_rx_ext_frame(); #endif // deinit sniffer mode, unregister sniffer callback if (wifi_set_channel(0) != 0) { CMD_ERR("wifi_set_channel() 0 fail\n"); } if (wifi_softap_set_sniffer(0) != 0) { CMD_ERR("wifi_softap_set_sniffer() stop fail\n"); } OS_ThreadDelete(&sniffer_thread); } /* $ sniffer_start t1=100 t2=100 */ static enum cmd_status cmd_sniffer_start_exec(char *cmd) { uint32_t sniffer_time, softap_time, time; if (cmd_sscanf(cmd, "t1=%u t2=%u", &sniffer_time, &softap_time) == 2) { time = (sniffer_time & 0xffff) | (softap_time << 16); sniffer_run = 1; if (OS_ThreadCreate(&sniffer_thread, "sniffer", sniffer_task, (void *)time, OS_THREAD_PRIO_APP, 2 * 1024) != OS_OK) { CMD_ERR("[ERR] create sniffer task failed\n"); return CMD_STATUS_FAIL; } return CMD_STATUS_OK; } else { return CMD_STATUS_INVALID_ARG; } } /* $ sniffer_stop */ static enum cmd_status cmd_sniffer_stop_exec(char *cmd) { sniffer_run = 0; while (OS_ThreadIsValid(&sniffer_thread)) { OS_MSleep(1); /* wait for thread termination */ } return CMD_STATUS_OK; } static enum cmd_status monitor_chan_test(char *cmd) { int ret; int chan; CMD_DBG("monitor start\n"); cmd_sscanf(cmd, "c=%d", &chan); net_switch_mode(WLAN_MODE_MONITOR); #if MONITOR_RX_HT40_PHY_INFO enable_rx_ext_frame(); #endif wifi_set_promisc(1); CMD_DBG("set chan %d\n", chan); ret = wlan_monitor_set_channel(CMD_WLAN_NETIF, chan); if (ret != 0) { CMD_ERR("set chan fail %d\n", chan); } return CMD_STATUS_OK; } static void monitor_task(void *arg) { int i; int ret; CMD_DBG("monitor start\n"); net_switch_mode(WLAN_MODE_MONITOR); #if MONITOR_RX_HT40_PHY_INFO enable_rx_ext_frame(); #endif wifi_set_promisc(1); while (monitor_run) { for (i = 0; i < nitems(sniffer_channels); ++i) { //printf("chan %d\n", sniffer_channels[i]); ret = wlan_monitor_set_channel(CMD_WLAN_NETIF, (int16_t)sniffer_channels[i]); if (ret != 0) { CMD_ERR("set chan fail\n"); } if (sniffer_channels[i] == assist_test_ap_chan) { auth_frame_creat(); send_auth_frame(); } OS_MSleep(100); } } #if MONITOR_RX_HT40_PHY_INFO disable_rx_ext_frame(); #endif wifi_set_promisc(0); net_switch_mode(WLAN_MODE_STA); CMD_DBG("monitor stop\n"); OS_ThreadDelete(&monitor_thread); } /* monitro start */ static enum cmd_status cmd_monitor_start_exec(char *cmd) { monitor_run = 1; if (OS_ThreadCreate(&monitor_thread, "monitor", monitor_task, NULL, OS_THREAD_PRIO_APP, 2 * 1024) != OS_OK) { CMD_ERR("[ERR] create sniffer task failed\n"); return CMD_STATUS_FAIL; } return CMD_STATUS_OK; } /* $ monitor_stop */ static enum cmd_status cmd_monitor_stop_exec(char *cmd) { monitor_run = 0; while (OS_ThreadIsValid(&monitor_thread)) { OS_MSleep(1); /* wait for thread termination */ } return CMD_STATUS_OK; } static enum cmd_status cmd_sniffer_statistics_start_exec(char *cmd) { sniffer_rx_total_cnt = 0; statistics_start_time = OS_JiffiesToMSecs(OS_GetJiffies()); return CMD_STATUS_OK; } static enum cmd_status cmd_sniffer_statistics_stop_exec(char *cmd) { statistics_end_time = OS_JiffiesToMSecs(OS_GetJiffies()); CMD_DBG("rx cnt %u, time total %u s %u ms, avg_ps %u\n", sniffer_rx_total_cnt, (statistics_end_time-statistics_start_time)/1000, (statistics_end_time-statistics_start_time)%1000, 1000*sniffer_rx_total_cnt/(statistics_end_time-statistics_start_time)); return CMD_STATUS_OK; } static enum cmd_status cmd_sniffer_pkt_print_enable_exec(char *cmd) { int cnt; cnt = cmd_sscanf(cmd, "%d", &pkt_print_enable); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } return CMD_STATUS_OK; } #endif static enum cmd_status cmd_wlan_set_bcn_intvl_calib(char *cmd) { int ret; int enable_bcn_intvl_calib; int cnt = cmd_sscanf(cmd, "e=%d", &enable_bcn_intvl_calib); if (cnt != 1) { CMD_ERR("cnt %d\n", cnt); return CMD_STATUS_INVALID_ARG; } ret = wlan_ext_request(g_wlan_netif, WLAN_EXT_CMD_SET_BCN_INTVL_CALIB, enable_bcn_intvl_calib); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } static enum cmd_status cmd_wlan_get_cur_bcn_intvl(char *cmd) { int ret; uint32_t bcn_intvl; ret = wlan_ext_request(CMD_WLAN_NETIF, WLAN_EXT_CMD_GET_CUR_BCN_INTVL, (uint32_t)(&bcn_intvl)); CMD_LOG(1, "cur beacon interval: %d tu\n", bcn_intvl); if (ret == -2) { CMD_ERR("%s: command '%s' invalid arg\n", __func__, cmd); return CMD_STATUS_ACKED; } else if (ret == -1) { CMD_ERR("%s: command '%s' exec failed\n", __func__, cmd); return CMD_STATUS_ACKED; } return CMD_STATUS_OK; } /* * wlan commands */ static enum cmd_status cmd_wlan_help_exec(char *cmd); static const struct cmd_data g_wlan_cmds[] = { { "stop", cmd_wlan_stop_exec }, { "start", cmd_wlan_start_exec }, { "pm_dtim", cmd_wlan_set_pm_dtim }, { "get_pm_dtim", cmd_wlan_get_pm_dtim }, { "set_lsn_intv", cmd_wlan_set_listen_interval }, { "ps_mode", cmd_wlan_set_ps_mode }, { "pm", cmd_wlan_pm }, { "ampdu", cmd_wlan_set_ampdu }, { "retry", cmd_wlan_set_retry }, { "null_prd", cmd_wlan_set_pm_tx_null_period }, { "bcn_win_cfg", cmd_wlan_set_bcn_win_cfg }, { "bcn_win", cmd_wlan_set_bcn_win_us }, { "get_bcn_stat", cmd_wlan_get_bcn_stat }, { "get_cur_rate", cmd_wlan_get_cur_tx_rate }, { "get_cur_signal", cmd_wlan_get_cur_signal }, { "scan_freq", cmd_wlan_scan_freq }, { "set_scan_param", cmd_wlan_set_scan_param }, { "get_temp_volt", cmd_wlan_get_temp_volt }, { "set_tv_upload", cmd_wlan_set_temp_volt_auto_upload }, { "set_tv_thresh", cmd_wlan_set_temp_volt_thresh }, { "set_edca_param", cmd_wlan_set_edca_param }, { "get_edca_param", cmd_wlan_get_edca_param }, { "set_bcn_freq_offs_time", cmd_wlan_set_bcn_freq_offs_time }, { "set_lfclock_param", cmd_wlan_set_lfclock_param }, { "set_bcn_rx_11b_only", cmd_wlan_set_bcn_rx_11b_only }, { "bcn_lost_comp", cmd_wlan_set_bcn_lost_comp }, { "set_bcn_intvl_calib", cmd_wlan_set_bcn_intvl_calib }, { "get_cur_bcn_intvl", cmd_wlan_get_cur_bcn_intvl }, { "get_reason_code", cmd_wlan_get_stats_code }, { "set_auth_tmo_and_tries", cmd_wlan_set_auth_tmo_and_tries }, { "set_assoc_tmo_and_tries", cmd_wlan_set_assoc_tmo_and_tries }, { "set_bss_loss_thold", cmd_wlan_set_bss_loss_thold }, { "arp_reply_keep_alive", cmd_wlan_arp_reply_keep_alive }, { "set_hidden_ap", cmd_wlan_set_hidden_ap}, { "set_mixrate", cmd_wlan_set_mixrate }, #if SUPPORT_BCN_AUTO_OFFSET { "set_bcn_auto_offset", cmd_wlan_set_bcn_auto_offset }, #endif { "set_pre_rx_bcn", cmd_wlan_set_pre_rx_bcn }, { "set_stay_awake_tmo", cmd_wlan_set_stay_awake_tmo }, { "set_auto_power", cmd_wlan_set_auto_power }, { "set_lp_param", cmd_wlan_set_low_power_param }, { "set_chk_bcn_without_data", cmd_wlan_set_chk_bcn_without_data }, { "set_bcn_tim_no_data_tmo", cmd_wlan_set_bcn_tim_no_data_tmo }, { "set_filter_type", cmd_wlan_set_filter_type }, #if LOW_POWER_IP_SERVICE { "set_auto_scan", cmd_wlan_set_auto_scan }, { "get_ap_mac", cmd_wlan_get_ap_mac }, { "ser_start", cmd_wlan_server_start }, { "ser_send", cmd_wlan_server_send }, { "ser_recv", cmd_wlan_server_recv }, { "ser_stop", cmd_wlan_server_stop }, { "cli_start", cmd_wlan_client_start }, { "cli_send", cmd_wlan_client_send }, { "cli_recv", cmd_wlan_client_recv }, { "cli_stop", cmd_wlan_client_stop }, { "p2p_server", cmd_wlan_set_p2p_server }, { "p2p_wkpacket", cmd_wlan_set_p2p_wkpacket }, { "p2p_wakeupip", cmd_wlan_set_p2p_wakeupip }, { "p2p_kpalive", cmd_wlan_set_p2p_kpalive }, { "p2p_hostsleep", cmd_wlan_set_p2p_hostsleep }, { "p2p_kpalive_start", cmd_wlan_p2p_keepalive_start }, { "p2p_kpalive_stop", cmd_wlan_p2p_keepalive_stop }, #endif #if MONITOR_RX_HT40_PHY_INFO { "ht40_rx_start", cmd_mimo_start_exec}, { "ht40_rx_stop", cmd_mimo_stop_exec}, #endif #if AP_SNIFFER { "sniffer_start", cmd_sniffer_start_exec}, { "sniffer_stop", cmd_sniffer_stop_exec}, { "sniffer_set_addr", cmd_sniffer_set_assist_test_ap_addr_exec}, { "sniffer_chan", sniffer_chan_test}, { "sniffer_info_start", cmd_sniffer_statistics_start_exec}, { "sniffer_info_stop", cmd_sniffer_statistics_stop_exec}, { "sniffer_pkt_print", cmd_sniffer_pkt_print_enable_exec}, { "monitor_start", cmd_monitor_start_exec}, { "monitor_stop", cmd_monitor_stop_exec}, { "monitor_chan", monitor_chan_test}, #endif #if NONCONNECT_SNIFF { "rcv_spec_frm", cmd_wlan_set_rcv_special_frm }, { "raw_frm_cfg", cmd_wlan_send_raw_frm_cfg }, { "sniff_kp_active", cmd_wlan_sniff_kp_active }, { "sniff_auto_wkp_host", cmd_wlan_set_sniff_auto_wakeup_host }, { "sniff_auto_wkp_wifi", cmd_wlan_set_sniff_auto_wakeup_wifi }, { "send_raw_frm", cmd_wlan_send_raw_frm }, { "switch_chn", cmd_wlan_switch_channel_cfg }, { "get_chn", cmd_wlan_get_cur_channel }, { "rcv_filter_mac", cmd_wlan_rcv_frm_filter_mac }, { "set_frm_filter", cmd_wlan_set_frm_filter }, { "rcv_filter1_ie", cmd_wlan_rcv_frm_filter1_ie_cfg }, { "rcv_filter2_ie", cmd_wlan_rcv_frm_filter2_ie_cfg }, { "rcv_filter1_pl", cmd_wlan_rcv_frm_filter1_pl_cfg }, { "rcv_filter2_pl", cmd_wlan_rcv_frm_filter2_pl_cfg }, { "set_temp_frm", cmd_wlan_set_temp_frm }, { "send_sync_frm", cmd_wlan_send_sync_frm }, { "set_ext_param", cmd_wlan_set_sniff_ext_param }, { "get_rcv_stat", cmd_wlan_get_rcv_stat }, { "set_rcv_cb", cmd_wlan_set_rcv_cb }, { "set_even_ie", cmd_wlan_set_even_ie }, #endif { "set_fast_join", cmd_wlan_set_fast_join }, { "help", cmd_wlan_help_exec }, }; static enum cmd_status cmd_wlan_help_exec(char *cmd) { return cmd_help_exec(g_wlan_cmds, cmd_nitems(g_wlan_cmds), 16); } enum cmd_status cmd_wlan_exec(char *cmd) { if (CMD_WLAN_NETIF == NULL && cmd_strcmp(cmd, "start")) { return CMD_STATUS_FAIL; } return cmd_exec(cmd, g_wlan_cmds, cmd_nitems(g_wlan_cmds)); } #endif /* PRJCONF_NET_EN */ #endif /* CONFIG_WLAN */