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

int wfaStaSetIBSSResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *setIBSSResp = (dutCmdResponse_t *) (cmdBuf + 4);	DPRINT_INFO(WFA_OUT, "Entering wfaStaSetIBSSResp .../n");	switch(setIBSSResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaIBSS running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE/r/n");		break;	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaStaGetStatsResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *getStatsResp = (dutCmdResponse_t *) (cmdBuf + 4);	caStaGetStatsResp_t *stats = &getStatsResp->cmdru.ifStats;	DPRINT_INFO(WFA_OUT, "Entering wfaStaGetStatsResp .../n");	switch(getStatsResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaGetStats running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,txFrames,%i,rxFrames,%i,txMulticast,%i,rxMulticast,%i,fcsErrors,%i,txRetries,%i/r/n",			stats->txFrames, stats->rxFrames, stats->txMulticast, stats->rxMulticast, stats->fcsErrors, stats->txRetries);		break;	case STATUS_ERROR:		sprintf(wfaCAAgetData.gRespStr, "status,ERROR/r/n");		break;	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaStaGetMacAddressResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *getmacResp = (dutCmdResponse_t *) (cmdBuf + 4);	DPRINT_INFO(WFA_OUT, "Entering wfaStaGetMacAddressResp .../n");	switch(getmacResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaGetMacAddress running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,mac,%s/r/n", getmacResp->cmdru.mac);		break;	case STATUS_ERROR:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,mac,00:00:00:00:00:00/r/n");		break;	default:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,mac,00:00:00:00:00:00/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaStaSetEncryptionResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *getBssidResp = (dutCmdResponse_t *) (cmdBuf + 4);	DPRINT_INFO(WFA_OUT, "Entering wfaStaGetBSSIDResp .../n");	switch(getBssidResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaSetEncryption running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,bssid,%s/r/n", getBssidResp->cmdru.bssid);		break;	case STATUS_ERROR:		sprintf(wfaCAAgetData.gRespStr, "status,ERROR/r/n");		break;	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, " %s/n", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaStaGetInfoResp(BYTE *cmdBuf){	dutCmdResponse_t *infoResp = (dutCmdResponse_t *)(cmdBuf + 4);	int done = 0;	switch(infoResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaGetInfo running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,%s/r/n", infoResp->cmdru.info);		break;	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaTrafficAgentPingStopResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *stpResp = (dutCmdResponse_t *) (cmdBuf + 4);	switch(stpResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaTrafficAgentPingStop running .../n");		done = 1;		break;	case STATUS_COMPLETE:		{			sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,sent,%d,replies,%d/r/n",				stpResp->cmdru.pingStp.sendCnt,				stpResp->cmdru.pingStp.repliedCnt);			break;		}	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaStaGetPskResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *p2pResp = (dutCmdResponse_t *) (cmdBuf + 4);	caP2pStaGetPskResp_t *pskInfo= &p2pResp->cmdru.pskInfo;	DPRINT_INFO(WFA_OUT, "Entering wfaStaGetPskResp .../n");	switch(p2pResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaGetPskResp running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,passphrase,%s,ssid,%s/r/n", pskInfo->passPhrase,pskInfo->ssid);		break;	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaStaVerifyIpConnectResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *verifyResp = (dutCmdResponse_t *)(cmdBuf + 4);	DPRINT_INFO(WFA_OUT, "Entering wfaStaVerifyIpConnectResp/n");	switch(verifyResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaVerifyConnect running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,connected,%i/r/n", verifyResp->cmdru.connected);		break;	case STATUS_ERROR:		sprintf(wfaCAAgetData.gRespStr, "status,ERROR/r/n");	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaStaP2pStartGrpFormResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *p2pResp = (dutCmdResponse_t *) (cmdBuf + 4);	DPRINT_INFO(WFA_OUT, "Entering wfaStaP2pStartGrpFormResp .../n");	switch(p2pResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaP2pStartGrpFormResp running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,result,%s,groupid,%s/r/n", p2pResp->cmdru.p2presult,p2pResp->cmdru.grpid);		break;	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

int wfaDeviceGetInfoResp(BYTE *cmdBuf){	int done=1;	dutCmdResponse_t *devInfoResp = (dutCmdResponse_t *) (cmdBuf + 4);	caDeviceGetInfoResp_t *dinfo = &devInfoResp->cmdru.devInfo;	switch(devInfoResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaDeviceGetInfo running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,vendor,%s,model,%s,version,%s/r/n",			dinfo->vendor, dinfo->model, dinfo->version);		break;	default:		sprintf(wfaCAAgetData.gRespStr, "status,INVALID/r/n");	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

/* * wfaStaSetEapTTLS(): *   This is to set *   1. ssid *   2. username *   3. passwd *   4. encrypType - tkip or aes-ccmp *   5. keyManagementType - wpa or wpa2 *   6. trustedRootCA */int wfaStaSetEapTTLS(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){   int ret = 0;   char cmdStr[WFA_CMD_STR_SZ];   caStaSetEapTTLS_t *setTTLS = (caStaSetEapTTLS_t *)caCmdBuf;   char *ifname = setTTLS->intf;   sprintf(cmdStr, "wpa_cli -i %s disable_network 0", ifname);   system(cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 ssid '/"%s/"'", ifname, setTTLS->ssid);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 identity '/"%s/"'", ifname, setTTLS->username);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 password '/"%s/"'", ifname, setTTLS->passwd);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 key_mgmt WPA-EAP", ifname);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);/* This may not need to set. if it is not set, default to take all *///   sprintf(cmdStr, "wpa_cli -i %s set_network 0 pairwise '/"%s/"", ifname, setTTLS->encrptype);//   system(cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 eap TTLS", ifname);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 ca_cert '/"%s/%s/"'", ifname, CERTIFICATES_PATH, setTTLS->trustedRootCA);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 proto WPA", ifname);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 anonymous_identity '/"anonymous/"'", ifname);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   sprintf(cmdStr, "wpa_cli -i %s set_network 0 phase2 '/"auth=MSCHAPV2/"'", ifname);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   sprintf(cmdStr, "wpa_cli -i %s enable_network 0", ifname);   system(cmdStr);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   ret = STATUS_COMPLETE;   wfaEncodeTLV(WFA_STA_SET_EAPTTLS_RESP_TLV, 4, (BYTE *)&ret, respBuf);   *respLen = WFA_TLV_HDR_LEN + 4;   return TRUE;}

/* * wfaTGConfig: store the traffic profile setting that will be used to *           instruct traffic generation. * input: cmd -- not used * response: send success back to controller * return: success or fail * Note: the profile storage is a global space. */int wfaTGConfig(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){    int ret = FALSE;    tgStream_t *myStream = NULL;    dutCmdResponse_t *confResp = &gGenericResp;        /* if the stream table over maximum, reset it */     if(slotCnt == WFA_MAX_TRAFFIC_STREAMS)       slotCnt = 0;    if(slotCnt == 0)    {       printf("resetting stream table/n");       wMEMSET(gStreams, 0, WFA_MAX_TRAFFIC_STREAMS*sizeof(tgStream_t));    }       DPRINT_INFO(WFA_OUT, "entering tcConfig .../n");    myStream = &gStreams[slotCnt++];    wMEMSET(myStream, 0, sizeof(tgStream_t));    wMEMCPY(&myStream->profile, caCmdBuf, len);    myStream->id = ++streamId; /* the id start from 1 */     myStream->tblidx = slotCnt-1;#if 0    DPRINT_INFO(WFA_OUT, "profile %i direction %i dest ip %s dport %i source %s sport %i rate %i duration %i size %i class %i delay %i/n", myStream->profile.profile, myStream->profile.direction, myStream->profile.dipaddr, myStream->profile.dport, myStream->profile.sipaddr, myStream->profile.sport, myStream->profile.rate, myStream->profile.duration, myStream->profile.pksize, myStream->profile.trafficClass, myStream->profile.startdelay);#endif     confResp->status = STATUS_COMPLETE;     confResp->streamId = myStream->id;    wfaEncodeTLV(WFA_TRAFFIC_AGENT_CONFIG_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)confResp, respBuf);    *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t);     return ret;}

static void shutdown_onchannelcallback(void *context){	struct vmbus_channel *channel = context;	u32 recvlen;	u64 requestid;	u8  execute_shutdown = false;	struct shutdown_msg_data *shutdown_msg;	struct icmsg_hdr *icmsghdrp;	struct icmsg_negotiate *negop = NULL;	vmbus_recvpacket(channel, shut_txf_buf,			 PAGE_SIZE, &recvlen, &requestid);	if (recvlen > 0) {		DPRINT_DBG(VMBUS, "shutdown packet: len=%d, requestid=%lld",			   recvlen, requestid);		icmsghdrp = (struct icmsg_hdr *)&shut_txf_buf[			sizeof(struct vmbuspipe_hdr)];		if (icmsghdrp->icmsgtype == ICMSGTYPE_NEGOTIATE) {			prep_negotiate_resp(icmsghdrp, negop, shut_txf_buf);		} else {			shutdown_msg =				(struct shutdown_msg_data *)&shut_txf_buf[					sizeof(struct vmbuspipe_hdr) +					sizeof(struct icmsg_hdr)];			switch (shutdown_msg->flags) {			case 0:			case 1:				icmsghdrp->status = HV_S_OK;				execute_shutdown = true;				DPRINT_INFO(VMBUS, "Shutdown request received -"					    " gracefull shutdown initiated");				break;			default:				icmsghdrp->status = HV_E_FAIL;				execute_shutdown = false;				DPRINT_INFO(VMBUS, "Shutdown request received -"					    " Invalid request");				break;			};		}		icmsghdrp->icflags = ICMSGHDRFLAG_TRANSACTION			| ICMSGHDRFLAG_RESPONSE;		vmbus_sendpacket(channel, shut_txf_buf,				       recvlen, requestid,				       VM_PKT_DATA_INBAND, 0);	}	if (execute_shutdown == true)		orderly_poweroff(false);}

int wfaDeviceGetInfo(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){	caDeviceGetInfoResp_t dinfo;	char cmdStr[WFA_CMD_STR_SZ];	FILE *fd;	if ((fd = popen("/tmp/ASD/wl ver | awk '{print $7}'", "r")) == NULL){		printf("Couldn't open either /tmp/ASD/wl or awk/n");		dinfo.status = STATUS_ERROR;	} else {		memset(&dinfo, 0, sizeof(dinfo));		fgets(cmdStr, sizeof(cmdStr), fd);	/* Ignore first line */		fgets(cmdStr, sizeof(cmdStr), fd);		cmdStr[strlen(cmdStr) - 1] = 0;		/* Get rid of NL */		pclose(fd);	   dinfo.status = STATUS_COMPLETE;	   sprintf(dinfo.vendor, "%.16s", "Broadcom");	   sprintf(dinfo.version, "%.16s", cmdStr);	   sprintf(dinfo.model, "%.8s", "BRCM");	   DPRINT_INFO(WFA_OUT, "Entering wfaDeviceGetInfo .../n");	   DPRINT_INFO(WFA_OUT, "status %i vendor %s model %s version %s/n", dinfo.status, dinfo.vendor, dinfo.model, dinfo.version);	   wfaEncodeTLV(WFA_DEVICE_GET_INFO_RESP_TLV, sizeof(dinfo), (BYTE *)&dinfo, respBuf);   	   *respLen = WFA_TLV_HDR_LEN + sizeof(dinfo);   }   return TRUE;}

bcmSsidObj_t *bcmWfaSsidObjTblAdd(char *ssidStr){	bcmSsidObj_t *bso;	DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblAdd: ssidStr %s/n", ssidStr);	if (bcmSsidIsGood(ssidStr) == FALSE) {		return (NULL);	}	if ((bso = bcmWfaSsidTblSsidFind(ssidStr))) {		DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s): ssid already exists/n", ssidStr);		return (bso);	}	if (!(bso = bcmWfaSsidTblFreeEntry())) {		DPRINT_INFO(WFA_OUT, "no free entry/n");		return (NULL);	}		strcpy(bso->ssidStr, ssidStr);	bso->bssType = BCM_BSS_INFRA; /* init it to infrastructure bss */	bso->primary_key = BCM_PRI_KEY_BAD; /* init it to bad one */	bsotbl.addCnt++;	bsotbl.entries++;	return (bso);}

/* * wfaStaSetUAPSD() *    This is to set *    1. maxSPLength - 0,1,2,or 4  *    2. acBE *    3. acBK *    4. acVI *    5. acVO */int wfaStaSetUAPSD(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){	int ret = 0;	int retVal = TRUE;	caStaSetUAPSD_t *uapsd = (caStaSetUAPSD_t *)caCmdBuf;	bcmSsidObj_t *bso;	char *ssidStr;	DPRINT_INFO(WFA_OUT, "maxSPLength %d acBE %d acBK %d acVI %d acVO %d/n",		uapsd->maxSPLength, uapsd->acBE, uapsd->acBK, uapsd->acVI, uapsd->acVO);	ssidStr = uapsd->ssid;	if (!(bso = bcmWfaSsidTblSsidFind(ssidStr))) {		if (!(bso = bcmWfaSsidObjTblAdd(ssidStr))) {			DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed./n", ssidStr);			retVal = FALSE;			goto exit;		}	}	bso->maxSPLength = uapsd->maxSPLength;	bso->acBE = uapsd->acBE;	bso->acBK = uapsd->acBK;	bso->acVI = uapsd->acVI;	bso->acVO = uapsd->acVO;exit:	ret = STATUS_COMPLETE;	wfaEncodeTLV(WFA_STA_SET_UAPSD_RESP_TLV, 4, (BYTE *)&ret, respBuf);   	*respLen = WFA_TLV_HDR_LEN + 4;	return retVal;}

int wfaStaUploadResp(BYTE *cmdBuf){	int done=0;	dutCmdResponse_t *uploadResp = (dutCmdResponse_t *) (cmdBuf + 4);	caStaUploadResp_t *upld = &uploadResp->cmdru.uld;	switch(uploadResp->status)	{	case STATUS_RUNNING:		DPRINT_INFO(WFA_OUT, "wfaStaUpload running .../n");		done = 1;		break;	case STATUS_COMPLETE:		sprintf(wfaCAAgetData.gRespStr, "status,COMPLETE,code,%i,%s/r/n", 			upld->seqnum, upld->bytes);		break;	case STATUS_ERROR:		sprintf(wfaCAAgetData.gRespStr, "status,ERROR/r/n");		break;	}	DPRINT_INFO(WFA_OUT, "%s", wfaCAAgetData.gRespStr);	wfaCtrlSend(wfaCAAgetData.gCaSockfd, (BYTE *)wfaCAAgetData.gRespStr, strlen(wfaCAAgetData.gRespStr));	return done;}

/* * The function is to set  *   1. ssid *   2. passPhrase *   3. keyMangementType - wpa/wpa2 *   4. encrypType - tkip or aes-ccmp */int wfaStaSetPSK(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){	int ret = 0;	int retVal = TRUE;	caStaSetPSK_t *setPSK = (caStaSetPSK_t *)caCmdBuf;	bcmSsidObj_t *bso;	char *ssidStr;	DPRINT_INFO(WFA_OUT, "wfaStaSetPSK()");	ssidStr = setPSK->ssid;	if (!(bso = bcmWfaSsidTblSsidFind(ssidStr))) {		if (!(bso = bcmWfaSsidObjTblAdd(ssidStr))) {			DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed./n", ssidStr);			retVal = FALSE;			goto exit;		}	}	if (!strcmp(setPSK->keyMgmtType, "wpa")) {		bso->wpa_auth = BCM_WPA_AUTH_PSK; /* WPA-PSK/WPA-Personal */	} else if (!strcmp(setPSK->keyMgmtType, "wpa2")) {		bso->wpa_auth = BCM_WPA2_AUTH_PSK; /* WPA2-PSK/WPA2-Personal */	} else {		DPRINT_ERR(WFA_OUT, "invalid key_mgmt %s", setPSK->keyMgmtType); 		retVal = FALSE;		goto exit;	}	DPRINT_INFO(WFA_OUT, "wpa_auth %d/n", bso->wpa_auth);	if (setPSK->encpType == ENCRYPT_TKIP) {		bso->wsec = 3;	} else if (setPSK->encpType == ENCRYPT_AESCCMP) {		bso->wsec = 7;	} else {		DPRINT_ERR(WFA_OUT, "invalid encpType %d", setPSK->encpType); 		goto exit;	}	DPRINT_INFO(WFA_OUT, "encpType %d wsec %d/n", setPSK->encpType, bso->wsec);	strcpy((char *)bso->passphrase, (char *)setPSK->passphrase);	bso->auth = 0;	if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) {		bcmWfaSsidObjPrint(bso);	}	retVal = TRUE;exit:		ret = STATUS_COMPLETE;	wfaEncodeTLV(WFA_STA_SET_PSK_RESP_TLV, 4, (BYTE *)&ret, respBuf);   	*respLen = WFA_TLV_HDR_LEN + 4;		return retVal; }

/* Not sure what the intention is, but I am using this routine * as storing info only, no action.  Action is taken when we actually associate */int wfaStaSetIBSS(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){	int ret;	int retVal = TRUE;	caStaSetIBSS_t *setIBSS = (caStaSetIBSS_t *)caCmdBuf;	bcmSsidObj_t *bso;	int idx;	char *ssidStr;		DPRINT_INFO(WFA_OUT, "wfaStaSetIBSS()/n");	/* Save the settings for when we need them */	ssidStr = setIBSS->ssid;	if (!(bso = bcmWfaSsidTblSsidFind(ssidStr))) {		if (!(bso = bcmWfaSsidObjTblAdd(ssidStr))) {			DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed./n", ssidStr);			retVal = FALSE;			goto exit;		}	}	bso->bssType = BCM_BSS_INDEPENDENT;	if (setIBSS->channel) {		bso->channel = setIBSS->channel;	}	bso->wsec = (!setIBSS->encpType) ? 0 : 1;	for(idx = 0; idx < 4; idx++) {		if(setIBSS->keys[idx][0] != '/0') {			strcpy(bso->keys[idx], setIBSS->keys[idx]);		} else {			bzero(bso->keys[idx], BCM_WEP_KEY_SIZE_MAX);		}	}	if ((setIBSS->activeKeyIdx > 0) && (setIBSS->activeKeyIdx < 5)) {		/* move the index range from (1 to 4) to (0 to 3) */		bso->primary_key = setIBSS->activeKeyIdx - 1;	}	if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) {		bcmWfaSsidObjPrint(bso);	}exit:	ret = STATUS_COMPLETE;	wfaEncodeTLV(WFA_STA_SET_IBSS_RESP_TLV, 4, (BYTE *)&ret, respBuf);   	*respLen = WFA_TLV_HDR_LEN + 4;		return retVal;}

/* * wfaSetEncryption(): *   The function is to set the wireless interface with WEP or none. *   Input parameters:  *     1. I/F *     2. ssid *     3. encpType - wep or none *     Optional: *     4. key1 *     5. key2 *     6. key3 *     7. key4 *     8. activeKey Index : 1, 2, 3, or 4 */int wfaSetEncryption(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){	int ret = 0;	int retVal = TRUE;	caStaSetEncryption_t *setEncryp = (caStaSetEncryption_t *)caCmdBuf;	int idx;	bcmSsidObj_t *bso;	char * ssidStr;	DPRINT_INFO(WFA_OUT, "wfaSetEncryption()/n");	/* Save the settings for when we need them */	ssidStr = setEncryp->ssid;	if (!(bso = bcmWfaSsidTblSsidFind(ssidStr))) {		if (!(bso = bcmWfaSsidObjTblAdd(ssidStr))) {			DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed./n", ssidStr);			retVal = FALSE;			goto exit;		}	}	/* set Key management to NONE (NO WPA) for plaintext or WEP */	bso->wpa_auth = BCM_WPA_AUTH_DISABLED;	for(idx = 0; idx < 4; idx++) {		if(setEncryp->keys[idx][0] != '/0') {			strcpy(bso->keys[idx], setEncryp->keys[idx]);		} else {			bzero(bso->keys[idx], BCM_WEP_KEY_SIZE_MAX);		}	}	if ((setEncryp->activeKeyIdx > 0) && (setEncryp->activeKeyIdx < 5)) {		/* move the index range from (1 to 4) to (0 to 3) */		bso->primary_key = setEncryp->activeKeyIdx - 1;	}	bso->wsec = (!setEncryp->encpType) ? 0 : 1;	if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) {		bcmWfaSsidObjPrint(bso);	}exit:		ret = STATUS_COMPLETE;	wfaEncodeTLV(WFA_STA_SET_ENCRYPTION_RESP_TLV, 4, (BYTE *)&ret, respBuf);	*respLen = WFA_TLV_HDR_LEN + 4;		return retVal;}

/* * wfaStaGetMacAddress() *    This function is to retrieve the MAC address of a wireless I/F. */int wfaStaGetMacAddress(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){	dutCmdResponse_t getmacResp;	FILE *tmpfd;	DPRINT_INFO(WFA_OUT, "Entering wfaStaGetMacAddress .../n");	if ((tmpfd = popen("/tmp/ASD/wl dump | grep perm | awk '{print $4}'", "r")) == NULL){		int status = STATUS_ERROR;		wfaEncodeTLV(WFA_STA_GET_MAC_ADDRESS_RESP_TLV, 4, (BYTE *)&status, respBuf);   		*respLen = WFA_TLV_HDR_LEN + 4;		DPRINT_ERR(WFA_ERR, "Pipe open for wl dump failed/n");		return FALSE;	}	fgets(getmacResp.cmdru.mac, sizeof(getmacResp.cmdru.mac), tmpfd);	getmacResp.cmdru.mac[strlen(getmacResp.cmdru.mac) - 1] = 0;		/* Get rid of NL */	printf("get_mac_addr: returning mac :%s:/n", getmacResp.cmdru.mac);	pclose (tmpfd);	getmacResp.status = STATUS_COMPLETE; 	wfaEncodeTLV(WFA_STA_GET_MAC_ADDRESS_RESP_TLV, sizeof(getmacResp), 		(BYTE *)&getmacResp, respBuf);   	*respLen = WFA_TLV_HDR_LEN + sizeof(getmacResp);	return TRUE;}

/* * wfaStaIsConnected(): *    The function is to check whether the station's wireless I/F has  *    already connected to an AP. */int wfaStaIsConnected(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){	char cmdStr[WFA_CMD_STR_SZ];	FILE *tmpfd;	dutCmdResponse_t staConnectResp;	DPRINT_INFO(WFA_OUT, "Entering isConnected .../n"); 	/* Associated gets long response */	if ((tmpfd = popen("/tmp/ASD/wl assoc | wc -l", "r")) == NULL){		printf("wc -l failed/n");	}	fgets(cmdStr, sizeof(cmdStr), tmpfd);	pclose(tmpfd);	/* Short response means not associated */	if (atoi(cmdStr) <= 2)		staConnectResp.cmdru.connected = 0;	else		staConnectResp.cmdru.connected = 1;	/*	 * Report back the status: Complete or Failed.	 */	staConnectResp.status = STATUS_COMPLETE;	wfaEncodeTLV(WFA_STA_IS_CONNECTED_RESP_TLV, sizeof(staConnectResp), 		(BYTE *)&staConnectResp, respBuf);   	*respLen = WFA_TLV_HDR_LEN + sizeof(staConnectResp);	return TRUE;}

int storvsc_dev_remove(struct hv_device *device){	struct storvsc_device *stor_device;	DPRINT_INFO(STORVSC, "disabling storage device (%p)...",		    device->ext);	stor_device = release_stor_device(device);	/*	 * At this point, all outbound traffic should be disable. We	 * only allow inbound traffic (responses) to proceed so that	 * outstanding requests can be completed.	 */	storvsc_wait_to_drain(stor_device);	stor_device = final_release_stor_device(device);	/* Close the channel */	vmbus_close(device->channel);	free_stor_device(stor_device);	return 0;}

/* * wfaStaGetStats(): * The function is to retrieve the statistics of the I/F's layer 2 txFrames,  * rxFrames, txMulticast, rxMulticast, fcsErrors/crc, and txRetries. * Currently there is not definition how to use these info.  */int wfaStaGetStats(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){	int ret = 0;	caStaGetStatsResp_t statsResp;	FILE *fd;	char cmdStr[256];	DPRINT_INFO(WFA_OUT, "Entering wfaStaGetStats .../n");	if ((fd = popen("/tmp/ASD/wl dump stats | grep txframe | awk '{print $2,/"//n/",$10}'", "r")) == NULL){		DPRINT_ERR(WFA_ERR, "Couldn't get txframe stats/n");		goto wfaStaGetStats_error;	} else {		fgets(cmdStr, sizeof(cmdStr), fd);	/* line 1: tx frame */		statsResp.txFrames =  atoi(cmdStr);		fgets(cmdStr, sizeof(cmdStr), fd);	/* line 2: rx frame */		statsResp.rxFrames =  atoi(cmdStr);		pclose(fd);	}	if ((fd = popen("/tmp/ASD/wl dump stats | grep txmulti | awk '{print $4, /"//n/", $6 + $8}'", "r")) == NULL){		DPRINT_ERR(WFA_ERR, "Couldn't get d11_txmulti stats/n");		goto wfaStaGetStats_error;	} else {		fgets(cmdStr, sizeof(cmdStr), fd);	/* line 1: txmulti */		statsResp.txMulticast = atoi(cmdStr);		fgets(cmdStr, sizeof(cmdStr), fd);	/* line 2: d11_txretry + d11_txretrie */		statsResp.txRetries = atoi(cmdStr);		pclose(fd);	}	if ((fd = popen("/tmp/ASD/wl dump stats | grep rxdfrmmcast | awk '{print $6 + $8}'", "r")) == NULL){		DPRINT_ERR(WFA_ERR, "Couldn't get rxdfrmmcast stats/n");		goto wfaStaGetStats_error;	} else {		fgets(cmdStr, sizeof(cmdStr), fd);	/* data + mngment mcast frames */		statsResp.rxMulticast = atoi(cmdStr);		pclose(fd);	}	if ((fd = popen("/tmp/ASD/wl dump stats | grep rxbadfcs | awk '{print $8}'", "r")) == NULL){		DPRINT_ERR(WFA_ERR, "Couldn't get rxbadfcs  stats/n");		goto wfaStaGetStats_error;	} else {		fgets(cmdStr, sizeof(cmdStr), fd);		statsResp.fcsErrors = atoi(cmdStr);		pclose(fd);	}	statsResp.status = STATUS_COMPLETE;	wfaEncodeTLV(WFA_STA_GET_STATS_RESP_TLV, sizeof(statsResp), (BYTE *)&statsResp, respBuf);   	*respLen = WFA_TLV_HDR_LEN + sizeof(statsResp);	return TRUE;wfaStaGetStats_error:	ret = STATUS_ERROR;	wfaEncodeTLV(WFA_STA_GET_STATS_RESP_TLV, 4, (BYTE *)&ret, respBuf);   	*respLen = WFA_TLV_HDR_LEN + 4;	return FALSE;}

static void netvsc_xmit_completion(void *context){	struct hv_netvsc_packet *packet = (struct hv_netvsc_packet *)context;	struct sk_buff *skb = (struct sk_buff *)		(unsigned long)packet->Completion.Send.SendCompletionTid;	struct net_device *net;	DPRINT_ENTER(NETVSC_DRV);	kfree(packet);	if (skb) {		net = skb->dev;		dev_kfree_skb_any(skb);		if (netif_queue_stopped(net)) {			DPRINT_INFO(NETVSC_DRV, "net device (%p) waking up...",				    net);			netif_wake_queue(net);		}	}	DPRINT_EXIT(NETVSC_DRV);}

static void netvsc_drv_exit(void){	struct netvsc_driver *netvsc_drv_obj = &g_netvsc_drv.drv_obj;	struct driver_context *drv_ctx = &g_netvsc_drv.drv_ctx;	struct device *current_dev;	int ret;	while (1) {		current_dev = NULL;		/* Get the device */		ret = driver_for_each_device(&drv_ctx->driver, NULL,					     &current_dev, netvsc_drv_exit_cb);		if (ret)			DPRINT_WARN(NETVSC_DRV,				    "driver_for_each_device returned %d", ret);		if (current_dev == NULL)			break;		/* Initiate removal from the top-down */		DPRINT_INFO(NETVSC_DRV, "unregistering device (%p)...",			    current_dev);		device_unregister(current_dev);	}	if (netvsc_drv_obj->base.OnCleanup)		netvsc_drv_obj->base.OnCleanup(&netvsc_drv_obj->base);	vmbus_child_driver_unregister(drv_ctx);	return;}

/* * wfaStaSetIpConfig(): *   The function is to set the ip configuration to a wireless I/F. *   1. IP address *   2. Mac address *   3. default gateway *   4. dns nameserver (pri and sec).   */int wfaStaSetIpConfig(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){   dutCommand_t *setIpConf = (dutCommand_t *)caCmdBuf;   char cmds[128];   int ret = 0;   caStaSetIpConfig_t *ipconfig = &setIpConf->cmdsu.ipconfig;   DPRINT_INFO(WFA_OUT, "entering wfaStaSetIpConfig .../n");   /*    * Use command 'ifconfig' to configure the interface ip address, mask.    * (Linux specific).    */   if (!strlen(ipconfig->intf) || !strlen(ipconfig->ipaddr)){	   ret = STATUS_ERROR;	   wfaEncodeTLV(WFA_STA_SET_IP_CONFIG_RESP_TLV, 4, (BYTE *)&ret, respBuf);   	   *respLen = WFA_TLV_HDR_LEN + 4;	   return TRUE;   }   sprintf(cmds, "%s %s %s ", IFCONFIG_PATH, ipconfig->intf, ipconfig->ipaddr);   if (strlen(ipconfig->mask))   	sprintf(&cmds[strlen(cmds)], "netmask %s ", ipconfig->mask);   system(cmds);   DPRINT_INFO(WFA_OUT, "%s/n", "doing ifconfig");   /* use command 'route add' to set set gatewway (linux specific) */    if(ipconfig->defGateway[0]) {      sprintf(cmds, "%s add default gw %s > /dev/null 2>&1", ROUTE_PATH, ipconfig->defGateway);      system(cmds);      DPRINT_INFO(WFA_OUT, "%s/n", "doing route add");   }   /* set dns (linux specific) */   if (ipconfig->pri_dns[0]){	   sprintf(cmds, "cp /etc/resolv.conf /tmp/resolv.conf.bk");	   system(cmds);	   sprintf(cmds, "echo nameserv %s > /etc/resolv.conf", ipconfig->pri_dns);	   system(cmds);	   sprintf(cmds, "echo nameserv %s >> /etc/resolv.conf", ipconfig->sec_dns);	   system(cmds);   }   ret = STATUS_COMPLETE;   wfaEncodeTLV(WFA_STA_SET_IP_CONFIG_RESP_TLV, 4, (BYTE *)&ret, respBuf);      *respLen = WFA_TLV_HDR_LEN + 4;   return TRUE;}

void bcmWfaSsidObjTblDel(char *ssidStr){	bcmSsidObj_t *bso;	DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblDel: ssidStr %s/n", ssidStr);	bso = bcmWfaSsidTblSsidFind(ssidStr);	if (bso == NULL) {		return;	}	DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblDel: deleting bso %p/n", bso);	bzero(bso, sizeof(bcmSsidObj_t));	bsotbl.delCnt++;	bsotbl.entries--;}

/* * wfaStaVerifyIpConnection(): * The function is to verify if the station has IP connection with an AP by * send ICMP/pings to the AP. */ int wfaStaVerifyIpConnection(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf){   dutCommand_t *verip = (dutCommand_t *)caCmdBuf;   char cmdStr[WFA_CMD_STR_SZ];   FILE *tmpfile;   dutCmdResponse_t verifyIpResp;   dutCommand_t vvv;      DPRINT_INFO(WFA_OUT, "Entering wfaStaVerifyIpConnection .../n");   memcpy(&vvv, caCmdBuf, sizeof(dutCommand_t));   /* set timeout value in case not set */   if(verip->cmdsu.verifyIp.timeout <= 0)        verip->cmdsu.verifyIp.timeout = 10;      /* execute the ping command  and pipe the result to a tmp file */   sprintf(cmdStr, "ping %s -c 3 -W %d | grep '100%%'", verip->cmdsu.verifyIp.dipaddr,  verip->cmdsu.verifyIp.timeout);   DPRINT_INFO(WFA_OUT, "%s/n", cmdStr);   if (strlen(verip->cmdsu.verifyIp.dipaddr) == 0 || ((tmpfile = popen(cmdStr, "r")) == NULL)){      int status = STATUS_ERROR;      wfaEncodeTLV(WFA_STA_VERIFY_IP_CONNECTION_RESP_TLV, 4, (BYTE *)&status, respBuf);         *respLen = WFA_TLV_HDR_LEN + 4;      DPRINT_ERR(WFA_ERR, "Could not execute %s/n", cmdStr);      return FALSE;   }   verifyIpResp.status = STATUS_COMPLETE;   if (fgets(cmdStr, sizeof(cmdStr), tmpfile) == NULL){      verifyIpResp.cmdru.connected = 1;   } else{      verifyIpResp.cmdru.connected = 0;   }   pclose(tmpfile);      wfaEncodeTLV(WFA_STA_VERIFY_IP_CONNECTION_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)&verifyIpResp, respBuf);      *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t);      return TRUE;}