自学教程：C++ wpa_ctrl_request函数代码示例

static wrapd_status_t wrapd_wpa_s_cmd(wrapd_hdl_t *mctx, char *cmd){    struct wrap_demon *aptr = (void *) mctx;    char buf[2048];    size_t len = sizeof(buf);    int ret;    if (aptr->global == NULL) {        wrapd_printf("Not connected to global wpa_supplicant");        return -1;    }    ret = wpa_ctrl_request(aptr->global, cmd, os_strlen(cmd), buf, &len, NULL);    if (ret == -2) {        wrapd_printf("'%s' command timed out", cmd);        return WRAPD_STATUS_ETIMEDOUT;    } else if (ret < 0) {        wrapd_printf("'%s' command failed", cmd);        return WRAPD_STATUS_FAILED;    }    buf[len] = '/0';    //wrapd_printf("%s", buf);    return WRAPD_STATUS_OK;}

/* ----------------------------------------------------------------------------- WPACtrl_request */static PyObject* WPACtrl_request(WPACtrl* self, PyObject* args, UNUSED PyObject* kargs){	int ret;	char* cmd;	char buf[2048];	size_t buflen = sizeof(buf) - 1;	if (!PyArg_ParseTuple(args, "s", &cmd)) {		PyErr_SetString(WPACtrl_error, "failed to parse request command string");		return NULL;	}	ret = wpa_ctrl_request(self->ctrl_iface, cmd, strlen(cmd), buf, &buflen, NULL);	switch (ret) {	case 0:		buf[buflen] = '/0';		return Py_BuildValue("s", buf);	case -1:		PyErr_SetString(WPACtrl_error, "wpa_ctrl_request failed");		break;	case -2:		PyErr_SetString(WPACtrl_error, "wpa_ctrl_request timed out");		break;	default:		PyErr_SetString(WPACtrl_error, "wpa_ctrl_request returned unknown error");		break;	}	return NULL;}

S32 IpcWpa_CommandWithResp(THandle hIpcWpa, PS8 cmd, S32 print, PS8 pResp, PU32 pRespLen){	TIpcWpa* pIpcWpa = (TIpcWpa*)hIpcWpa;	S32 ret;	*pRespLen = IPC_WPA_RESP_MAX_LEN - 1;	ret = wpa_ctrl_request(pIpcWpa->pWpaCtrl, (char*)cmd, os_strlen(cmd), (char*)pResp, (size_t*)pRespLen, NULL);	if (ret == -2)	{		os_error_printf(CU_MSG_ERROR, (PS8)"'%s' command timed out./n", cmd);		return EOALERR_IPC_WPA_ERROR_CMD_TIMEOUT;	}	else if (ret < 0)	{		os_error_printf(CU_MSG_ERROR, (PS8)"'%s' command failed./n", cmd);		return EOALERR_IPC_WPA_ERROR_CMD_FAILED;	}	if (print)	{		pResp[*pRespLen] = '/0';		os_error_printf(CU_MSG_INFO2, (PS8)"%s", pResp);	}	return OK;}

static void do_wpa_request(char *cmd, size_t len){    size_t reply_len = sizeof(wpa_buffer);    if (wpa_ctrl_request(ctrl, cmd, len, wpa_buffer, &reply_len, send_to_erl) < 0)        err(EXIT_FAILURE, "wpa_ctrl_request");    send_to_erl(wpa_buffer, reply_len);}

static int wpa_ctrl_command_sta(struct wpa_ctrl *ctrl, const char *cmd,				char *addr, size_t addr_len, int print){	char buf[4096], *pos;	size_t len;	int ret;	if (ctrl_conn == NULL) {		printf("Not connected to hostapd - command dropped./n");		return -1;	}	len = sizeof(buf) - 1;	ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len,			       hostapd_cli_msg_cb);	if (ret == -2) {		printf("'%s' command timed out./n", cmd);		return -2;	} else if (ret < 0) {		printf("'%s' command failed./n", cmd);		return -1;	}	buf[len] = '/0';	if (memcmp(buf, "FAIL", 4) == 0)		return -1;	if (print)		printf("%s", buf);	pos = buf;	while (*pos != '/0' && *pos != '/n')		pos++;	*pos = '/0';	os_strlcpy(addr, buf, addr_len);	return 0;}

