static int open_tracing_file (void)
{
if (config.tracingOutputFileName == NULL || *config.tracingOutputFileName == 0)
{
config.tracingOutputFile = NULL;
return 1;
}
else if (os_strcasecmp (config.tracingOutputFileName, "stdout") == 0)
{
config.tracingOutputFile = stdout;
return 1;
}
else if (os_strcasecmp (config.tracingOutputFileName, "stderr") == 0)
{
config.tracingOutputFile = stderr;
return 1;
}
else if ((config.tracingOutputFile = fopen (config.tracingOutputFileName, config.tracingAppendToFile ? "a" : "w")) == NULL)
{
nn_log (LC_ERROR, "%s: cannot open for writing", config.tracingOutputFileName);
return 0;
}
else
{
return 1;
}
}
int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
size_t buf_len )
{
struct i802_bss *bss = priv;
struct wpa_driver_nl80211_data *drv = bss->drv;
struct ifreq ifr;
android_wifi_priv_cmd priv_cmd;
int ret = 0;
if (os_strcasecmp(cmd, "STOP") == 0) {
linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
} else if (os_strcasecmp(cmd, "START") == 0) {
linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");
} else if (os_strcasecmp(cmd, "MACADDR") == 0) {
u8 macaddr[ETH_ALEN] = {};
ret = linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname, macaddr);
if (!ret)
ret = os_snprintf(buf, buf_len,
"Macaddr = " MACSTR "\n", MAC2STR(macaddr));
} else { /* Use private command */
memset(&ifr, 0, sizeof(ifr));
memset(&priv_cmd, 0, sizeof(priv_cmd));
os_memcpy(buf, cmd, strlen(cmd) + 1);
os_strncpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
priv_cmd.buf = buf;
priv_cmd.used_len = buf_len;
priv_cmd.total_len = buf_len;
ifr.ifr_data = &priv_cmd;
if ((ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr)) < 0) {
wpa_printf(MSG_ERROR, "%s: failed to issue private commands\n", __func__);
} else {
drv_errors = 0;
ret = 0;
if ((os_strcasecmp(cmd, "LINKSPEED") == 0) ||
(os_strcasecmp(cmd, "RSSI") == 0) ||
(os_strcasecmp(cmd, "GETBAND") == 0) )
ret = strlen(buf);
else if (os_strcasecmp(cmd, "COUNTRY") == 0)
wpa_supplicant_event(drv->ctx,
EVENT_CHANNEL_LIST_CHANGED, NULL);
else if (os_strncasecmp(cmd, "SETBAND", 7) == 0)
wpa_printf(MSG_DEBUG, "%s: %s ", __func__, cmd);
else if (os_strcasecmp(cmd, "P2P_DEV_ADDR") == 0)
wpa_printf(MSG_DEBUG, "%s: P2P: Device address ("MACSTR")",
__func__, MAC2STR(buf));
else if (os_strcasecmp(cmd, "P2P_SET_PS") == 0)
wpa_printf(MSG_DEBUG, "%s: P2P: %s ", __func__, buf);
else if (os_strcasecmp(cmd, "P2P_SET_NOA") == 0)
wpa_printf(MSG_DEBUG, "%s: P2P: %s ", __func__, buf);
else
wpa_printf(MSG_DEBUG, "%s %s len = %d, %d", __func__, buf, ret, strlen(buf));
}
}
return ret;
}
static int nai_realm_match(struct nai_realm *realm, const char *home_realm)
{
char *tmp, *pos, *end;
int match = 0;
if (realm->realm == NULL || home_realm == NULL)
return 0;
if (os_strchr(realm->realm, ';') == NULL)
return os_strcasecmp(realm->realm, home_realm) == 0;
tmp = os_strdup(realm->realm);
if (tmp == NULL)
return 0;
pos = tmp;
while (*pos) {
end = os_strchr(pos, ';');
if (end)
*end = '\0';
if (os_strcasecmp(pos, home_realm) == 0) {
match = 1;
break;
}
if (end == NULL)
break;
pos = end + 1;
}
os_free(tmp);
return match;
}
static int cmd_send(int s, int argc, char *argv[])
{
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
u8 buf[WLANTEST_CTRL_MAX_CMD_LEN], *end, *pos, *len_pos;
int rlen;
enum wlantest_inject_protection prot;
int arg;
/* <prot> <raw frame as hex dump> */
if (argc < 2) {
printf("send needs two arguments: protected/unprotected, "
"raw frame as hex dump\n");
return -1;
}
pos = buf;
end = buf + sizeof(buf);
WPA_PUT_BE32(pos, WLANTEST_CTRL_SEND);
pos += 4;
if (os_strcasecmp(argv[0], "normal") == 0)
prot = WLANTEST_INJECT_NORMAL;
else if (os_strcasecmp(argv[0], "protected") == 0)
prot = WLANTEST_INJECT_PROTECTED;
else if (os_strcasecmp(argv[0], "unprotected") == 0)
prot = WLANTEST_INJECT_UNPROTECTED;
else if (os_strcasecmp(argv[0], "incorrect") == 0)
prot = WLANTEST_INJECT_INCORRECT_KEY;
else {
printf("Unknown protection type '%s'\n", argv[1]);
printf("Protection types: normal protected unprotected "
"incorrect\n");
return -1;
}
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
WPA_PUT_BE32(pos, WLANTEST_ATTR_FRAME);
pos += 4;
len_pos = pos;
pos += 4;
for (arg = 1; pos && arg < argc; arg++)
pos = add_hex(pos, end, argv[arg]);
if (pos == NULL)
return -1;
WPA_PUT_BE32(len_pos, pos - len_pos - 4);
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
if (rlen < 0)
return -1;
printf("OK\n");
return 0;
}
static const char * wps_er_find_wfadevice(const char *data)
{
const char *tag, *tagname, *end;
char *val;
int found = 0;
while (!found) {
/* Find next <device> */
for (;;) {
if (xml_next_tag(data, &tag, &tagname, &end))
return NULL;
data = end;
if (!os_strncasecmp(tagname, "device", 6) &&
*tag != '/' &&
(tagname[6] == '>' || !isgraph(tagname[6]))) {
break;
}
}
/* Check whether deviceType is WFADevice */
val = xml_get_first_item(data, "deviceType");
if (val == NULL)
return NULL;
wpa_printf(MSG_DEBUG, "WPS ER: Found deviceType '%s'", val);
found = os_strcasecmp(val, "urn:schemas-wifialliance-org:"
"device:WFADevice:1") == 0;
os_free(val);
}
return data;
}
static c_metaEquality
c_metaNameCompare (
c_baseObject baseObject,
c_metaFindCompareArg arg)
{
c_findArg farg = (c_findArg)arg;
c_metaEquality equality = E_UNEQUAL;
char *name;
if (CQ_KIND_IN_MASK (baseObject, farg->metaFilter)) {
if (CQ_KIND_IN_MASK (baseObject, CQ_SPECIFIERS)) {
name = c_specifier(baseObject)->name;
} else if (CQ_KIND_IN_MASK (baseObject, CQ_METAOBJECTS)) {
name = c_metaObject(baseObject)->name;
} else {
return equality;
}
if (farg->metaFilter & CQ_CASEINSENSITIVE) {
if (os_strcasecmp (name, (const char *)farg->name) == 0) {
equality = E_EQUAL;
}
} else {
if (strcmp (name, (const char *)farg->name) == 0) {
equality = E_EQUAL;
}
}
}
return equality;
}
static int cmd_get_sta_counter(int s, int argc, char *argv[])
{
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
u8 buf[100], *end, *pos;
int rlen, i;
size_t len;
if (argc != 3) {
printf("get_sta_counter needs at three arguments: "
"counter name, BSSID, and STA address\n");
return -1;
}
pos = buf;
end = buf + sizeof(buf);
WPA_PUT_BE32(pos, WLANTEST_CTRL_GET_STA_COUNTER);
pos += 4;
for (i = 0; sta_counters[i].name; i++) {
if (os_strcasecmp(sta_counters[i].name, argv[0]) == 0)
break;
}
if (sta_counters[i].name == NULL) {
printf("Unknown STA counter '%s'\n", argv[0]);
printf("Counters:");
for (i = 0; sta_counters[i].name; i++)
printf(" %s", sta_counters[i].name);
printf("\n");
return -1;
}
pos = attr_add_be32(pos, end, WLANTEST_ATTR_STA_COUNTER,
sta_counters[i].num);
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
if (hwaddr_aton(argv[1], pos) < 0) {
printf("Invalid BSSID '%s'\n", argv[1]);
return -1;
}
pos += ETH_ALEN;
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
if (hwaddr_aton(argv[2], pos) < 0) {
printf("Invalid STA address '%s'\n", argv[2]);
return -1;
}
pos += ETH_ALEN;
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
if (rlen < 0)
return -1;
pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_COUNTER, &len);
if (pos == NULL || len != 4)
return -1;
printf("%u\n", WPA_GET_BE32(pos));
return 0;
}
char * ICACHE_FLASH_ATTR http_url_get_query_param(http_connection *c,char* param){
NODE_DBG("http_url_get_query_param");
if(!(c->url_parsed.field_set & (1<<UF_QUERY))) //return null if there's no query at all
return NULL;
//find field
char *start = c->url + c->url_parsed.field_data[UF_QUERY].off;
char * end = start + c->url_parsed.field_data[UF_QUERY].len -1;
char *param_search = (char*)os_malloc(strlen(param)+2);
os_strcpy(param_search,param);
os_strcat(param_search,"=");
NODE_DBG("search for : %s",param_search);
char *ret=NULL;
start--; //to start at ?
while(start<=end){
NODE_DBG("char : %c",*start);
if(*start == '?' || *start == '&' || *start=='\0'){
NODE_DBG("Is match?");
start++;
//check param name, case insensitive
if(os_strcasecmp(param_search,start)==0){
NODE_DBG("yes");
//match
start +=strlen(param_search);
ret = start;
//0 end string
while(*start!='\0' && *start!='&')
start++;
*start='\0';
break;
}
}
start++;
}
os_free(param_search);
return ret;
}
static int cmd_info_bss(int s, int argc, char *argv[])
{
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
u8 buf[100], *end, *pos;
int rlen, i;
size_t len;
char info[100];
if (argc != 2) {
printf("bss_info needs at two arguments: "
"field name and BSSID\n");
return -1;
}
pos = buf;
end = buf + sizeof(buf);
WPA_PUT_BE32(pos, WLANTEST_CTRL_INFO_BSS);
pos += 4;
for (i = 0; bss_infos[i].name; i++) {
if (os_strcasecmp(bss_infos[i].name, argv[0]) == 0)
break;
}
if (bss_infos[i].name == NULL) {
printf("Unknown BSS info '%s'\n", argv[0]);
printf("Info fields:");
for (i = 0; bss_infos[i].name; i++)
printf(" %s", bss_infos[i].name);
printf("\n");
return -1;
}
pos = attr_add_be32(pos, end, WLANTEST_ATTR_BSS_INFO,
bss_infos[i].num);
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
if (hwaddr_aton(argv[1], pos) < 0) {
printf("Invalid BSSID '%s'\n", argv[1]);
return -1;
}
pos += ETH_ALEN;
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
if (rlen < 0)
return -1;
pos = attr_get(resp + 4, rlen - 4, WLANTEST_ATTR_INFO, &len);
if (pos == NULL)
return -1;
if (len >= sizeof(info))
len = sizeof(info) - 1;
os_memcpy(info, pos, len);
info[len] = '\0';
printf("%s\n", info);
return 0;
}
static int dev_pwd_e_file_filter(const struct dirent *entry)
{
unsigned int prefix;
char ext[5];
if (sscanf(entry->d_name, "%8x.%4s", &prefix, ext) != 2)
return 0;
if (prefix == 0)
return 0;
if (os_strcasecmp(ext, "WFA") != 0)
return 0;
return 1;
}
int fst_test_req_send_fst_request(const char *params)
{
int fsts_id;
Boolean is_valid;
char *endp;
struct fst_setup_req req;
struct fst_session s;
struct fst_group *g;
enum hostapd_hw_mode hw_mode;
u8 channel;
char additional_param[FST_MAX_COMMAND_WORD_NAME_LENGTH];
if (params[0] != ' ')
return -EINVAL;
params++;
fsts_id = fst_read_next_int_param(params, &is_valid, &endp);
if (!is_valid)
return -EINVAL;
if (get_group_fill_session(&g, &s))
return -EINVAL;
req.action = FST_ACTION_SETUP_REQUEST;
req.dialog_token = g->dialog_token;
req.llt = host_to_le32(FST_LLT_MS_DEFAULT);
/* 8.4.2.147 Session Transition element */
req.stie.element_id = WLAN_EID_SESSION_TRANSITION;
req.stie.length = sizeof(req.stie) - 2;
req.stie.fsts_id = host_to_le32(fsts_id);
req.stie.session_control = SESSION_CONTROL(SESSION_TYPE_BSS, 0);
fst_iface_get_channel_info(s.data.new_iface, &hw_mode, &channel);
req.stie.new_band_id = fst_hw_mode_to_band(hw_mode);
req.stie.new_band_op = 1;
req.stie.new_band_setup = 0;
fst_iface_get_channel_info(s.data.old_iface, &hw_mode, &channel);
req.stie.old_band_id = fst_hw_mode_to_band(hw_mode);
req.stie.old_band_op = 1;
req.stie.old_band_setup = 0;
if (!fst_read_next_text_param(endp, additional_param,
sizeof(additional_param), &endp)) {
if (!os_strcasecmp(additional_param, FST_CTR_PVAL_BAD_NEW_BAND))
req.stie.new_band_id = req.stie.old_band_id;
}
return fst_session_send_action(&s, TRUE, &req, sizeof(req),
s.data.old_iface->mb_ie);
}
static int wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
{
struct wpa_cli_cmd *cmd, *match = NULL;
int count;
int ret = 0;
count = 0;
cmd = wpa_cli_commands;
while (cmd->cmd) {
if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
{
match = cmd;
if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
/* we have an exact match */
count = 1;
break;
}
count++;
}
cmd++;
}
if (count > 1) {
printf("Ambiguous command '%s'; possible commands:", argv[0]);
cmd = wpa_cli_commands;
while (cmd->cmd) {
if (os_strncasecmp(cmd->cmd, argv[0],
os_strlen(argv[0])) == 0) {
printf(" %s", cmd->cmd);
}
cmd++;
}
printf("\n");
ret = 1;
} else if (count == 0) {
printf("Unknown command '%s'\n", argv[0]);
ret = 1;
} else {
#ifdef ANDROID
if( os_strncasecmp( "level", argv[0], os_strlen(argv[0]) ) == 0 ) {
ctrl = monitor_conn;
}
#endif
ret = match->handler(ctrl, argc - 1, &argv[1]);
}
return ret;
}
int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
size_t buf_len )
{
struct i802_bss *bss = priv;
struct wpa_driver_nl80211_data *drv = bss->drv;
struct wpa_driver_nl80211_data *driver;
struct ifreq ifr;
android_wifi_priv_cmd priv_cmd;
int ret = 0;
if (os_strcasecmp(cmd, "STOP") == 0) {
dl_list_for_each(driver, &drv->global->interfaces, struct wpa_driver_nl80211_data, list) {
linux_set_iface_flags(drv->global->ioctl_sock, driver->first_bss->ifname, 0);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
}
} else if (os_strcasecmp(cmd, "START") == 0) {
/**
* Convert a string to a verbosity level.
*
* NOTE: The parsing is case insensitive.
*
* @param[out] level Verbosity level parsed
* @param[in] str String to parse
*
* @return true if successful, false otherwise
*/
bool exa_verb_from_str(exa_cli_log_level_t *level, const char *str)
{
int i;
if (level == NULL || str == NULL)
return false;
for (i = 0; log_lvl_str_table[i].str != NULL; i++)
if (os_strcasecmp(str, log_lvl_str_table[i].str) == 0)
{
*level = log_lvl_str_table[i].lvl;
return true;
}
return false;
}
/* Given that we have received a header w/ POST, act upon it
*
* Format of POST (case-insensitive):
*
* First line must be:
* POST /<file> HTTP/1.1
* Since we don't do anything fancy we just ignore other lines.
*
* Our response (if no error) which includes only required lines is:
* HTTP/1.1 200 OK
* Connection: close
* Content-Type: text/xml
* Date: <rfc1123-date>
*
* Header lines must end with \r\n
* Per RFC 2616, content-length: is not required but connection:close
* would appear to be required (given that we will be closing it!).
*/
static void web_connection_parse_post(struct upnp_wps_device_sm *sm,
struct sockaddr_in *cli,
struct http_request *req,
const char *filename)
{
enum http_reply_code ret;
char *data = http_request_get_data(req); /* body of http msg */
const char *action = NULL;
size_t action_len = 0;
const char *replyname = NULL; /* argument name for the reply */
struct wpabuf *reply = NULL; /* data for the reply */
if (os_strcasecmp(filename, UPNP_WPS_DEVICE_CONTROL_FILE)) {
wpa_printf(MSG_INFO, "WPS UPnP: Invalid POST filename %s",
filename);
ret = HTTP_NOT_FOUND;
goto bad;
}
ret = UPNP_INVALID_ACTION;
action = web_get_action(req, &action_len);
if (action == NULL)
goto bad;
if (!os_strncasecmp("GetDeviceInfo", action, action_len))
ret = web_process_get_device_info(sm, &reply, &replyname);
else if (!os_strncasecmp("PutMessage", action, action_len))
ret = web_process_put_message(sm, data, &reply, &replyname);
else if (!os_strncasecmp("PutWLANResponse", action, action_len))
ret = web_process_put_wlan_response(sm, data, &reply,
&replyname);
else if (!os_strncasecmp("SetSelectedRegistrar", action, action_len))
ret = web_process_set_selected_registrar(sm, cli, data, &reply,
&replyname);
else
wpa_printf(MSG_INFO, "WPS UPnP: Unknown POST type");
bad:
if (ret != HTTP_OK)
wpa_printf(MSG_INFO, "WPS UPnP: POST failure ret=%d", ret);
web_connection_send_reply(req, ret, action, action_len, reply,
replyname);
wpabuf_free(reply);
}
int str_to_debug_level(const char *s)
{
if (os_strcasecmp(s, "EXCESSIVE") == 0)
return MSG_EXCESSIVE;
if (os_strcasecmp(s, "MSGDUMP") == 0)
return MSG_MSGDUMP;
if (os_strcasecmp(s, "DEBUG") == 0)
return MSG_DEBUG;
if (os_strcasecmp(s, "INFO") == 0)
return MSG_INFO;
if (os_strcasecmp(s, "WARNING") == 0)
return MSG_WARNING;
if (os_strcasecmp(s, "ERROR") == 0)
return MSG_ERROR;
return -1;
}
static int wpa_supplicant_ctrl_iface_set(struct wpa_supplicant *wpa_s,
char *cmd)
{
char *value;
int ret = 0;
value = os_strchr(cmd, ' ');
if (value == NULL)
return -1;
*value++ = '\0';
wpa_printf(MSG_DEBUG, "CTRL_IFACE SET '%s'='%s'", cmd, value);
if (os_strcasecmp(cmd, "EAPOL::heldPeriod") == 0) {
eapol_sm_configure(wpa_s->eapol,
atoi(value), -1, -1, -1);
} else if (os_strcasecmp(cmd, "EAPOL::authPeriod") == 0) {
eapol_sm_configure(wpa_s->eapol,
-1, atoi(value), -1, -1);
} else if (os_strcasecmp(cmd, "EAPOL::startPeriod") == 0) {
eapol_sm_configure(wpa_s->eapol,
-1, -1, atoi(value), -1);
} else if (os_strcasecmp(cmd, "EAPOL::maxStart") == 0) {
eapol_sm_configure(wpa_s->eapol,
-1, -1, -1, atoi(value));
} else if (os_strcasecmp(cmd, "dot11RSNAConfigPMKLifetime") == 0) {
if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_LIFETIME,
atoi(value)))
ret = -1;
} else if (os_strcasecmp(cmd, "dot11RSNAConfigPMKReauthThreshold") ==
0) {
if (wpa_sm_set_param(wpa_s->wpa, RSNA_PMK_REAUTH_THRESHOLD,
atoi(value)))
ret = -1;
} else if (os_strcasecmp(cmd, "dot11RSNAConfigSATimeout") == 0) {
if (wpa_sm_set_param(wpa_s->wpa, RSNA_SA_TIMEOUT, atoi(value)))
ret = -1;
} else
ret = -1;
return ret;
}
static int ctrl_command(int s, int argc, char *argv[])
{
const struct wlantest_cli_cmd *cmd, *match = NULL;
int count = 0;
int ret = 0;
for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
if (os_strncasecmp(cmd->cmd, argv[0], os_strlen(argv[0])) == 0)
{
match = cmd;
if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
/* exact match */
count = 1;
break;
}
count++;
}
}
if (count > 1) {
printf("Ambiguous command '%s'; possible commands:", argv[0]);
for (cmd = wlantest_cli_commands; cmd->cmd; cmd++) {
if (os_strncasecmp(cmd->cmd, argv[0],
os_strlen(argv[0])) == 0) {
printf(" %s", cmd->cmd);
}
}
printf("\n");
ret = 1;
} else if (count == 0) {
printf("Unknown command '%s'\n", argv[0]);
ret = 1;
} else {
ret = match->handler(s, argc - 1, &argv[1]);
}
return ret;
}
static void wpa_request(struct wpa_ctrl *ctrl, int argc, char *argv[])
{
const struct hostapd_cli_cmd *cmd, *match = NULL;
int count;
count = 0;
cmd = hostapd_cli_commands;
while (cmd->cmd) {
if (strncasecmp(cmd->cmd, argv[0], strlen(argv[0])) == 0) {
match = cmd;
if (os_strcasecmp(cmd->cmd, argv[0]) == 0) {
/* we have an exact match */
count = 1;
break;
}
count++;
}
cmd++;
}
if (count > 1) {
printf("Ambiguous command '%s'; possible commands:", argv[0]);
cmd = hostapd_cli_commands;
while (cmd->cmd) {
if (strncasecmp(cmd->cmd, argv[0], strlen(argv[0])) ==
0) {
printf(" %s", cmd->cmd);
}
cmd++;
}
printf("\n");
} else if (count == 0) {
printf("Unknown command '%s'\n", argv[0]);
} else {
match->handler(ctrl, argc - 1, &argv[1]);
}
}
int ICACHE_FLASH_ATTR http_ws_handle_connect(http_connection *c) {
NODE_DBG("http_ws_handle_connect c =%p",c);
if(c->state == HTTPD_STATE_ON_URL){
http_set_save_header(c,HTTP_ORIGIN);
http_set_save_header(c,HTTP_CONNECTION);
http_set_save_header(c,HTTP_UPGRADE);
http_set_save_header(c,HTTP_SEC_WEBSOCKET_KEY);
http_set_save_header(c,HTTP_SEC_WEBSOCKET_PROTOCOL);
http_set_save_header(c,HTTP_SEC_WEBSOCKET_VERSION);
return HTTP_WS_CGI_MORE;
}
//wait handshake request complete
if(c->state != HTTPD_STATE_BODY_END)
return HTTP_WS_CGI_MORE;
header * upgrade_header = http_get_header(c,HTTP_UPGRADE);
header * connection_header = http_get_header(c,HTTP_CONNECTION);
header * origin_header = http_get_header(c,HTTP_ORIGIN);
header * key_header = http_get_header(c,HTTP_SEC_WEBSOCKET_KEY);
if(upgrade_header==NULL) goto badrequest;
if(connection_header==NULL) goto badrequest;
if(origin_header==NULL) goto badrequest;
if(key_header==NULL) goto badrequest;
NODE_DBG("headers ok");
if(os_strcasecmp(upgrade_header->value,"websocket")!=0) goto badrequest;
// Following (https://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17)
//calculate sha1 of concatenetion key+uuid
uint8_t digest[20]; //sha1 is always 20 byte long
SHA1_CTX ctx;
SHA1_Init(&ctx);
SHA1_Update(&ctx,key_header->value,os_strlen(key_header->value));
SHA1_Update(&ctx,ws_uuid,os_strlen(ws_uuid));
SHA1_Final(digest,&ctx);
char base64Digest[31]; //
Base64encode(base64Digest,(const char*)digest,20);
//accept the handshake
http_SET_HEADER(c,HTTP_UPGRADE,"WebSocket");
http_SET_HEADER(c,HTTP_CONNECTION,"Upgrade");
http_SET_HEADER(c,HTTP_WEBSOCKET_ACCEPT,base64Digest);
http_websocket_HANDSHAKE(c);
c->handshake_ok=1;
if(client_connected_callback!=NULL)
client_connected_callback(c);
return HTTP_WS_CGI_MORE;
badrequest:
http_response_BAD_REQUEST(c);
return HTTP_WS_CGI_DONE;
}
/* Given that we have received a header w/ SUBSCRIBE, act upon it
*
* Format of SUBSCRIBE (case-insensitive):
*
* First line must be:
* SUBSCRIBE /wps_event HTTP/1.1
*
* Our response (if no error) which includes only required lines is:
* HTTP/1.1 200 OK
* Server: xx, UPnP/1.0, xx
* SID: uuid:xxxxxxxxx
* Timeout: Second-<n>
* Content-Length: 0
* Date: xxxx
*
* Header lines must end with \r\n
* Per RFC 2616, content-length: is not required but connection:close
* would appear to be required (given that we will be closing it!).
*/
static void web_connection_parse_subscribe(struct upnp_wps_device_sm *sm,
struct http_request *req,
const char *filename)
{
struct wpabuf *buf;
char *b;
char *hdr = http_request_get_hdr(req);
char *h;
char *match;
int match_len;
char *end;
int len;
int got_nt = 0;
u8 uuid[UUID_LEN];
int got_uuid = 0;
char *callback_urls = NULL;
struct subscription *s = NULL;
enum http_reply_code ret = HTTP_INTERNAL_SERVER_ERROR;
buf = wpabuf_alloc(1000);
if (buf == NULL) {
http_request_deinit(req);
return;
}
wpa_hexdump_ascii(MSG_DEBUG, "WPS UPnP: HTTP SUBSCRIBE",
(u8 *) hdr, os_strlen(hdr));
/* Parse/validate headers */
h = hdr;
/* First line: SUBSCRIBE /wps_event HTTP/1.1
* has already been parsed.
*/
if (os_strcasecmp(filename, UPNP_WPS_DEVICE_EVENT_FILE) != 0) {
ret = HTTP_PRECONDITION_FAILED;
goto error;
}
wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP SUBSCRIBE for event");
end = os_strchr(h, '\n');
while (end) {
/* Option line by option line */
h = end + 1;
end = os_strchr(h, '\n');
if (end == NULL)
break; /* no unterminated lines allowed */
/* NT assures that it is our type of subscription;
* not used for a renewal.
**/
match = "NT:";
match_len = os_strlen(match);
if (os_strncasecmp(h, match, match_len) == 0) {
h += match_len;
while (*h == ' ' || *h == '\t')
h++;
match = "upnp:event";
match_len = os_strlen(match);
if (os_strncasecmp(h, match, match_len) != 0) {
ret = HTTP_BAD_REQUEST;
goto error;
}
got_nt = 1;
continue;
}
/* HOST should refer to us */
#if 0
match = "HOST:";
match_len = os_strlen(match);
if (os_strncasecmp(h, match, match_len) == 0) {
h += match_len;
while (*h == ' ' || *h == '\t')
h++;
.....
}
#endif
/* CALLBACK gives one or more URLs for NOTIFYs
* to be sent as a result of the subscription.
* Each URL is enclosed in angle brackets.
*/
match = "CALLBACK:";
match_len = os_strlen(match);
if (os_strncasecmp(h, match, match_len) == 0) {
h += match_len;
while (*h == ' ' || *h == '\t')
h++;
len = end - h;
os_free(callback_urls);
callback_urls = dup_binstr(h, len);
if (callback_urls == NULL) {
ret = HTTP_INTERNAL_SERVER_ERROR;
goto error;
}
if (len > 0 && callback_urls[len - 1] == '\r')
callback_urls[len - 1] = '\0';
continue;
}
/* SID is only for renewal */
match = "SID:";
match_len = os_strlen(match);
if (os_strncasecmp(h, match, match_len) == 0) {
h += match_len;
while (*h == ' ' || *h == '\t')
h++;
match = "uuid:";
match_len = os_strlen(match);
if (os_strncasecmp(h, match, match_len) != 0) {
ret = HTTP_BAD_REQUEST;
goto error;
}
h += match_len;
while (*h == ' ' || *h == '\t')
h++;
if (uuid_str2bin(h, uuid)) {
ret = HTTP_BAD_REQUEST;
goto error;
}
got_uuid = 1;
continue;
}
/* TIMEOUT is requested timeout, but apparently we can
* just ignore this.
*/
}
int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
size_t buf_len )
{
struct i802_bss *bss = priv;
struct wpa_driver_nl80211_data *drv = bss->drv;
struct ifreq ifr;
int ret = 0;
if (os_strcasecmp(cmd, "STOP") == 0) {
linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
} else if (os_strcasecmp(cmd, "START") == 0) {
linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");
} else if (os_strcasecmp(cmd, "RELOAD") == 0) {
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
} else if (os_strncasecmp(cmd, "POWERMODE ", 10) == 0) {
int mode;
mode = atoi(cmd + 10);
ret = wpa_driver_set_power_save(priv, mode);
if (ret < 0) {
wpa_driver_send_hang_msg(drv);
} else {
g_power_mode = mode;
g_drv_errors = 0;
}
} else if (os_strncasecmp(cmd, "GETPOWER", 8) == 0) {
ret = os_snprintf(buf, buf_len, "POWERMODE = %d\n", g_power_mode);
} else if (os_strncasecmp(cmd, "BTCOEXMODE ", 11) == 0) {
int mode = atoi(cmd + 11);
if (mode == BLUETOOTH_COEXISTENCE_MODE_DISABLED) { /* disable BT-coex */
ret = wpa_driver_toggle_btcoex_state('0');
} else if (mode == BLUETOOTH_COEXISTENCE_MODE_SENSE) { /* enable BT-coex */
ret = wpa_driver_toggle_btcoex_state('1');
} else {
wpa_printf(MSG_DEBUG, "invalid btcoex mode: %d", mode);
ret = -1;
}
} else if (os_strcasecmp(cmd, "MACADDR") == 0) {
u8 macaddr[ETH_ALEN] = {};
ret = linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname, macaddr);
if (!ret)
ret = os_snprintf(buf, buf_len,
"Macaddr = " MACSTR "\n", MAC2STR(macaddr));
} else if( os_strncasecmp(cmd, "RXFILTER-ADD ", 13) == 0 ) {
int i = nl80211_parse_wowlan_trigger_nr(cmd + 13);
if(i < 0)
return i;
return nl80211_toggle_wowlan_trigger(bss, i, 1);
} else if( os_strncasecmp(cmd, "RXFILTER-REMOVE ", 16) == 0 ) {
int i = nl80211_parse_wowlan_trigger_nr(cmd + 16);
if(i < 0)
return i;
return nl80211_toggle_wowlan_trigger(bss, i, 0);
} else if( os_strcasecmp(cmd, "RXFILTER-START") == 0 ) {
return nl80211_set_wowlan_triggers(bss, 1);
} else if( os_strcasecmp(cmd, "RXFILTER-STOP") == 0 ) {
return nl80211_set_wowlan_triggers(bss, 0);
} else if( os_strncasecmp(cmd, "DROPBCAST", 9) == 0 ) {
char *value = cmd + 10;
if (!os_strcasecmp(value, "ENABLE") ||
!os_strcasecmp(value, "1")) {
ret = nl80211_toggle_dropbcast(1);
} else if (!os_strcasecmp(value, "DISABLE") ||
!os_strcasecmp(value, "0")) {
ret = nl80211_toggle_dropbcast(0);
} else if (!os_strcasecmp(value, "GET") ||
!os_strlen(value)) {
ret = nl80211_dropbcast_get(buf, buf_len);
} else {
wpa_printf(MSG_ERROR,
"Invalid parameter for DROPBCAST: %s",
value);
ret = -1;
}
} else if( os_strncasecmp(cmd, "SETBAND ", 8) == 0 ) {
int val = atoi(cmd + 8);
ret = 0;
if ( val < 0 || val > 2 )
ret = -1;
} else {
wpa_printf(MSG_INFO, "%s: Unsupported command %s", __func__, cmd);
}
return ret;
}
/* Given that we have received a header w/ GET, act upon it
*
* Format of GET (case-insensitive):
*
* First line must be:
* GET /<file> HTTP/1.1
* Since we don't do anything fancy we just ignore other lines.
*
* Our response (if no error) which includes only required lines is:
* HTTP/1.1 200 OK
* Connection: close
* Content-Type: text/xml
* Date: <rfc1123-date>
*
* Header lines must end with \r\n
* Per RFC 2616, content-length: is not required but connection:close
* would appear to be required (given that we will be closing it!).
*/
static void web_connection_parse_get(struct upnp_wps_device_sm *sm,
struct http_request *hreq, char *filename)
{
struct wpabuf *buf; /* output buffer, allocated */
char *put_length_here;
char *body_start;
enum {
GET_DEVICE_XML_FILE,
GET_SCPD_XML_FILE
} req;
size_t extra_len = 0;
int body_length;
char len_buf[10];
struct upnp_wps_device_interface *iface;
iface = dl_list_first(&sm->interfaces,
struct upnp_wps_device_interface, list);
if (iface == NULL) {
http_request_deinit(hreq);
return;
}
/*
* It is not required that filenames be case insensitive but it is
* allowed and cannot hurt here.
*/
if (os_strcasecmp(filename, UPNP_WPS_DEVICE_XML_FILE) == 0) {
wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP GET for device XML");
req = GET_DEVICE_XML_FILE;
extra_len = 3000;
if (iface->wps->friendly_name)
extra_len += os_strlen(iface->wps->friendly_name);
if (iface->wps->manufacturer_url)
extra_len += os_strlen(iface->wps->manufacturer_url);
if (iface->wps->model_description)
extra_len += os_strlen(iface->wps->model_description);
if (iface->wps->model_url)
extra_len += os_strlen(iface->wps->model_url);
if (iface->wps->upc)
extra_len += os_strlen(iface->wps->upc);
} else if (!os_strcasecmp(filename, UPNP_WPS_SCPD_XML_FILE)) {
wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP GET for SCPD XML");
req = GET_SCPD_XML_FILE;
extra_len = os_strlen(wps_scpd_xml);
} else {
/* File not found */
wpa_printf(MSG_DEBUG, "WPS UPnP: HTTP GET file not found: %s",
filename);
buf = wpabuf_alloc(200);
if (buf == NULL) {
http_request_deinit(hreq);
return;
}
wpabuf_put_str(buf,
"HTTP/1.1 404 Not Found\r\n"
"Connection: close\r\n");
http_put_date(buf);
/* terminating empty line */
wpabuf_put_str(buf, "\r\n");
goto send_buf;
}
buf = wpabuf_alloc(1000 + extra_len);
if (buf == NULL) {
http_request_deinit(hreq);
return;
}
wpabuf_put_str(buf,
"HTTP/1.1 200 OK\r\n"
"Content-Type: text/xml; charset=\"utf-8\"\r\n");
wpabuf_put_str(buf, "Server: Unspecified, UPnP/1.0, Unspecified\r\n");
wpabuf_put_str(buf, "Connection: close\r\n");
wpabuf_put_str(buf, "Content-Length: ");
/*
* We will paste the length in later, leaving some extra whitespace.
* HTTP code is supposed to be tolerant of extra whitespace.
*/
put_length_here = wpabuf_put(buf, 0);
wpabuf_put_str(buf, " \r\n");
http_put_date(buf);
/* terminating empty line */
wpabuf_put_str(buf, "\r\n");
body_start = wpabuf_put(buf, 0);
switch (req) {
case GET_DEVICE_XML_FILE:
format_wps_device_xml(iface, sm, buf);
break;
case GET_SCPD_XML_FILE:
wpabuf_put_str(buf, wps_scpd_xml);
break;
}
/* Now patch in the content length at the end */
body_length = (char *) wpabuf_put(buf, 0) - body_start;
os_snprintf(len_buf, 10, "%d", body_length);
os_memcpy(put_length_here, len_buf, os_strlen(len_buf));
send_buf:
http_request_send_and_deinit(hreq, buf);
}
int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
size_t buf_len )
{
struct i802_bss *bss = priv;
struct wpa_driver_nl80211_data *drv = bss->drv;
struct ifreq ifr;
android_wifi_priv_cmd priv_cmd;
int ret = 0;
if (os_strcasecmp(cmd, "STOP") == 0) {
linux_set_iface_flags(drv->ioctl_sock, bss->ifname, 0);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
} else if (os_strcasecmp(cmd, "START") == 0) {
linux_set_iface_flags(drv->ioctl_sock, bss->ifname, 1);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");
} else if (os_strcasecmp(cmd, "MACADDR") == 0) {
u8 macaddr[ETH_ALEN] = {};
ret = linux_get_ifhwaddr(drv->ioctl_sock, bss->ifname, macaddr);
if (!ret)
ret = os_snprintf(buf, buf_len,
"Macaddr = " MACSTR "\n", MAC2STR(macaddr));
} else if (os_strcasecmp(cmd, "RELOAD") == 0) {
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
} else if (os_strncasecmp(cmd, "POWERMODE ", 10) == 0) {
int state;
state = atoi(cmd + 10);
ret = wpa_driver_set_power_save(priv, state);
if (ret < 0)
wpa_driver_send_hang_msg(drv);
else
drv_errors = 0;
} else if (os_strncasecmp(cmd, "GETPOWER", 8) == 0) {
int state = -1;
ret = wpa_driver_get_power_save(priv, &state);
if (!ret && (state != -1)) {
ret = os_snprintf(buf, buf_len, "POWERMODE = %d\n", state);
drv_errors = 0;
} else {
wpa_driver_send_hang_msg(drv);
}
} else { /* Use private command */
if (os_strcasecmp(cmd, "BGSCAN-START") == 0) {
ret = wpa_driver_set_backgroundscan_params(priv);
if (ret < 0) {
return ret;
}
os_memcpy(buf, "PNOFORCE 1", 11);
} else if (os_strcasecmp(cmd, "BGSCAN-STOP") == 0) {
os_memcpy(buf, "PNOFORCE 0", 11);
} else {
os_memcpy(buf, cmd, strlen(cmd) + 1);
}
memset(&ifr, 0, sizeof(ifr));
memset(&priv_cmd, 0, sizeof(priv_cmd));
os_strncpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
priv_cmd.buf = buf;
priv_cmd.used_len = buf_len;
priv_cmd.total_len = buf_len;
ifr.ifr_data = &priv_cmd;
//alber test if ((ret = ioctl(drv->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr)) < 0) {
//alber test wpa_printf(MSG_ERROR, "%s: failed to issue private commands\n", __func__);
//alber test wpa_driver_send_hang_msg(drv);
//alber } else {
drv_errors = 0;
ret = 0;
if ((os_strcasecmp(cmd, "LINKSPEED") == 0) ||
(os_strcasecmp(cmd, "RSSI") == 0) ||
(os_strcasecmp(cmd, "GETBAND") == 0) ||
(os_strcasecmp(cmd, "P2P_GET_NOA") == 0))
ret = strlen(buf);
wpa_printf(MSG_DEBUG, "%s %s len = %d, %d", __func__, buf, ret, strlen(buf));
//alber test }
}
return ret;
}
/*-----------------------------------------------------------------------------
Routine Name: wpa_driver_tista_driver_cmd
Routine Description: executes driver-specific commands
Arguments:
priv - pointer to private data structure
cmd - command
buf - return buffer
buf_len - buffer length
Return Value: actual buffer length - success, -1 - failure
-----------------------------------------------------------------------------*/
static int wpa_driver_tista_driver_cmd( void *priv, char *cmd, char *buf, size_t buf_len )
{
struct wpa_driver_ti_data *drv = (struct wpa_driver_ti_data *)priv;
int ret = -1, prev_events, flags;
wpa_printf(MSG_DEBUG, "%s %s", __func__, cmd);
if( os_strcasecmp(cmd, "start") == 0 ) {
wpa_printf(MSG_DEBUG,"Start command");
scan_exit(drv); /* Clear scan cache */
ret = wpa_driver_tista_driver_start(priv);
if( ret == 0 ) {
drv->driver_is_loaded = TRUE;
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");
}
return( TI2WPA_STATUS(ret) );
}
TI_CHECK_DRIVER( drv->driver_is_loaded, -1 );
if( os_strcasecmp(cmd, "stop") == 0 ) {
wpa_printf(MSG_DEBUG,"Stop command");
if ((wpa_driver_wext_get_ifflags(drv->wext, &flags) == 0) &&
(flags & IFF_UP)) {
wpa_printf(MSG_ERROR, "TI: %s when iface is UP", cmd);
wpa_driver_wext_set_ifflags(drv->wext, flags & ~IFF_UP);
}
ret = wpa_driver_tista_driver_stop(priv);
if( ret == 0 ) {
scan_exit(drv); /* Clear scan cache */
drv->driver_is_loaded = FALSE;
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
}
}
if( os_strcasecmp(cmd, "reload") == 0 ) {
wpa_printf(MSG_DEBUG,"Reload command");
ret = 0;
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
}
else if( os_strcasecmp(cmd, "macaddr") == 0 ) {
wpa_driver_tista_get_mac_addr(priv);
wpa_printf(MSG_DEBUG, "Macaddr command");
ret = sprintf(buf, "Macaddr = " MACSTR "\n", MAC2STR(drv->own_addr));
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
else if( os_strcasecmp(cmd, "scan-passive") == 0 ) {
wpa_printf(MSG_DEBUG,"Scan Passive command");
drv->scan_type = SCAN_TYPE_NORMAL_PASSIVE;
ret = 0;
}
else if( os_strcasecmp(cmd, "scan-active") == 0 ) {
wpa_printf(MSG_DEBUG,"Scan Active command");
drv->scan_type = SCAN_TYPE_NORMAL_ACTIVE;
ret = 0;
}
else if( os_strcasecmp(cmd, "scan-mode") == 0 ) {
wpa_printf(MSG_DEBUG,"Scan Mode command");
ret = snprintf(buf, buf_len, "ScanMode = %u\n", drv->scan_type);
if (ret < (int)buf_len) {
return( ret );
}
}
else if( os_strcasecmp(cmd, "linkspeed") == 0 ) {
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)(drv->ctx);
wpa_printf(MSG_DEBUG,"Link Speed command");
drv->link_speed = wpa_s->link_speed / 1000000;
ret = sprintf(buf,"LinkSpeed %u\n", drv->link_speed);
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
else if( os_strncasecmp(cmd, "scan-channels", 13) == 0 ) {
int noOfChan;
noOfChan = atoi(cmd + 13);
wpa_printf(MSG_DEBUG,"Scan Channels command = %d", noOfChan);
if( (noOfChan > 0) && (noOfChan <= MAX_NUMBER_OF_CHANNELS_PER_SCAN) )
drv->scan_channels = noOfChan;
ret = sprintf(buf,"Scan-Channels = %d\n", drv->scan_channels);
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
else if( os_strcasecmp(cmd, "rssi-approx") == 0 ) {
scan_result_t *cur_res;
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)(drv->ctx);
scan_ssid_t *p_ssid;
int rssi, len;
wpa_printf(MSG_DEBUG,"rssi-approx command");
if( !wpa_s )
return( ret );
cur_res = scan_get_by_bssid(drv, wpa_s->bssid);
if( cur_res ) {
p_ssid = scan_get_ssid(cur_res);
if( p_ssid ) {
len = (int)(p_ssid->ssid_len);
rssi = cur_res->level;
if( (len > 0) && (len <= MAX_SSID_LEN) && (len < (int)buf_len)) {
os_memcpy((void *)buf, (void *)(p_ssid->ssid), len);
ret = len;
ret += snprintf(&buf[ret], buf_len-len, " rssi %d\n", rssi);
}
}
}
}
else if( os_strcasecmp(cmd, "rssi") == 0 ) {
u8 ssid[MAX_SSID_LEN];
scan_result_t *cur_res;
struct wpa_supplicant *wpa_s = (struct wpa_supplicant *)(drv->ctx);
int rssi_data, rssi_beacon, len;
wpa_printf(MSG_DEBUG,"rssi command");
ret = wpa_driver_tista_get_rssi(priv, &rssi_data, &rssi_beacon);
if( ret == 0 ) {
len = wpa_driver_tista_get_ssid(priv, (u8 *)ssid);
wpa_printf(MSG_DEBUG,"rssi_data %d rssi_beacon %d", rssi_data, rssi_beacon);
if( (len > 0) && (len <= MAX_SSID_LEN) ) {
os_memcpy((void *)buf, (void *)ssid, len);
ret = len;
ret += sprintf(&buf[ret], " rssi %d\n", rssi_beacon);
wpa_printf(MSG_DEBUG, "buf %s", buf);
/* Update cached value */
if( !wpa_s )
return( ret );
cur_res = scan_get_by_bssid(drv, wpa_s->bssid);
if( cur_res )
cur_res->level = rssi_beacon;
}
else
{
wpa_printf(MSG_DEBUG, "Fail to get ssid when reporting rssi");
ret = -1;
}
}
}
else if( os_strncasecmp(cmd, "powermode", 9) == 0 ) {
u32 mode;
TPowerMgr_PowerMode tMode;
mode = (u32)atoi(cmd + 9);
wpa_printf(MSG_DEBUG,"Power Mode command = %u", mode);
if( mode < POWER_MODE_MAX )
{
tMode.PowerMode = (PowerMgr_PowerMode_e)mode;
tMode.PowerMngPriority = POWER_MANAGER_USER_PRIORITY;
ret = wpa_driver_tista_config_power_management( priv, &tMode, 1 );
}
}
else if (os_strncasecmp(cmd, "getpower", 8) == 0 ) {
u32 mode;
TPowerMgr_PowerMode tMode;
os_memset(&tMode, 0, sizeof(TPowerMgr_PowerMode));
ret = wpa_driver_tista_config_power_management( priv, &tMode, 0 );
if( ret == 0 ) {
ret = sprintf(buf, "powermode = %u\n", tMode.PowerMode);
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
}
else if( os_strncasecmp(cmd, "btcoexmode", 10) == 0 ) {
u32 mode;
mode = (u32)atoi(cmd + 10);
wpa_printf(MSG_DEBUG,"BtCoex Mode command = %u", mode);
ret = wpa_driver_tista_enable_bt_coe( priv, mode );
if( ret == 0 ) {
drv->btcoex_mode = mode;
}
}
else if( os_strcasecmp(cmd, "btcoexstat") == 0 ) {
u32 status = drv->btcoex_mode;
wpa_printf(MSG_DEBUG,"BtCoex Status");
ret = wpa_driver_tista_get_bt_coe_status( priv, &status );
if( ret == 0 ) {
ret = sprintf(buf, "btcoexstatus = 0x%x\n", status);
wpa_printf(MSG_DEBUG, "buf %s", buf);
}
}
else if( os_strcasecmp(cmd, "rxfilter-start") == 0 ) {
wpa_printf(MSG_DEBUG,"Rx Data Filter Start command");
ret = wpa_driver_tista_driver_enable_rx_data_filter( priv );
}
else if( os_strcasecmp(cmd, "rxfilter-stop") == 0 ) {
wpa_printf(MSG_DEBUG,"Rx Data Filter Stop command");
ret = wpa_driver_tista_driver_disable_rx_data_filter( priv );
}
else if( os_strcasecmp(cmd, "rxfilter-statistics") == 0 ) {
TCuCommon_RxDataFilteringStatistics stats;
int len, i;
os_memset(&stats, 0, sizeof(TCuCommon_RxDataFilteringStatistics));
wpa_printf(MSG_DEBUG,"Rx Data Filter Statistics command");
ret = wpa_driver_tista_driver_rx_data_filter_statistics( priv, &stats );
if( ret == 0 ) {
ret = snprintf(buf, buf_len, "RxFilterStat: %u", (u32)stats.unmatchedPacketsCount);
for(i=0; ( i < MAX_DATA_FILTERS ); i++) {
ret += snprintf(&buf[ret], buf_len-ret, " %u", (u32)stats.matchedPacketsCount[i]);
}
ret += snprintf(&buf[ret], buf_len-ret, "\n");
if (ret >= (int)buf_len) {
ret = -1;
}
}
}
else if( os_strncasecmp(cmd, "rxfilter-add", 12) == 0 ) {
TRxDataFilterRequest dfreq;
char *cp = cmd + 12;
char *endp;
int type;
if (*cp != '\0') {
type = (int)strtol(cp, &endp, 0);
if (endp != cp) {
wpa_printf(MSG_DEBUG,"Rx Data Filter Add [%d] command", type);
ret = prepare_filter_struct( priv, type, &dfreq );
if( ret == 0 ) {
ret = wpa_driver_tista_driver_rx_data_filter( priv, &dfreq, 1 );
}
}
}
}
else if( os_strncasecmp(cmd, "rxfilter-remove",15) == 0 ) {
TRxDataFilterRequest dfreq;
char *cp = cmd + 15;
char *endp;
int type;
if (*cp != '\0') {
type = (int)strtol(cp, &endp, 0);
if (endp != cp) {
wpa_printf(MSG_DEBUG,"Rx Data Filter remove [%d] command", type);
ret = prepare_filter_struct( priv, type, &dfreq );
if( ret == 0 ) {
ret = wpa_driver_tista_driver_rx_data_filter( priv, &dfreq, 0 );
}
}
}
}
else {
wpa_printf(MSG_DEBUG,"Unsupported command");
}
return ret;
}
static int cmd_inject(int s, int argc, char *argv[])
{
u8 resp[WLANTEST_CTRL_MAX_RESP_LEN];
u8 buf[100], *end, *pos;
int rlen, i;
enum wlantest_inject_protection prot;
/* <frame> <prot> <sender> <BSSID> <STA/ff:ff:ff:ff:ff:ff> */
if (argc < 5) {
printf("inject needs five arguments: frame, protection, "
"sender, BSSID, STA/ff:ff:ff:ff:ff:ff\n");
return -1;
}
pos = buf;
end = buf + sizeof(buf);
WPA_PUT_BE32(pos, WLANTEST_CTRL_INJECT);
pos += 4;
for (i = 0; inject_frames[i].name; i++) {
if (os_strcasecmp(inject_frames[i].name, argv[0]) == 0)
break;
}
if (inject_frames[i].name == NULL) {
printf("Unknown inject frame '%s'\n", argv[0]);
printf("Frames:");
for (i = 0; inject_frames[i].name; i++)
printf(" %s", inject_frames[i].name);
printf("\n");
return -1;
}
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_FRAME,
inject_frames[i].frame);
if (os_strcasecmp(argv[1], "normal") == 0)
prot = WLANTEST_INJECT_NORMAL;
else if (os_strcasecmp(argv[1], "protected") == 0)
prot = WLANTEST_INJECT_PROTECTED;
else if (os_strcasecmp(argv[1], "unprotected") == 0)
prot = WLANTEST_INJECT_UNPROTECTED;
else if (os_strcasecmp(argv[1], "incorrect") == 0)
prot = WLANTEST_INJECT_INCORRECT_KEY;
else {
printf("Unknown protection type '%s'\n", argv[1]);
printf("Protection types: normal protected unprotected "
"incorrect\n");
return -1;
}
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_PROTECTION, prot);
if (os_strcasecmp(argv[2], "ap") == 0) {
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
1);
} else if (os_strcasecmp(argv[2], "sta") == 0) {
pos = attr_add_be32(pos, end, WLANTEST_ATTR_INJECT_SENDER_AP,
0);
} else {
printf("Unknown sender '%s'\n", argv[2]);
printf("Sender types: ap sta\n");
return -1;
}
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_BSSID, ETH_ALEN);
if (hwaddr_aton(argv[3], pos) < 0) {
printf("Invalid BSSID '%s'\n", argv[3]);
return -1;
}
pos += ETH_ALEN;
pos = attr_hdr_add(pos, end, WLANTEST_ATTR_STA_ADDR, ETH_ALEN);
if (hwaddr_aton(argv[4], pos) < 0) {
printf("Invalid STA '%s'\n", argv[4]);
return -1;
}
pos += ETH_ALEN;
rlen = cmd_send_and_recv(s, buf, pos - buf, resp, sizeof(resp));
if (rlen < 0)
return -1;
printf("OK\n");
return 0;
}
static int wpa_driver_priv_driver_cmd(void *priv, char *cmd, char *buf, size_t buf_len)
{
struct wpa_driver_awext_data *drv = priv;
int ret = -1;
int flags;
wpa_printf(MSG_DEBUG, "AWEXT: %s %s", __func__, cmd);
if (os_strcasecmp(cmd, "start") == 0) {
wpa_printf(MSG_DEBUG,"Start command");
return (ret);
}
if (os_strcasecmp(cmd, "stop") == 0) {
wpa_printf(MSG_DEBUG,"Stop command");
if ((wpa_driver_awext_get_ifflags(drv, &flags) == 0) &&
(flags & IFF_UP)) {
wpa_printf(MSG_ERROR, "WEXT: %s when iface is UP", cmd);
wpa_driver_awext_set_ifflags(drv, flags & ~IFF_UP);
}
}
else if (os_strcasecmp(cmd, "reload") == 0) {
wpa_printf(MSG_DEBUG,"Reload command");
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
return ret;
}
else if (os_strcasecmp(cmd, "macaddr") == 0) {
struct ifreq ifr;
os_memset(&ifr, 0, sizeof(ifr));
os_strncpy(ifr.ifr_name, drv->ifname, IFNAMSIZ);
if (ioctl(drv->ioctl_sock, SIOCGIFHWADDR, &ifr) < 0) {
perror("ioctl[SIOCGIFHWADDR]");
ret = -1;
} else {
u8 *macaddr = (u8 *) ifr.ifr_hwaddr.sa_data;
ret = snprintf(buf, buf_len, "Macaddr = " MACSTR "\n",
MAC2STR(macaddr));
}
}
else if (os_strcasecmp(cmd, "scan-passive") == 0) {
wpa_printf(MSG_DEBUG,"Scan Passive command");
}
else if (os_strcasecmp(cmd, "scan-active") == 0) {
wpa_printf(MSG_DEBUG,"Scan Active command");
}
else if (os_strcasecmp(cmd, "linkspeed") == 0) {
struct iwreq wrq;
unsigned int linkspeed;
os_strncpy(wrq.ifr_name, drv->ifname, IFNAMSIZ);
wpa_printf(MSG_DEBUG,"Link Speed command");
if (ioctl(drv->ioctl_sock, SIOCGIWRATE, &wrq) < 0) {
perror("ioctl[SIOCGIWRATE]");
ret = -1;
} else {
linkspeed = wrq.u.bitrate.value / 1000000;
ret = snprintf(buf, buf_len, "LinkSpeed %d\n", linkspeed);
}
}
else if (os_strncasecmp(cmd, "scan-channels", 13) == 0) {
}
else if ((os_strcasecmp(cmd, "rssi") == 0) || (os_strcasecmp(cmd, "rssi-approx") == 0)) {
struct iwreq wrq;
struct iw_statistics stats;
signed int rssi;
wpa_printf(MSG_DEBUG, ">>>. DRIVER AWEXT RSSI ");
wrq.u.data.pointer = (caddr_t) &stats;
wrq.u.data.length = sizeof(stats);
wrq.u.data.flags = 1; /* Clear updated flag */
strncpy(wrq.ifr_name, drv->ifname, IFNAMSIZ);
if (ioctl(drv->ioctl_sock, SIOCGIWSTATS, &wrq) < 0) {
perror("ioctl[SIOCGIWSTATS]");
ret = -1;
} else {
if (stats.qual.updated & IW_QUAL_DBM) {
/* Values in dBm, stored in u8 with range 63 : -192 */
rssi = ( stats.qual.level > 63 ) ?
stats.qual.level - 0x100 :
stats.qual.level;
} else {
rssi = stats.qual.level;
}
if (drv->ssid_len != 0 && drv->ssid_len < buf_len) {
os_memcpy((void *) buf, (void *) (drv->ssid),
drv->ssid_len );
ret = drv->ssid_len;
ret += snprintf(&buf[ret], buf_len-ret,
" rssi %d\n", rssi);
if (ret < (int)buf_len) {
return( ret );
}
ret = -1;
}
}
}
else if (os_strncasecmp(cmd, "powermode", 9) == 0) {
}
else if (os_strncasecmp(cmd, "getpower", 8) == 0) {
}
else if (os_strncasecmp(cmd, "get-rts-threshold", 17) == 0) {
struct iwreq wrq;
unsigned int rtsThreshold;
strncpy(wrq.ifr_name, drv->ifname, IFNAMSIZ);
if (ioctl(drv->ioctl_sock, SIOCGIWRTS, &wrq) < 0) {
perror("ioctl[SIOCGIWRTS]");
ret = -1;
} else {
rtsThreshold = wrq.u.rts.value;
wpa_printf(MSG_DEBUG,"Get RTS Threshold command = %d",
rtsThreshold);
ret = snprintf(buf, buf_len, "rts-threshold = %u\n",
rtsThreshold);
if (ret < (int)buf_len) {
return( ret );
}
}
}
else if (os_strncasecmp(cmd, "set-rts-threshold", 17) == 0) {
struct iwreq wrq;
unsigned int rtsThreshold;
char *cp = cmd + 17;
char *endp;
strncpy(wrq.ifr_name, drv->ifname, IFNAMSIZ);
if (*cp != '\0') {
rtsThreshold = (unsigned int)strtol(cp, &endp, 0);
if (endp != cp) {
wrq.u.rts.value = rtsThreshold;
wrq.u.rts.fixed = 1;
wrq.u.rts.disabled = 0;
if (ioctl(drv->ioctl_sock, SIOCSIWRTS, &wrq) < 0) {
perror("ioctl[SIOCGIWRTS]");
ret = -1;
} else {
rtsThreshold = wrq.u.rts.value;
wpa_printf(MSG_DEBUG,"Set RTS Threshold command = %d", rtsThreshold);
ret = 0;
}
}
}
}
else if (os_strcasecmp(cmd, "btcoexscan-start") == 0) {
}
else if (os_strcasecmp(cmd, "btcoexscan-stop") == 0) {
}
else if (os_strcasecmp(cmd, "rxfilter-start") == 0) {
wpa_printf(MSG_DEBUG,"Rx Data Filter Start command");
}
else if (os_strcasecmp(cmd, "rxfilter-stop") == 0) {
wpa_printf(MSG_DEBUG,"Rx Data Filter Stop command");
}
else if (os_strcasecmp(cmd, "rxfilter-statistics") == 0) {
}
else if (os_strncasecmp(cmd, "rxfilter-add", 12) == 0 ) {
}
else if (os_strncasecmp(cmd, "rxfilter-remove",15) == 0) {
}
else if (os_strcasecmp(cmd, "snr") == 0) {
struct iwreq wrq;
struct iw_statistics stats;
int snr, rssi, noise;
wrq.u.data.pointer = (caddr_t) &stats;
wrq.u.data.length = sizeof(stats);
wrq.u.data.flags = 1; /* Clear updated flag */
strncpy(wrq.ifr_name, drv->ifname, IFNAMSIZ);
if (ioctl(drv->ioctl_sock, SIOCGIWSTATS, &wrq) < 0) {
perror("ioctl[SIOCGIWSTATS]");
ret = -1;
} else {
if (stats.qual.updated & IW_QUAL_DBM) {
/* Values in dBm, stored in u8 with range 63 : -192 */
rssi = ( stats.qual.level > 63 ) ?
stats.qual.level - 0x100 :
stats.qual.level;
noise = ( stats.qual.noise > 63 ) ?
stats.qual.noise - 0x100 :
stats.qual.noise;
} else {
rssi = stats.qual.level;
noise = stats.qual.noise;
}
snr = rssi - noise;
ret = snprintf(buf, buf_len, "snr = %u\n", (unsigned int)snr);
if (ret < (int)buf_len) {
return( ret );
}
}
}
else if (os_strncasecmp(cmd, "btcoexmode", 10) == 0) {
}
else if( os_strcasecmp(cmd, "btcoexstat") == 0 ) {
}
else {
wpa_printf(MSG_DEBUG,"Unsupported command");
}
return (ret);
}
int fst_test_req_send_fst_response(const char *params)
{
int fsts_id;
Boolean is_valid;
char *endp;
struct fst_setup_res res;
struct fst_session s;
struct fst_group *g;
enum hostapd_hw_mode hw_mode;
u8 status_code;
u8 channel;
char response[FST_MAX_COMMAND_WORD_NAME_LENGTH];
struct fst_session *_s;
if (params[0] != ' ')
return -EINVAL;
params++;
fsts_id = fst_read_next_int_param(params, &is_valid, &endp);
if (!is_valid)
return -EINVAL;
if (get_group_fill_session(&g, &s))
return -EINVAL;
status_code = WLAN_STATUS_SUCCESS;
if (!fst_read_next_text_param(endp, response, sizeof(response),
&endp)) {
if (!os_strcasecmp(response, FST_CS_PVAL_RESPONSE_REJECT))
status_code = WLAN_STATUS_PENDING_ADMITTING_FST_SESSION;
}
os_memset(&res, 0, sizeof(res));
res.action = FST_ACTION_SETUP_RESPONSE;
/*
* If some session has just received an FST Setup Request, then
* use the correct dialog token copied from this request.
*/
_s = fst_find_session_in_progress(fst_session_get_peer_addr(&s, TRUE),
g);
res.dialog_token = (_s && fst_session_is_ready_pending(_s)) ?
_s->data.pending_setup_req_dlgt : g->dialog_token;
res.status_code = status_code;
res.stie.element_id = WLAN_EID_SESSION_TRANSITION;
res.stie.length = sizeof(res.stie) - 2;
if (res.status_code == WLAN_STATUS_SUCCESS) {
res.stie.fsts_id = fsts_id;
res.stie.session_control = SESSION_CONTROL(SESSION_TYPE_BSS, 0);
fst_iface_get_channel_info(s.data.new_iface, &hw_mode,
&channel);
res.stie.new_band_id = fst_hw_mode_to_band(hw_mode);
res.stie.new_band_op = 1;
res.stie.new_band_setup = 0;
fst_iface_get_channel_info(s.data.old_iface, &hw_mode,
&channel);
res.stie.old_band_id = fst_hw_mode_to_band(hw_mode);
res.stie.old_band_op = 1;
res.stie.old_band_setup = 0;
}
if (!fst_read_next_text_param(endp, response, sizeof(response),
&endp)) {
if (!os_strcasecmp(response, FST_CTR_PVAL_BAD_NEW_BAND))
res.stie.new_band_id = res.stie.old_band_id;
}
return fst_session_send_action(&s, TRUE, &res, sizeof(res),
s.data.old_iface->mb_ie);
}
int eapol_auth_set_conf(struct eapol_state_machine *sm, const char *param,
const char *value)
{
wpa_printf(MSG_DEBUG, "EAPOL: External configuration operation for "
MACSTR " - param=%s value=%s",
MAC2STR(sm->addr), param, value);
if (os_strcasecmp(param, "AdminControlledDirections") == 0) {
if (os_strcmp(value, "Both") == 0)
sm->adminControlledDirections = Both;
else if (os_strcmp(value, "In") == 0)
sm->adminControlledDirections = In;
else
return -1;
eapol_auth_step(sm);
return 0;
}
if (os_strcasecmp(param, "AdminControlledPortControl") == 0) {
if (os_strcmp(value, "ForceAuthorized") == 0)
sm->portControl = ForceAuthorized;
else if (os_strcmp(value, "ForceUnauthorized") == 0)
sm->portControl = ForceUnauthorized;
else if (os_strcmp(value, "Auto") == 0)
sm->portControl = Auto;
else
return -1;
eapol_auth_step(sm);
return 0;
}
if (os_strcasecmp(param, "quietPeriod") == 0) {
sm->quietPeriod = atoi(value);
return 0;
}
if (os_strcasecmp(param, "serverTimeout") == 0) {
sm->serverTimeout = atoi(value);
return 0;
}
if (os_strcasecmp(param, "reAuthPeriod") == 0) {
sm->reAuthPeriod = atoi(value);
return 0;
}
if (os_strcasecmp(param, "reAuthEnabled") == 0) {
if (os_strcmp(value, "TRUE") == 0)
sm->reAuthEnabled = TRUE;
else if (os_strcmp(value, "FALSE") == 0)
sm->reAuthEnabled = FALSE;
else
return -1;
eapol_auth_step(sm);
return 0;
}
if (os_strcasecmp(param, "KeyTransmissionEnabled") == 0) {
if (os_strcmp(value, "TRUE") == 0)
sm->keyTxEnabled = TRUE;
else if (os_strcmp(value, "FALSE") == 0)
sm->keyTxEnabled = FALSE;
else
return -1;
eapol_auth_step(sm);
return 0;
}
return -1;
}
int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
size_t buf_len )
{
struct i802_bss *bss = priv;
struct wpa_driver_nl80211_data *drv = bss->drv;
struct ifreq ifr;
android_wifi_priv_cmd priv_cmd;
int ret = 0;
if (os_strcasecmp(cmd, "STOP") == 0) {
linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
} else if (os_strcasecmp(cmd, "START") == 0) {
linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1);
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");
} else if (os_strcasecmp(cmd, "MACADDR") == 0) {
u8 macaddr[ETH_ALEN] = {};
ret = linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname, macaddr);
if (!ret)
ret = os_snprintf(buf, buf_len,
"Macaddr = " MACSTR "\n", MAC2STR(macaddr));
} else if (os_strcasecmp(cmd, "RELOAD") == 0) {
wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "HANGED");
} else if (os_strncasecmp(cmd, "POWERMODE ", 10) == 0) {
int state;
state = atoi(cmd + 10);
ret = wpa_driver_set_power_save(priv, state);
if (ret < 0)
wpa_driver_send_hang_msg(drv);
else
drv_errors = 0;
} else if (os_strncasecmp(cmd, "GETPOWER", 8) == 0) {
int state = -1;
ret = wpa_driver_get_power_save(priv, &state);
if (!ret && (state != -1)) {
ret = os_snprintf(buf, buf_len, "POWERMODE = %d\n", state);
drv_errors = 0;
} else {
wpa_driver_send_hang_msg(drv);
}
} else if(os_strcmp(cmd, "SCAN-ACTIVE") == 0) {
return 0; /* unsupported function */
} else if(os_strcmp(cmd, "SCAN-PASSIVE") == 0) {
return 0; /* unsupported function */
} else if(os_strncmp(cmd, "RXFILTER-ADD ", 13) == 0) {
return 0; /* Ignore it */
} else if(os_strncmp(cmd, "RXFILTER-REMOVE ", 16) == 0) {
return 0; /* Ignore it */
} else if(os_strncmp(cmd, "BTCOEXMODE ", 11) == 0) {
int mode;
if (sscanf(cmd, "%*s %d", &mode)==1) {
/*
* Android disable BT-COEX when obtaining dhcp packet except there is headset is connected
* It enable the BT-COEX after dhcp process is finished
* We ignore since we have our way to do bt-coex during dhcp obtaining.
*/
switch (mode) {
case 1: /* Disable*/
break;
case 0: /* Enable */
/* fall through */
case 2: /* Sense*/
/* fall through */
default:
break;
}
return 0; /* ignore it */
}
} else if(os_strcmp(cmd, "RXFILTER-START") == 0) {
// STUB
return 0;
} else if(os_strcmp(cmd, "RXFILTER-STOP") == 0) {
// STUB
return 0;
} else { /* Use private command */
if (os_strcasecmp(cmd, "BGSCAN-START") == 0) {
ret = wpa_driver_set_backgroundscan_params(priv);
if (ret < 0) {
return ret;
}
os_memcpy(buf, "PNOFORCE 1", 11);
} else if (os_strcasecmp(cmd, "BGSCAN-STOP") == 0) {
os_memcpy(buf, "PNOFORCE 0", 11);
} else {
os_memcpy(buf, cmd, strlen(cmd) + 1);
}
memset(&ifr, 0, sizeof(ifr));
memset(&priv_cmd, 0, sizeof(priv_cmd));
os_strncpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);
priv_cmd.buf = buf;
priv_cmd.used_len = buf_len;
priv_cmd.total_len = buf_len;
ifr.ifr_data = &priv_cmd;
if ((ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr)) < 0) {
wpa_printf(MSG_ERROR, "%s: failed to issue private commands\n", __func__);
wpa_driver_send_hang_msg(drv);
} else {
drv_errors = 0;
ret = 0;
if ((os_strcasecmp(cmd, "LINKSPEED") == 0) ||
(os_strcasecmp(cmd, "RSSI") == 0) ||
(os_strcasecmp(cmd, "GETBAND") == 0) )
ret = strlen(buf);
wpa_printf(MSG_DEBUG, "%s %s len = %d, %d", __func__, buf, ret, strlen(buf));
}
}
return ret;
}
