static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read,
int action_monitor)
{
int first = 1;
if (ctrl == NULL) {
wpa_cli_reconnect();
return;
}
while (wpa_ctrl_pending(ctrl) > 0) {
char buf[256];
size_t len = sizeof(buf) - 1;
if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
buf[len] = '\0';
if (action_monitor)
wpa_cli_action_process(buf);
else {
if (in_read && first)
printf("\n");
first = 0;
printf("%s\n", buf);
}
} else {
printf("Could not read pending message.\n");
break;
}
}
if (wpa_ctrl_pending(ctrl) < 0) {
printf("Connection to wpa_supplicant lost - trying to "
"reconnect\n");
wpa_cli_reconnect();
}
}
static void hostapd_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read,
int action_monitor)
{
int first = 1;
if (ctrl_conn == NULL)
return;
while (wpa_ctrl_pending(ctrl)) {
char buf[256];
size_t len = sizeof(buf) - 1;
if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
buf[len] = '\0';
if (action_monitor)
hostapd_cli_action_process(buf, len);
else {
cli_event(buf);
if (in_read && first)
printf("\n");
first = 0;
printf("%s\n", buf);
}
} else {
printf("Could not read pending message.\n");
break;
}
}
}
void* wifi_manager::_wifi_recv_thread(void* data) {
wifi_manager* _manager = (wifi_manager*)data;
int ret;
char buf[256];
size_t len;
while(_manager->_is_running) {
ret = wpa_ctrl_pending(_manager->_event_ctrl);
if(ret == 1) {
len = 256;
if(!wpa_ctrl_recv(_manager->_event_ctrl,buf,&len)) {
buf[len] = 0;
list<wifi_event_call*>::node* pcall = NULL;
//printf("***%s\n",buf);
for(list<wifi_event_call*>::node* _c = _manager->_call_list.begin();_c != _manager->_call_list.end();_c = _c->next) {
if(strncmp(buf+3,_c->element->event,strlen(_c->element->event)) == 0) {
pcall = _c;
}
}
if(pcall) {
(*pcall->element->_func)(buf[1] - '0',buf + 3 + strlen(pcall->element->event),pcall->element->data);
}
}
}else if(ret == -1)
break;
usleep(1);
}
return NULL;
}
static void process_wpa()
{
while (wpa_ctrl_pending(ctrl)) {
size_t reply_len = sizeof(wpa_buffer);
if (wpa_ctrl_recv(ctrl, wpa_buffer, &reply_len) < 0)
err(EXIT_FAILURE, "wpa_ctrl_recv");
send_to_erl(wpa_buffer, reply_len);
}
}
void WpaGui::receiveMsgs()
{
char buf[256];
size_t len;
while (monitor_conn && wpa_ctrl_pending(monitor_conn) > 0) {
len = sizeof(buf) - 1;
if (wpa_ctrl_recv(monitor_conn, buf, &len) == 0) {
buf[len] = '\0';
processMsg(buf);
}
}
}
void WpaGui::receiveMsgs()
{
char buf[256];printf("========== WpaGui::receiveMsgs Function.=========\n");
size_t len;
while (monitor_conn && wpa_ctrl_pending(monitor_conn) > 0) {
len = sizeof(buf) - 1;
if (wpa_ctrl_recv(monitor_conn, buf, &len) == 0) {
buf[len] = '\0';printf("======== receiveMsgs:%s \n",buf);
processMsg(buf);
}
}
}
int WiFiNode::waitFor(const char *waitStr, const int &timeoutMs) {
int result = -1;
int retry = timeoutMs ? timeoutMs : 1000;
if (!wpaCtrl || !waitStr) {
DBGMSG_ERR("Input is Null");
return result;
}
char replyBuff[1024] = {0};
const size_t replySize = sizeof(replyBuff) - 1;
do {
if (!wpa_ctrl_pending(wpaCtrl)) {
usleep(1000);
} else {
size_t replyLen = replySize;
int readRes = wpa_ctrl_recv(wpaCtrl, replyBuff, &replyLen);
if (readRes) {
DBGMSG_ERR("Read failed %d", readRes);
return readRes;
}
replyBuff[replyLen] = '\0';
DBGMSG_M("Read %d [%s]", replyLen, replyBuff);
if (strstr(replyBuff, waitStr)) {
DBGMSG_H("Compare Hit!");
result = 0;
DBGMSG_M("wpa_ctrl_pending %d", wpa_ctrl_pending(wpaCtrl));
break;
}
DBGMSG_M("Continue waiting. Elapsed %d from %d", timeoutMs - retry, timeoutMs);
}
} while (retry--);
if (!retry) {
DBGMSG_M("Exit by Timeout");
}
return result;
}
/* ----------------------------------------------------------------------------- WPACtrl_pending */
static PyObject* WPACtrl_pending(WPACtrl* self)
{
int ret;
ret = wpa_ctrl_pending(self->ctrl_iface);
switch (ret) {
case 1:
Py_RETURN_TRUE;
case 0:
Py_RETURN_FALSE;
case -1:
PyErr_SetString(WPACtrl_error, "wpa_ctrl_pending failed");
break;
default:
PyErr_SetString(WPACtrl_error, "wpa_ctrl_pending returned unknown error");
break;
}
return NULL;
}
static void wpa_cli_reconnect(void)
{
wpa_cli_close_connection();
ctrl_conn = wpa_cli_open_connection(ctrl_ifname);
if (ctrl_conn) {
printf("Connection to wpa_supplicant re-established\n");
#ifdef ANDROID
if (wpa_ctrl_attach(monitor_conn) == 0) {
#else
if (wpa_ctrl_attach(ctrl_conn) == 0) {
#endif
wpa_cli_attached = 1;
} else {
printf("Warning: Failed to attach to "
"wpa_supplicant.\n");
}
}
}
static void wpa_cli_recv_pending(struct wpa_ctrl *ctrl, int in_read,
int action_monitor)
{
int first = 1;
#ifdef ANDROID
if (ctrl == NULL) {
#else
if (ctrl_conn == NULL) {
#endif
wpa_cli_reconnect();
return;
}
while (wpa_ctrl_pending(ctrl) > 0) {
char buf[256];
size_t len = sizeof(buf) - 1;
if (wpa_ctrl_recv(ctrl, buf, &len) == 0) {
buf[len] = '\0';
if (action_monitor)
wpa_cli_action_process(buf);
else {
if (in_read && first)
printf("\n");
first = 0;
printf("%s\n", buf);
}
} else {
printf("Could not read pending message.\n");
break;
}
}
if (wpa_ctrl_pending(ctrl) < 0) {
printf("Connection to wpa_supplicant lost - trying to "
"reconnect\n");
wpa_cli_reconnect();
}
}
#ifdef CONFIG_READLINE
static char * wpa_cli_cmd_gen(const char *text, int state)
{
static int i, len;
const char *cmd;
if (state == 0) {
i = 0;
len = os_strlen(text);
}
while ((cmd = wpa_cli_commands[i].cmd)) {
i++;
if (os_strncasecmp(cmd, text, len) == 0)
return os_strdup(cmd);
}
return NULL;
}
static char * wpa_cli_dummy_gen(const char *text, int state)
{
return NULL;
}
static char ** wpa_cli_completion(const char *text, int start, int end)
{
return rl_completion_matches(text, start == 0 ?
wpa_cli_cmd_gen : wpa_cli_dummy_gen);
}
#endif /* CONFIG_READLINE */
static void wpa_cli_interactive(void)
{
#define max_args 10
char cmdbuf[256], *cmd, *argv[max_args], *pos;
int argc;
#ifdef CONFIG_READLINE
char *home, *hfile = NULL;
#endif /* CONFIG_READLINE */
printf("\nInteractive mode\n\n");
#ifdef CONFIG_READLINE
rl_attempted_completion_function = wpa_cli_completion;
home = getenv("HOME");
if (home) {
const char *fname = ".wpa_cli_history";
int hfile_len = os_strlen(home) + 1 + os_strlen(fname) + 1;
hfile = os_malloc(hfile_len);
if (hfile) {
int res;
res = os_snprintf(hfile, hfile_len, "%s/%s", home,
fname);
if (res >= 0 && res < hfile_len) {
hfile[hfile_len - 1] = '\0';
read_history(hfile);
stifle_history(100);
}
}
}
#endif /* CONFIG_READLINE */
do {
#ifdef ANDROID
wpa_cli_recv_pending(monitor_conn, 0, 0);
#else
wpa_cli_recv_pending(ctrl_conn, 0, 0);
#endif
#ifndef CONFIG_NATIVE_WINDOWS
alarm(ping_interval);
#endif /* CONFIG_NATIVE_WINDOWS */
#ifdef CONFIG_READLINE
cmd = readline("> ");
if (cmd && *cmd) {
HIST_ENTRY *h;
while (next_history())
;
h = previous_history();
if (h == NULL || os_strcmp(cmd, h->line) != 0)
add_history(cmd);
next_history();
}
#else /* CONFIG_READLINE */
printf("> ");
cmd = fgets(cmdbuf, sizeof(cmdbuf), stdin);
#endif /* CONFIG_READLINE */
#ifndef CONFIG_NATIVE_WINDOWS
alarm(0);
#endif /* CONFIG_NATIVE_WINDOWS */
if (cmd == NULL)
break;
#ifdef ANDROID
wpa_cli_recv_pending(monitor_conn, 0, 0);
#else
wpa_cli_recv_pending(ctrl_conn, 0, 0);
#endif
pos = cmd;
while (*pos != '\0') {
if (*pos == '\n') {
*pos = '\0';
break;
}
pos++;
}
argc = 0;
pos = cmd;
for (;;) {
while (*pos == ' ')
pos++;
if (*pos == '\0')
break;
argv[argc] = pos;
argc++;
if (argc == max_args)
break;
if (*pos == '"') {
char *pos2 = os_strrchr(pos, '"');
if (pos2)
pos = pos2 + 1;
}
while (*pos != '\0' && *pos != ' ')
pos++;
if (*pos == ' ')
*pos++ = '\0';
}
if (argc)
wpa_request(ctrl_conn, argc, argv);
if (cmd != cmdbuf)
os_free(cmd);
} while (!wpa_cli_quit);
#ifdef CONFIG_READLINE
if (hfile) {
/* Save command history, excluding lines that may contain
* passwords. */
HIST_ENTRY *h;
history_set_pos(0);
while ((h = current_history())) {
char *p = h->line;
while (*p == ' ' || *p == '\t')
p++;
if (cmd_has_sensitive_data(p)) {
h = remove_history(where_history());
if (h) {
os_free(h->line);
os_free(h->data);
os_free(h);
} else
next_history();
} else
next_history();
}
write_history(hfile);
os_free(hfile);
}
#endif /* CONFIG_READLINE */
}