static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, char *cmd, int print){#ifdef ANDROID	char buf[4096];#else	char buf[2048];#endif	size_t len;	int ret;	if (ctrl_conn == NULL) {		printf("Not connected to wpa_supplicant - command dropped./n");		return -1;	}	len = sizeof(buf) - 1;	ret = wpa_ctrl_request(ctrl, cmd, os_strlen(cmd), buf, &len,			       wpa_cli_msg_cb);	if (ret == -2) {		printf("'%s' command timed out./n", cmd);		return -2;	} else if (ret < 0) {		printf("'%s' command failed./n", cmd);		return -1;	}	if (print) {		buf[len] = '/0';		printf("%s", buf);	}	return 0;}

void  SIGQUIT_handler(int sig){     char *cmd = "GET channel";     char buf[2];     size_t len;     int ret;          int ShmID_getchar;     char *ShmPTR_getchar;     key_t MyKey_getchar;     MyKey_getchar = 7878;     ShmID_getchar = shmget(MyKey_getchar, sizeof(char), IPC_CREAT | 0666);     ShmPTR_getchar = (char *) shmat(ShmID_getchar, NULL, 0);     if(sig == SIGQUIT) {         printf("SIGQUIT signal to get channel received/n");     }     ctrl_ifname = "wlan0";     len = sizeof(buf)-1;     ctrl_conn = hostapd_cli_open_connection(ctrl_ifname);     if (ctrl_conn) {         printf("Connection established./n");     }     ret = wpa_ctrl_request(ctrl_conn, cmd, strlen(cmd), buf, &len,                               hostapd_cli_msg_cb);     printf("GET channel command sent/n");     printf("Channel in received buffer is: %c/n", buf[0]);      //Sharring channel with http server     *ShmPTR_getchar = buf[0];     signal(sig, SIGQUIT_handler);}

static void hostapd_cli_action(struct wpa_ctrl *ctrl){	fd_set rfds;	int fd, res;	struct timeval tv;	char buf[256];	size_t len;	fd = wpa_ctrl_get_fd(ctrl);	while (!hostapd_cli_quit) {		FD_ZERO(&rfds);		FD_SET(fd, &rfds);		tv.tv_sec = ping_interval;		tv.tv_usec = 0;		res = select(fd + 1, &rfds, NULL, NULL, &tv);		if (res < 0 && errno != EINTR) {			perror("select");			break;		}		if (FD_ISSET(fd, &rfds))			hostapd_cli_recv_pending(ctrl, 0, 1);		else {			len = sizeof(buf) - 1;			if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,					     hostapd_cli_action_process) < 0 ||			    len < 4 || os_memcmp(buf, "PONG", 4) != 0) {				printf("hostapd did not reply to PING "				       "command - exiting/n");				break;			}		}	}}

int wifi_send_command(struct wpa_ctrl *ctrl, const char *cmd, char *reply, size_t *reply_len){    int ret;    if (ctrl_conn == NULL) {        LOGV("Not connected to wpa_supplicant - /"%s/" command dropped./n", cmd);        return -1;    }    if (strcmp(cmd, "DRIVER START") == 0) {        LOGD("wifi.c : load driver after resume/n");        wifi_load_driver();    }    ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), reply, reply_len, NULL);    LOGV("wifi.c : cmd=%s, reply=%s/n", cmd, reply);    if (strcmp(cmd, "DRIVER STOP") == 0) {        LOGD("wifi.c : unload driver before suspend/n");        wifi_unload_driver();    }    if (ret == -2) {        LOGD("'%s' command timed out./n", cmd);        /* unblocks the monitor receive socket for termination */        write(exit_sockets[0], "T", 1);        return -2;    } else if (ret < 0 || strncmp(reply, "FAIL", 4) == 0) {        return -1;    }    if (strncmp(cmd, "PING", 4) == 0) {        reply[*reply_len] = '/0';    }    return 0;}

/* wpatalk_recv_pending -- process pending packets from authentication * daemon, and return > 0 if there are more packets (less than zero * if error). * If block is set to 1, will sleep waiting for up to one packet. */static int wpatalk_recv_pending(int block){        struct pollfd fds[1];        int nfds;        int more = 0;        int timeout_msec = 0;    /* negative for infinity */        char buf[512]; /* note: large enough to fit in unsolicited messages */	size_t len;        int nloops;        for (nloops = 0; ; nloops++) {	    if (ctrl_conn == NULL) {		return -1;	    }            fds[0].fd = wpa_ctrl_get_fd(ctrl_conn);            fds[0].events = POLLIN;            fds[0].revents = 0;            nfds = 1;            if (nloops > 0) timeout_msec = 1000;            else timeout_msec = 0;            nfds = poll(fds, nfds, timeout_msec);            if (nfds < 0) {                if (errno == EINTR) continue;                #if 1		wpatalk_error("Connection to daemon lost");                #else                wpatalk_fatal("Died on poll() error %d", errno);                #endif                return -1;            }            more = (nfds > 0);            if (more == 0) {                if (block == 0) {                    return 0;       /* nothing pending */                } else {                    /* blocking mode */                    /* verify that connection is still working */                    size_t len = sizeof(buf) - 1;                    if (wpa_ctrl_request(ctrl_conn, "PING", 4, buf, &len,	    		        wpatalk_action_cb) < 0 ||	                len < 4 || os_memcmp(buf, "PONG", 4) != 0) {	    	        wpatalk_error("daemon did not reply to PING");                        return -1;	            }                    /* and try again */                    continue;                }            }	    len = sizeof(buf) - 1;	    if (wpa_ctrl_recv(ctrl_conn, buf, &len) == 0) {	    	buf[len] = '/0';	        wpatalk_info("GOT: %s", buf);	    	wpatalk_action_process(buf);	    } else {	    	wpatalk_error("Could not read pending message.");	    }            break;	}        return more;}

static int _wpa_ctrl_command(struct wpa_ctrl *ctrl, const char *cmd, int print){	char buf[4096];	size_t len;	int ret;	if (ctrl_conn == NULL) {		printf("Not connected to hostapd - command dropped./n");		return -1;	}	len = sizeof(buf) - 1;	ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len,			       hostapd_cli_msg_cb);	if (ret == -2) {		printf("'%s' command timed out./n", cmd);		return -2;	} else if (ret < 0) {		printf("'%s' command failed./n", cmd);		return -1;	}	if (print) {		buf[len] = '/0';		printf("%s", buf);	}	return 0;}

void AddInterface::interfaceSelected(QTreeWidgetItem *sel){	if (!sel)		return;#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE	struct wpa_ctrl *ctrl;	int ret;	char buf[20], cmd[256];	size_t len;	/*	 * INTERFACE_ADD <ifname>TAB<confname>TAB<driver>TAB<ctrl_interface>TAB	 * <driver_param>TAB<bridge_name>	 */	snprintf(cmd, sizeof(cmd),		 "INTERFACE_ADD %s/t%s/t%s/t%s/t%s/t%s",		 sel->text(1).toAscii().constData(),		 "default",		 sel->text(0).toAscii().constData(),		 "yes", "", "");	cmd[sizeof(cmd) - 1] = '/0';	ctrl = wpa_ctrl_open(NULL);	if (ctrl == NULL)		return;	len = sizeof(buf) - 1;	ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len, NULL);	wpa_ctrl_close(ctrl);	if (ret < 0) {		QMessageBox::warning(this, "wpa_gui",				     tr("Add interface command could not be "					"completed."));		return;	}	buf[len] = '/0';	if (buf[0] != 'O' || buf[1] != 'K') {		QMessageBox::warning(this, "wpa_gui",				     tr("Failed to add the interface."));		return;	}#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */#ifdef CONFIG_NATIVE_WINDOWS	if (!addRegistryInterface(sel->text(1))) {		QMessageBox::information(this, "wpa_gui",					 tr("Failed to add the interface into "					    "registry."));	}#endif /* CONFIG_NATIVE_WINDOWS */	wpagui->selectAdapter(sel->text(1));	close();}

void  SIGINT_handler(int sig){	     char *cmd = "CHAN_SWITCH 5 ";     char *finalCmd, charFreq[5];     char buf[2];     size_t len;     int ret;     int freq;     if(sig == SIGINT) {         printf("SIGINT signal to switch channel received/n");     }     //get channel from http server     key_t MyKey_chShare;     int ShmID_chShare;     char *ShmPTR_chShare;     MyKey_chShare   = 5555;     if ((ShmID_chShare   = shmget(MyKey_chShare, sizeof(char), 0666)) < 0) {         perror("shmget");         exit(1);     }     ShmPTR_chShare  = (char *) shmat(ShmID_chShare, NULL, 0);     printf("Channel received from http server is %s/n", ShmPTR_chShare);     //calculate the frequency to set in the channel switch command      int channel;     if(ShmPTR_chShare[0] == '0') {         freq = 2412 + 5*((int)(ShmPTR_chShare[1]) - '1');     }     else {         sscanf(ShmPTR_chShare, "%d", &channel);         freq = 2412 + 5*(channel-1);     }     snprintf(charFreq, sizeof charFreq, "%d", freq);     //generate command for channel switch     finalCmd = malloc(strlen(cmd)+1);     strcpy(finalCmd, cmd);     strcat(finalCmd, charFreq);     printf("Switch channel command = %s/n", finalCmd);     ctrl_ifname = "wlan0";     len = sizeof(buf)-1;     ctrl_conn = hostapd_cli_open_connection(ctrl_ifname);     if (ctrl_conn) {         printf("Connection established./n");     }     printf("command generated = %s/n", finalCmd);     ret = wpa_ctrl_request(ctrl_conn, finalCmd, strlen(finalCmd), buf, &len,                               hostapd_cli_msg_cb);     printf("switch channel command sent/n");      signal(sig, SIGINT_handler);}

bool wifi_manager::save_wificonfig() {	bool ret = false;	size_t len = WIFI_BUFFER_LEN - 1;		do {		if(wpa_ctrl_request(_ctrl,"SAVE_CONFIG",sizeof("SAVE_CONFIG"),_buffer,&len,NULL))			break;				ret = true;	}while(0);		return ret;}

static int wpa_ctrl_attach_helper(struct wpa_ctrl *ctrl, int attach) {    char buf[10];    int ret;    size_t len = 10;    ret = wpa_ctrl_request(ctrl, attach ? "ATTACH" : "DETACH", 6,            buf, &len, NULL);    if (ret < 0)        return ret;    if (len == 3 && os_memcmp(buf, "OK/n", 3) == 0)        return 0;    return -1;}

int WiFiNode::makeRequest(const char *cmd, char *reply, size_t *replyLen) {	if (!wpaCtrl || !cmd || !reply || !replyLen) {		DBGMSG_ERR("Input is Null");		return -1;	}	int res = wpa_ctrl_request(wpaCtrl, cmd, strlen(cmd), reply, replyLen, NULL);	reply[*replyLen] = '/0';	DBGMSG_M("Req [%s] reply [%d] Reply: /n%s", cmd, *replyLen, reply);	if (res || !replyLen) {		DBGMSG_ERR("Req failed");	}	return res;}

int WpaGui::ctrlRequest(const char *cmd, char *buf, size_t *buflen){	int ret;	if (ctrl_conn == NULL)		return -3;	ret = wpa_ctrl_request(ctrl_conn, cmd, strlen(cmd), buf, buflen, NULL);	if (ret == -2)		printf("'%s' command timed out./n", cmd);	else if (ret < 0)		printf("'%s' command failed./n", cmd);	return ret;}

bool wifi_manager::addWifiNetwork(const char* ssid,const char* passwd) {	bool ret = false;	size_t len = WIFI_BUFFER_LEN - 1;	char buf[256] = {0};	int id;	char* p;	do {		if(wpa_ctrl_request(_ctrl,"ADD_NETWORK",sizeof("ADD_NETWORK"),_buffer,&len,NULL))			break;				_buffer[len] = 0;		p = _buffer;		while(*p != '/n')p++;		*p = 0;		id = parse_int_dec(_buffer);				//printf("new network id:%s/n",_buffer);		sprintf(buf,"SET_NETWORK %d ssid /"%s/"",id,ssid);				if(wpa_ctrl_request(_ctrl,buf,strlen(buf),_buffer,&len,NULL))			break;				printf("%s/n",buf);		sprintf(buf,"SET_NETWORK %d psk /"%s/"",id,passwd);				if(wpa_ctrl_request(_ctrl,buf,strlen(buf),_buffer,&len,NULL))			break;		_buffer[len] = 0;			//printf("%s/n%s",buf,_buffer);		ret = true;	}while(0);		return ret;}

int WpaGui::ctrlRequest(const char *cmd, char *buf, size_t *buflen){    int ret;printf("This is WpaGui::ctrlRequest Function.And the cmd is %s /n",cmd);    if (ctrl_conn == NULL)            return -3;    ret = wpa_ctrl_request(ctrl_conn, cmd, strlen(cmd), buf, buflen,                           wpa_gui_msg_cb);    if (ret == -2)            printf("'%s' command timed out./n", cmd);    else if (ret < 0)            printf("'%s' command failed./n", cmd);    return ret;}

static int netcfg_wpa_cmd (char *cmd){    char buf[256];    size_t len;    int ret;        len = sizeof(buf) -1;    ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), buf, &len, NULL);        if (ret < 0) {        di_info("Sending %s to wpasupplicant failed", cmd);        return 1;    }        return 0;}

bool wifi_manager::connectWifi(int id) {	bool ret = false;	size_t len = WIFI_BUFFER_LEN - 1;	char buf[64] = {0};		do {		sprintf(buf,"SELECT_NETWORK %d",id);				if(wpa_ctrl_request(_ctrl,buf,strlen(buf),_buffer,&len,NULL))			break;				//printf("%s/n",buf);		ret = true;	}while(0);		return ret;}

int get_wpa_status(const char *ifname, const char *field, char *obuf,		   size_t obuf_size){	struct wpa_ctrl *ctrl;	char buf[4096];	char *pos, *end;	size_t len, flen;	ctrl = wpa_open_ctrl(ifname);	if (ctrl == NULL)		return -1;	len = sizeof(buf);	if (wpa_ctrl_request(ctrl, "STATUS", 6, buf, &len, NULL) < 0) {		wpa_ctrl_close(ctrl);		return -1;	}	wpa_ctrl_close(ctrl);	buf[len] = '/0';	flen = strlen(field);	pos = buf;	while (pos + flen < buf + len) {		if (pos > buf) {			if (*pos != '/n') {				pos++;				continue;			}			pos++;		}		if (strncmp(pos, field, flen) != 0 || pos[flen] != '=') {			pos++;			continue;		}		pos += flen + 1;		end = strchr(pos, '/n');		if (end == NULL)			return -1;		*end++ = '/0';		if (end - pos > (int) obuf_size)			return -1;		memcpy(obuf, pos, end - pos);		return 0;	}	return -1;}

int sup_cmd(char *result, char *cmd,...) {        va_list args;        int 		res;        char 		cmdbuf   [256];        size_t replen = 512;        if (!wpa_client)            return -1;            /* Not attached to wpa_supplicant control interface. */         va_start(args, cmd);        vsnprintf(cmdbuf, 256, cmd, args);        va_end(args);        res = wpa_ctrl_request(wpa_client, cmdbuf, strlen(cmdbuf), result, &replen, wpa_unsolicited);        if (res)            return res;} 

struct wpa_ctrl * wpa_ctrl_open(const char *ctrl_path){	struct wpa_ctrl *ctrl;	char buf[128];	size_t len;	ctrl = os_malloc(sizeof(*ctrl));	if (ctrl == NULL)		return NULL;	os_memset(ctrl, 0, sizeof(*ctrl));	ctrl->s = socket(PF_INET, SOCK_DGRAM, 0);	if (ctrl->s < 0) {		perror("socket");		os_free(ctrl);		return NULL;	}	ctrl->local.sin_family = AF_INET;	ctrl->local.sin_addr.s_addr = htonl((127 << 24) | 1);	if (bind(ctrl->s, (struct sockaddr *) &ctrl->local,		 sizeof(ctrl->local)) < 0) {		close(ctrl->s);		os_free(ctrl);		return NULL;	}	ctrl->dest.sin_family = AF_INET;	ctrl->dest.sin_addr.s_addr = htonl((127 << 24) | 1);	ctrl->dest.sin_port = htons(WPA_CTRL_IFACE_PORT);	if (connect(ctrl->s, (struct sockaddr *) &ctrl->dest,		    sizeof(ctrl->dest)) < 0) {		perror("connect");		close(ctrl->s);		os_free(ctrl);		return NULL;	}	len = sizeof(buf) - 1;	if (wpa_ctrl_request(ctrl, "GET_COOKIE", 10, buf, &len, NULL) == 0) {		buf[len] = '/0';		ctrl->cookie = strdup(buf);	}	return ctrl;}

static int wpa_set_psk(char *passphrase){    int ret, res;    size_t len;    char buf[256];    char cmd[256];        res = snprintf(cmd, sizeof(cmd), "SET_NETWORK 0 %s /"%s/"", "psk", passphrase);    if (res < 0)        return 1;        len = sizeof(buf) -1;        ret = wpa_ctrl_request(ctrl, cmd, sizeof(cmd), buf, &len, NULL);    if (ret != 0)        return 1;    return 0;}

void AddInterface::addInterfaces(){#ifdef CONFIG_CTRL_IFACE_NAMED_PIPE	struct wpa_ctrl *ctrl;	int ret;	char buf[2048];	size_t len;	ctrl = wpa_ctrl_open(NULL);	if (ctrl == NULL)		return;	len = sizeof(buf) - 1;	ret = wpa_ctrl_request(ctrl, "INTERFACE_LIST", 14, buf, &len, NULL);	if (ret < 0) {		wpa_ctrl_close(ctrl);		return;	}	buf[len] = '/0';	wpa_ctrl_close(ctrl);	QString ifaces(buf);	QStringList lines = ifaces.split(QRegExp("//n"));	for (QStringList::Iterator it = lines.begin();	     it != lines.end(); it++) {		QStringList arg = (*it).split(QChar('/t'));		if (arg.size() < 3)			continue;		QTreeWidgetItem *item = new QTreeWidgetItem(interfaceWidget);		if (!item)			break;		item->setText(0, arg[0]);		item->setText(1, arg[1]);		item->setText(2, arg[2]);	}	interfaceWidget->resizeColumnToContents(0);	interfaceWidget->resizeColumnToContents(1);	interfaceWidget->resizeColumnToContents(2);#endif /* CONFIG_CTRL_IFACE_NAMED_PIPE */}

static int wpa_set_ssid (char *ssid){    int ret, res;    size_t len;    char cmd[256];    char buf[256];        res = snprintf(cmd, sizeof(cmd), "SET_NETWORK 0 %s /"%s/"", "ssid", ssid);    if (res < 0)        return 1;            len = sizeof(buf) -1;    ret = wpa_ctrl_request(ctrl, cmd, sizeof(cmd), buf, &len, NULL);    if (ret != 0) {        di_info("Failed to set the ssid with wpasupplicant");        return 1;    }    return 0;}

int wifi_send_command(struct wpa_ctrl *ctrl, const char *cmd, char *reply, size_t *reply_len){    int ret;    if (ctrl_conn == NULL) {        LOGV("Not connected to wpa_supplicant - /"%s/" command dropped./n", cmd);        return -1;    }    ret = wpa_ctrl_request(ctrl, cmd, strlen(cmd), reply, reply_len, NULL);    if (ret == -2) {        LOGD("'%s' command timed out./n", cmd);        return -2;    } else if (ret < 0 || strncmp(reply, "FAIL", 4) == 0) {        return -1;    }    if (strncmp(cmd, "PING", 4) == 0) {        reply[*reply_len] = '/0';    }    return 0;}

int wpa_command_resp(const char *ifname, const char *cmd,		     char *resp, size_t resp_size){	struct wpa_ctrl *ctrl;	size_t len;	printf("wpa_command(ifname='%s', cmd='%s')/n", ifname, cmd);	ctrl = wpa_open_ctrl(ifname);	if (ctrl == NULL)		return -1;	len = resp_size;	if (wpa_ctrl_request(ctrl, cmd, strlen(cmd), resp, &len, NULL) < 0) {		printf("wpa_command: wpa_ctrl_request failed/n");		wpa_ctrl_close(ctrl);		return -1;	}	wpa_ctrl_close(ctrl);	resp[len] = '/0';	return 0;}

static void wpa_cli_action(struct wpa_ctrl *ctrl){#ifdef CONFIG_ANSI_C_EXTRA	/* TODO: ANSI C version(?) */	printf("Action processing not supported in ANSI C build./n");#else /* CONFIG_ANSI_C_EXTRA */	fd_set rfds;	int fd, res;	struct timeval tv;	char buf[256]; /* note: large enough to fit in unsolicited messages */	size_t len;	fd = wpa_ctrl_get_fd(ctrl);	while (!wpa_cli_quit) {		FD_ZERO(&rfds);		FD_SET(fd, &rfds);		tv.tv_sec = 2;		tv.tv_usec = 0;		res = select(fd + 1, &rfds, NULL, NULL, &tv);		if (res < 0 && errno != EINTR) {			perror("select");			break;		}		if (FD_ISSET(fd, &rfds))			wpa_cli_recv_pending(ctrl, 0, 1);		else {			/* verify that connection is still working */			len = sizeof(buf) - 1;			if (wpa_ctrl_request(ctrl, "PING", 4, buf, &len,					     wpa_cli_action_cb) < 0 ||			    len < 4 || os_memcmp(buf, "PONG", 4) != 0) {				printf("wpa_supplicant did not reply to PING "				       "command - exiting/n");				break;			}		}	}#endif /* CONFIG_ANSI_C_EXTRA */}