| /**************************************************************************** |
| * (c) Copyright 2007 Wi-Fi Alliance. All Rights Reserved |
| * |
| * |
| * LICENSE |
| * |
| * License is granted only to Wi-Fi Alliance members and designated |
| * contractors ($B!H(BAuthorized Licensees$B!I(B)..AN Authorized Licensees are granted |
| * the non-exclusive, worldwide, limited right to use, copy, import, export |
| * and distribute this software: |
| * (i) solely for noncommercial applications and solely for testing Wi-Fi |
| * equipment; and |
| * (ii) solely for the purpose of embedding the software into Authorized |
| * Licensee$B!G(Bs proprietary equipment and software products for distribution to |
| * its customers utipnder a license with at least the same restrictions as |
| * contained in this License, including, without limitation, the disclaimer of |
| * warranty and limitation of liability, below..AN The distribution rights |
| * granted in clause |
| * (ii), above, include distribution to third party companies who will |
| * redistribute the Authorized Licensee$B!G(Bs product to their customers with or |
| * without such third party$B!G(Bs private label. Other than expressly granted |
| * herein, this License is not transferable or sublicensable, and it does not |
| * extend to and may not be used with non-Wi-Fi applications..AN Wi-Fi Alliance |
| * reserves all rights not expressly granted herein..AN |
| *.AN |
| * Except as specifically set forth above, commercial derivative works of |
| * this software or applications that use the Wi-Fi scripts generated by this |
| * software are NOT AUTHORIZED without specific prior written permission from |
| * Wi-Fi Alliance. |
| *.AN |
| * Non-Commercial derivative works of this software for internal use are |
| * authorized and are limited by the same restrictions; provided, however, |
| * that the Authorized Licensee shall provide Wi-Fi Alliance with a copy of |
| * such derivative works under a perpetual, payment-free license to use, |
| * modify, and distribute such derivative works for purposes of testing Wi-Fi |
| * equipment. |
| *.AN |
| * Neither the name of the author nor "Wi-Fi Alliance" may be used to endorse |
| * or promote products that are derived from or that use this software without |
| * specific prior written permission from Wi-Fi Alliance. |
| * |
| * THIS SOFTWARE IS PROVIDED BY WI-FI ALLIANCE "AS IS" AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY, NON-INFRINGEMENT AND FITNESS FOR A.AN PARTICULAR PURPOSE, |
| * ARE DISCLAIMED. IN NO EVENT SHALL WI-FI ALLIANCE BE LIABLE FOR ANY DIRECT, |
| * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, THE COST OF PROCUREMENT OF SUBSTITUTE |
| * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE) ARISING IN ANY WAY OUT OF |
| * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /* |
| * File: wfa_cs.c -- configuration and setup |
| * This file contains all implementation for the dut setup and control |
| * functions, such as network interfaces, ip address and wireless specific |
| * setup with its supplicant. |
| * |
| * The current implementation is to show how these functions |
| * should be defined in order to support the Agent Control/Test Manager |
| * control commands. To simplify the current work and avoid any GPL licenses, |
| * the functions mostly invoke shell commands by calling linux system call, |
| * system("<commands>"). |
| * |
| * It depends on the differnt device and platform, vendors can choice their |
| * own ways to interact its systems, supplicants and process these commands |
| * such as using the native APIs. |
| * |
| * Revision History: |
| * 2006/03/10 -- initially created by qhu |
| * 2006/06/01 -- BETA Release by qhu |
| * 2006/06/13 -- 00.02 Release by qhu |
| * 2006/06/30 -- 00.10 Release by qhu |
| * 2006/07/10 -- 01.00 Release by qhu |
| * 2006/09/01 -- 01.05 Release by qhu |
| * 2006/10/26 -- 01.06 Released by qhu |
| * replace hardcoded buf size with macro |
| * 2006/12/02 -- bugs: 1. fixes incorrect order of getipconfig.sh |
| * input parameters reported by p.schwann |
| * 2. will add a new network for wap_cli command |
| * in case the network id 0 not present, |
| * recommended by c.benson |
| * the solution is to reimplement with calling |
| * native C API |
| * 2007/01/11 -- 01.10 released by qhu |
| * 2007/02/15 -- WMM Extension Beta released by qhu, mkaroshi |
| * 2007/03/18 -- add file close statements |
| * 2007/03/21 -- rename the file to avoid the confusion. |
| * 2007/03/30 -- 01.40 WPA2 and Official WMM Beta Release by qhu |
| * 2007/04/20 -- 02.00 WPA2 and Official WMM Release by qhu |
| * 2007/08/15 -- 02.10 WMM-Power Save release by qhu |
| * 2007/10/10 -- 02.20 Voice SOHO beta -- qhu |
| * 2007/11/07 -- 02.30 Voice HSO -- qhu |
| * |
| */ |
| #ifndef WIN32 |
| #include <unistd.h> |
| #include <sys/socket.h> |
| #include <sys/wait.h> |
| #include <arpa/inet.h> |
| #include <linux/types.h> |
| #include <linux/socket.h> |
| #include <poll.h> |
| #include <bcmendian.h> |
| #else |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <windows.h> |
| #include <iphlpapi.h> |
| #endif |
| |
| #include "wfa_debug.h" |
| #include "wfa_ver.h" |
| #include "wfa_main.h" |
| #include "wfa_types.h" |
| #include "wfa_ca.h" |
| #include "wfa_tlv.h" |
| #include "wfa_sock.h" |
| #include "wfa_tg.h" |
| #include "wfa_cmds.h" |
| #include "wfa_rsp.h" |
| #include "wfa_miscs.h" |
| #ifdef WFA_WMM_EXT |
| #ifdef WFA_WMM_PS_EXT |
| #include "wfa_wmmps.h" |
| #endif |
| #endif |
| |
| #define CERTIFICATES_PATH "/etc/wpa_supplicant" |
| #define TSPEC_VER 2 |
| #define TSPEC_BUF_SIZE 15 |
| #define MAX_TOKENS 15 |
| #define BYTE_0 0 |
| #define BYTE_1 1 |
| #define BYTE_2 2 |
| #define TID_INDEX 4 |
| #define NO_TSINFO 1 |
| #define TID_MISMATCH 2 |
| |
| /* Some device may only support UDP ECHO, activate this line */ |
| //#define WFA_PING_UDP_ECHO_ONLY 1 |
| |
| |
| int g_serv_sock_desc; |
| |
| /* Start --> Modified as per BRCM 1.3 ASD */ |
| |
| /* error code */ |
| #define BCM_OK 0 |
| #define BCM_BAD 1 |
| |
| #define BCM_SSID_LEN_MAX 32 |
| #define BCM_SSID_MAX 32 |
| |
| /* defines for BSS types */ |
| #define BCM_BSS_INVALID 0 |
| #define BCM_BSS_INDEPENDENT 1 |
| #define BCM_BSS_INFRA 3 |
| #define BCM_BSS_AUTO 4 |
| |
| /* defines for WPA AITHENTICATION */ |
| #define BCM_WPA_AUTH_DISABLED 0x0 |
| #define BCM_WPA_AUTH_NONE 0x1 |
| #define BCM_WPA_AUTH_8021X 0x2 |
| #define BCM_WPA_AUTH_PSK 0x4 |
| #define BCM_WPA2_AUTH_8021X 0x40 |
| #define BCM_WPA2_AUTH_PSK 0x80 |
| |
| #define BCM_WEP_KEY_SIZE_MAX 32 |
| #define BCM_8021X_ASSOC_TIMEOUT 3600 |
| #define BCM_PRI_KEY_BAD (-1) |
| |
| typedef union bcmEapObj { |
| caStaSetEapTLS_t setEapTLS; |
| caStaSetEapTTLS_t setEapTTLS; |
| caStaSetEapSIM_t setEapSIM; |
| caStaSetEapPEAP_t setEapPEAP; |
| caStaSetEapFAST_t setEapFAST; |
| caStaSetEapAKA_t setEapAKA; |
| } bcmEapObj_t; |
| |
| typedef struct bcmSsidObj |
| { |
| char ssidStr[BCM_SSID_LEN_MAX + 1]; |
| int bssType; |
| int channel; |
| int wsec; |
| int auth; /* 802.11 authentication : default 0 for open. */ |
| int wpa_auth; /* WPA authentication: default 1 for WPA-NONE */ |
| int uapsd; |
| char keys[4][BCM_WEP_KEY_SIZE_MAX]; /* wl addwep */ |
| int primary_key; |
| BYTE passphrase[64]; /* wl set_pmk */ |
| int powerSave; |
| /* UAPSD */ |
| int maxSPLength; |
| int acBE; |
| int acBK; |
| int acVI; |
| int acVO; |
| /* EAP Types*/ |
| bcmEapObj_t eapObj; |
| int eapType; |
| } bcmSsidObj_t; |
| |
| typedef struct bcmSsidObjTbl |
| { |
| bcmSsidObj_t ssidObj[BCM_SSID_MAX]; |
| uint addCnt; |
| uint delCnt; |
| uint entries; |
| } bcmSsidObjTbl_t; |
| |
| bcmSsidObjTbl_t bsotbl; |
| int bcmSsidIsGood(char *ssidStr); |
| bcmSsidObj_t *bcmWfaSsidTblFreeEntry(); |
| bcmSsidObj_t *bcmWfaSsidTblSsidFind(char *ssidStr); |
| bcmSsidObj_t *bcmWfaSsidObjTblAdd(char *ssidStr); |
| void bcmWfaSsidObjTblDel(char *ssidStr); |
| void bcmWfaSsidObjPrint(bcmSsidObj_t *bso); |
| void bcmWfaSsidObjTblPrint(void); |
| |
| /* End --> Modified as per BRCM 1.3 ASD */ |
| |
| /* Since the two definitions are used all over the CA function */ |
| char gCmdStr[WFA_CMD_STR_SZ]; |
| dutCmdResponse_t gGenericResp; |
| |
| /* |
| * agtCmdProcGetVersion(): response "ca_get_version" command to controller |
| * input: cmd --- not used |
| * valLen -- not used |
| * output: parms -- a buffer to store the version info response. |
| */ |
| |
| int agtCmdProcGetVersion(int len, BYTE *parms, int *respLen, BYTE *respBuf) |
| { |
| dutCmdResponse_t *getverResp = &gGenericResp; |
| |
| DPRINT_INFO(WFA_OUT, "entering agtCmdProcGetVersion ...\n"); |
| |
| getverResp->status = STATUS_COMPLETE; |
| strncpy(getverResp->cmdru.version, WFA_SYSTEM_VER, 8); |
| |
| wfaEncodeTLV(WFA_GET_VERSION_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)getverResp, respBuf); |
| |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| |
| return TRUE; |
| } |
| |
| /* |
| * wfaStaAssociate(): |
| * The function is to force the station wireless I/F to re/associate |
| * with the AP. |
| */ |
| int wfaStaAssociate(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| int retVal = TRUE; |
| dutCommand_t *assoc = (dutCommand_t *)caCmdBuf; |
| dutCmdResponse_t *staAssocResp = &gGenericResp; |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| int imode; /* 0 for ibss, 1 for infrastructure */ |
| char ssidTarget[WFA_SSID_NAME_LEN]; |
| bcmSsidObj_t *bso; |
| int idx; |
| char identity[WFA_BUFF_128],dummy[WFA_BUFF_128]; |
| |
| DPRINT_INFO(WFA_OUT, "entering wfaStaAssociate ...\n"); |
| /* use 'ifconfig' command to bring down the interface (linux specific) */ |
| |
| memcpy(ssidTarget, assoc->cmdsu.ssid, WFA_SSID_NAME_LEN); |
| bso = bcmWfaSsidTblSsidFind(ssidTarget); |
| if (!bso) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidTarget))) { |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed\n", ssidTarget); |
| retVal = FALSE; |
| goto exit; |
| } |
| if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) { |
| bcmWfaSsidObjPrint(bso); |
| } |
| |
| } |
| imode = (bso->bssType == BCM_BSS_INDEPENDENT) ? 0 : 1; |
| sprintf(gCmdStr, "%s disassoc", rwl_client_path); |
| exec_process(gCmdStr); |
| |
| asd_sleep(3); |
| /*Default case will be non-802.1x associations*/ |
| switch (bso->eapType) { |
| case BCM_EAP_TYPE_TLS: |
| strncpy(identity,bso->eapObj.setEapTLS.clientCertificate,sizeof(identity)); |
| /* For EAPTLS, identity is taken as the file name of the Client certificate |
| * since we do not have any username information in this mode |
| */ |
| printf("\n %s\n",identity); |
| strtok_r(identity,".",(char **)&dummy); |
| printf("\n %s\n",identity); |
| S_N_PRINTF(gCmdStr,sizeof(gCmdStr),"%s sh cnClient -A %s -ssid %s -%s -%s -tls " |
| "-usercert %s %s -identity %s -validate %s -timeout %d %s ", rwl_client_path, |
| bso->eapObj.setEapTLS.intf, bso->eapObj.setEapTLS.ssid, |
| bso->eapObj.setEapTLS.keyMgmtType, bso->eapObj.setEapTLS.encrptype, |
| bso->eapObj.setEapTLS.clientCertificate, KEY_FILE, identity, |
| bso->eapObj.setEapTLS.trustedRootCA, BCM_8021X_ASSOC_TIMEOUT, "%"); |
| retVal = exec_process_cnclient(gCmdStr, rwl_client_path, rwl_wifi_flag); |
| break; |
| case BCM_EAP_TYPE_TTLS: |
| S_N_PRINTF(gCmdStr,sizeof(gCmdStr),"%s sh cnClient -A %s -ssid %s -%s -%s -ttls-%s " |
| "-user %s -password %s -identity %s -validate %s -timeout %d %s ", rwl_client_path, |
| bso->eapObj.setEapTTLS.intf, bso->eapObj.setEapTTLS.ssid, |
| bso->eapObj.setEapTTLS.keyMgmtType, bso->eapObj.setEapTTLS.encrptype, TTLS_innerEAP, |
| bso->eapObj.setEapTTLS.username, bso->eapObj.setEapTTLS.passwd, |
| bso->eapObj.setEapTTLS.username, bso->eapObj.setEapTTLS.trustedRootCA, |
| BCM_8021X_ASSOC_TIMEOUT, "%"); |
| retVal = exec_process_cnclient(gCmdStr, rwl_client_path, rwl_wifi_flag); |
| break; |
| case BCM_EAP_TYPE_SIM: |
| S_N_PRINTF(gCmdStr,sizeof(gCmdStr),"%s sh cnClient -A %s -ssid %s -%s -%s -sim %s " |
| "-scpin %s -timeout %d %s ", rwl_client_path, bso->eapObj.setEapSIM.intf, |
| bso->eapObj.setEapSIM.ssid, bso->eapObj.setEapSIM.keyMgmtType, |
| bso->eapObj.setEapSIM.encrptype, bso->eapObj.setEapSIM.username, |
| bso->eapObj.setEapSIM.passwd, BCM_8021X_ASSOC_TIMEOUT, "%"); |
| retVal = exec_process_cnclient(gCmdStr, rwl_client_path, rwl_wifi_flag); |
| break; |
| case BCM_EAP_TYPE_PEAP: |
| S_N_PRINTF(gCmdStr,sizeof(gCmdStr),"%s sh cnClient -A %s -ssid %s -%s -%s -peap-%s " |
| "-user %s -password %s -identity %s -timeout %d %s ", rwl_client_path, |
| bso->eapObj.setEapPEAP.intf, bso->eapObj.setEapPEAP.ssid, |
| bso->eapObj.setEapPEAP.keyMgmtType, bso->eapObj.setEapPEAP.encrptype, |
| bso->eapObj.setEapPEAP.innerEAP, bso->eapObj.setEapPEAP.username, |
| bso->eapObj.setEapPEAP.passwd, bso->eapObj.setEapPEAP.username, |
| BCM_8021X_ASSOC_TIMEOUT, "%"); |
| retVal = exec_process_cnclient(gCmdStr, rwl_client_path, rwl_wifi_flag); |
| break; |
| case BCM_EAP_TYPE_FAST: |
| S_N_PRINTF(gCmdStr,sizeof(gCmdStr),"%s sh cnClient -A %s -ssid %s -%s -%s -fast-%s " |
| "-user %s -password %s -identity %s -validate %s -timeout %d %s ", rwl_client_path, |
| bso->eapObj.setEapFAST.intf, bso->eapObj.setEapFAST.ssid, |
| bso->eapObj.setEapFAST.keyMgmtType, bso->eapObj.setEapFAST.encrptype, |
| bso->eapObj.setEapFAST.innerEAP, bso->eapObj.setEapFAST.username, |
| bso->eapObj.setEapFAST.passwd, bso->eapObj.setEapFAST.username, |
| bso->eapObj.setEapFAST.trustedRootCA, BCM_8021X_ASSOC_TIMEOUT, "%"); |
| retVal = exec_process_cnclient(gCmdStr, rwl_client_path, rwl_wifi_flag); |
| break; |
| case BCM_EAP_TYPE_AKA: |
| S_N_PRINTF(gCmdStr,sizeof(gCmdStr),"%s sh cnClient -A %s -ssid %s -%s -%s -eap-aka " |
| "-user %s -password %s -identity %s -timeout %d %s ", rwl_client_path, |
| bso->eapObj.setEapAKA.intf, bso->eapObj.setEapAKA.ssid, |
| bso->eapObj.setEapAKA.keyMgmtType, bso->eapObj.setEapAKA.encrptype, |
| bso->eapObj.setEapAKA.username, bso->eapObj.setEapAKA.passwd, |
| bso->eapObj.setEapAKA.username,BCM_8021X_ASSOC_TIMEOUT, "%"); |
| retVal = exec_process_cnclient(gCmdStr, rwl_client_path, rwl_wifi_flag); |
| break; |
| default: |
| /* Run the commands in the batching mode in case of wifi transport*/ |
| if(rwl_wifi_flag) { |
| asd_sleep(1); |
| sprintf(gCmdStr, "%s seq_start", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| |
| |
| asd_sleep(1); |
| if ((!imode) && bso->channel){ |
| sprintf(gCmdStr, "%s channel %d", rwl_client_path, bso->channel); |
| exec_process(gCmdStr); |
| } |
| |
| sprintf(gCmdStr, "%s infra %d", rwl_client_path, imode); |
| exec_process(gCmdStr); |
| |
| /*Execute the command wme_apsd_sta only if the driver is down*/ |
| sprintf(gCmdStr, "%s wme_apsd_sta %d %d %d %d %d", rwl_client_path, |
| bso->maxSPLength, bso->acBE, bso->acBK, bso->acVI, bso->acVO); |
| exec_process(gCmdStr); |
| |
| asd_sleep(3); |
| sprintf(gCmdStr, "%s up", rwl_client_path); |
| exec_process(gCmdStr); |
| |
| if(rwl_wifi_flag) { |
| sprintf(gCmdStr, "%s seq_stop", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| |
| asd_sleep(2); |
| /* handle WEP keys */ |
| for(idx = 0; idx < 4; idx++) { |
| if(bso->keys[idx][0] != '\0') { |
| sprintf(gCmdStr, "%s addwep %d %s", rwl_client_path, idx, bso->keys[idx]); |
| } else { |
| sprintf(gCmdStr, "%s rmwep %d", rwl_client_path, idx); |
| } |
| exec_process(gCmdStr); |
| } |
| |
| /* set primary key */ |
| if(bso->primary_key != BCM_PRI_KEY_BAD) { |
| sprintf(gCmdStr, "%s primary_key %d", rwl_client_path, bso->primary_key); |
| exec_process(gCmdStr); |
| } |
| |
| /* security */ |
| sprintf(gCmdStr, "%s wsec %d", rwl_client_path, bso->wsec); |
| exec_process(gCmdStr); |
| |
| if(bso->passphrase[0] != '\0') { |
| sprintf(gCmdStr, "%s set_pmk %s", rwl_client_path, bso->passphrase); |
| exec_process(gCmdStr); |
| } |
| |
| if(bso->wpa_auth == BCM_WPA_AUTH_PSK) { |
| sprintf(gCmdStr, "%s sup_wpa 1", rwl_client_path ); |
| exec_process(gCmdStr); |
| } else if(bso->wpa_auth == BCM_WPA2_AUTH_PSK) { |
| sprintf(gCmdStr, "%s sup_wpa 2", rwl_client_path ); |
| exec_process(gCmdStr); |
| } |
| |
| sprintf(gCmdStr, "%s auth %d", rwl_client_path, bso->auth); |
| exec_process(gCmdStr); |
| |
| sprintf(gCmdStr, "%s wpa_auth %d", rwl_client_path, bso->wpa_auth); |
| exec_process(gCmdStr); |
| |
| sprintf(gCmdStr, "%s ssid %s", rwl_client_path, ssidTarget); |
| exec_process(gCmdStr); |
| } |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| exit: |
| /* End: Modified as per BRCM 1.3 ASD */ |
| |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| if(retVal == TRUE) |
| staAssocResp->status = STATUS_COMPLETE; |
| else |
| staAssocResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_ASSOCIATE_RESP_TLV, 4, (BYTE *)staAssocResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return retVal; /* Modified as per BRCM 1.3 ASD */ |
| } |
| |
| /* |
| * wfaStaReAssociate(): |
| * The function is to force the station wireless I/F to re/associate |
| * with the AP. |
| */ |
| int wfaStaReAssociate(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| dutCommand_t *assoc = (dutCommand_t *)caCmdBuf; |
| dutCmdResponse_t *staAssocResp = &gGenericResp; |
| |
| DPRINT_INFO(WFA_OUT, "entering wfaStaAssociate ...\n"); |
| sprintf(gCmdStr, "%s mpc 0", rwl_client_path); |
| exec_process(gCmdStr); |
| sprintf(gCmdStr, "%s up", rwl_client_path); |
| exec_process(gCmdStr); |
| /* "wl reassoc" command is not able to associate completly and receives an Auto IP */ |
| sprintf(gCmdStr, "%s reassoc %s", rwl_client_path, assoc->cmdsu.bssid); |
| exec_process(gCmdStr); |
| |
| staAssocResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_ASSOCIATE_RESP_TLV, 4, (BYTE *)staAssocResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| |
| /* |
| * wfaStaGetIpConfig(): |
| * This function is to retriev the ip info including |
| * 1. dhcp enable |
| * 2. ip address |
| * 3. mask |
| * 4. primary-dns |
| * 5. secondary-dns |
| * |
| * The current implementation is to use a script to find these information |
| * and store them in a file. |
| */ |
| |
| int wfaStaGetIpConfig(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| int i = 0; |
| #ifdef WIN32 |
| int slen; |
| DWORD dwStatus; |
| IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information for up to 16 NICs |
| PIP_ADAPTER_INFO pAdapterInfo; |
| DWORD dwBufLen = sizeof(AdapterInfo); // Save the memory size of buffer |
| #endif |
| |
| dutCommand_t *getIpConf = (dutCommand_t *)caCmdBuf; |
| dutCmdResponse_t *ipconfigResp = &gGenericResp; |
| char *ifname = getIpConf->intf; |
| caStaGetIpConfigResp_t *ifinfo = &ipconfigResp->cmdru.getIfconfig; |
| #ifndef WIN32 |
| FILE *shell_fpt; |
| DPRINT_INFO(WFA_OUT,"Entering staGetIpConfig...\n"); |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| /* Dhcp */ |
| sprintf(gCmdStr,"ps ax | grep -v grep | grep dhcli | wc -l >%s 2>&1", TMP_FILE_PATH); |
| |
| system(gCmdStr); |
| |
| shell_fpt = fopen(TMP_FILE_PATH, "rb"); |
| fread(gCmdStr, sizeof(char), 20, shell_fpt); |
| fclose(shell_fpt); |
| |
| remove(TMP_FILE_PATH); |
| if (atoi(gCmdStr) >= 1) |
| ifinfo->isDhcp = 1; |
| else |
| ifinfo->isDhcp = 0; |
| /* ipaddr */ |
| sprintf(gCmdStr, "%s %s | grep 'inet addr' | cut -d: -f2 | cut -d' ' -f1>%s 2>&1", |
| IFCONFIG_PATH, ifname, TMP_FILE_PATH); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| |
| system(gCmdStr); |
| |
| shell_fpt = fopen(TMP_FILE_PATH, "rb"); |
| ifinfo->ipaddr[0] = 0; |
| fread(ifinfo->ipaddr, sizeof(char), 20, shell_fpt); |
| ifinfo->ipaddr[strlen(ifinfo->ipaddr) - 1] = 0; /* Purge newline */ |
| if(ifinfo->ipaddr[0] == 0) |
| strncpy(ifinfo->ipaddr, "none", 15); |
| fclose(shell_fpt); |
| |
| remove(TMP_FILE_PATH); |
| /* mask */ |
| sprintf(gCmdStr, "%s %s | grep 'inet addr' | cut -d: -f4 >%s 2>&1", |
| IFCONFIG_PATH, ifname, TMP_FILE_PATH); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| |
| system(gCmdStr); |
| |
| shell_fpt = fopen(TMP_FILE_PATH, "rb"); |
| ifinfo->mask[0] = 0; |
| fread(ifinfo->mask, sizeof(char), 20, shell_fpt); |
| ifinfo->mask[strlen(ifinfo->mask) - 1] = 0; /* Purge newline */ |
| if(ifinfo->mask[0] == 0) |
| strcpy(ifinfo->mask, "none"); |
| fclose(shell_fpt); |
| |
| remove(TMP_FILE_PATH); |
| /* dns */ |
| sprintf(gCmdStr, "cat /etc/resolv.conf | grep nameserver | awk '{print $2}'>%s 2>&1", TMP_FILE_PATH); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| |
| system(gCmdStr); |
| |
| shell_fpt = fopen(TMP_FILE_PATH, "rb"); |
| for (i = 0; i < WFA_MAX_DNS_NUM; i++){ |
| fgets(ifinfo->dns[i], WFA_IP_ADDR_STR_LEN, shell_fpt); |
| if (ifinfo->dns[i][0]) |
| ifinfo->dns[i][strlen(ifinfo->dns[i]) - 1] = 0; /* Purge newline */ |
| else |
| strcpy(ifinfo->dns[i], "NOTDEF"); |
| } |
| |
| fclose(shell_fpt); |
| |
| remove(TMP_FILE_PATH); |
| /* End: Modified as per BRCM 1.3 ASD */ |
| |
| #else |
| /* The eth1 interface name in WinCE is BCMSDDHD1 and |
| * the eth0 interface name is VMINI1. The command that comes in from Linux CA |
| * will send the eth0 or eth1 interface, which is then translated to WinCE |
| * specific interface name to get the Adapters information*/ |
| if(!strcmp(getIpConf->intf, "eth1")) { |
| strcpy(getIpConf->intf , "BCMSDDHD1"); |
| } else if(!strcmp(getIpConf->intf, "eth0")) { |
| strcpy(getIpConf->intf , "VMINI1"); |
| } |
| /* Get the network interface information */ |
| dwStatus = GetAdaptersInfo(// Call GetAdapterInfo |
| AdapterInfo,// [out] buffer to receive data |
| &dwBufLen);// [in] size of receive data buffer |
| |
| pAdapterInfo= AdapterInfo;// Contains pointer to current adapter info |
| |
| while(pAdapterInfo){ |
| if(strcmp(pAdapterInfo->AdapterName, getIpConf->intf)==0){ |
| /*Check if DHCP Enabled*/ |
| if(pAdapterInfo->DhcpEnabled) |
| ifinfo->isDhcp = 1; |
| else |
| ifinfo->isDhcp = 0; |
| |
| /*IP Address */ |
| strcpy(ifinfo->ipaddr, pAdapterInfo->IpAddressList.IpAddress.String); |
| ifinfo->ipaddr[15]='\0'; |
| |
| /*Subnet mask*/ |
| strcpy(ifinfo->mask,pAdapterInfo->IpAddressList.IpMask.String); |
| slen = strlen(ifinfo->mask); |
| ifinfo->mask[slen+1] = '\0'; |
| |
| /*Primary DNS*/ |
| strcpy(ifinfo->dns[0], pAdapterInfo->PrimaryWinsServer.IpAddress.String); |
| slen = strlen(ifinfo->dns[0]); |
| |
| /*Secondary DNS*/ |
| strcpy(ifinfo->dns[1], pAdapterInfo->SecondaryWinsServer.IpAddress.String); |
| slen = strlen(ifinfo->dns[1]); |
| } |
| pAdapterInfo = pAdapterInfo->Next; |
| } |
| #endif |
| /* |
| * Report back the results |
| */ |
| ipconfigResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_GET_IP_CONFIG_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)ipconfigResp, respBuf); |
| |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| DPRINT_INFO(WFA_OUT, "%i %i %s %s %s %s %i\n", ipconfigResp->status, |
| ifinfo->isDhcp, ifinfo->ipaddr, ifinfo->mask, |
| ifinfo->dns[0], ifinfo->dns[1], *respLen); |
| return TRUE; |
| } |
| |
| /* |
| * 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). |
| * |
| * Set the IP address and the mask value only if the the DHCP(ipconfig->isDhcp) |
| * is disabled. Otherwise enable the DHCP for the network interface. |
| */ |
| int wfaStaSetIpConfig(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| dutCommand_t *setIpConf = (dutCommand_t *)caCmdBuf; |
| caStaSetIpConfig_t *ipconfig = &setIpConf->cmdsu.ipconfig; |
| dutCmdResponse_t *staSetIpResp = &gGenericResp; |
| |
| #ifndef WIN32 |
| pid_t pid; |
| int status; |
| DPRINT_INFO(WFA_OUT, "interface = %s, ipaddr = %s, dhcp = %d\r\n",ipconfig->intf,ipconfig->ipaddr,ipconfig->isDhcp); |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| if(!ipconfig->isDhcp) |
| { |
| if (!strlen(ipconfig->intf) || !strlen(ipconfig->ipaddr) || !strlen(ipconfig->mask)) |
| { |
| staSetIpResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SET_IP_CONFIG_RESP_TLV, 4, (BYTE *)staSetIpResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; /* changed to be FALSE? */ |
| } |
| sprintf(gCmdStr, "killall -9 dhclient"); |
| exec_process(gCmdStr); |
| sprintf(gCmdStr, "%s %s %s ", IFCONFIG_PATH, ipconfig->intf, ipconfig->ipaddr); |
| if (strlen(ipconfig->mask)) |
| sprintf(&gCmdStr[strlen(gCmdStr)], "netmask %s ", ipconfig->mask); |
| exec_process(gCmdStr); |
| DPRINT_INFO(WFA_OUT, "%s\n", "doing ifconfig"); |
| /* End: Modified as per BRCM 1.3 ASD */ |
| |
| /* use command 'route add' to set set gatewway (linux specific) */ |
| if(ipconfig->defGateway[0] != '\0') |
| { |
| sprintf(gCmdStr, "%s add default gw %s > /dev/null 2>&1", ROUTE_PATH, ipconfig->defGateway); |
| exec_process(gCmdStr); |
| DPRINT_INFO(WFA_OUT, "%s\n", "doing route add"); |
| } |
| |
| /* set dns (linux specific) */ |
| |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| /* if somedata is given as primary-dns then we'll display it |
| else we'll show it as NOTDEF */ |
| if(strcmp(ipconfig->pri_dns, "\0")) |
| { |
| /* set dns (linux specific) */ |
| sprintf(gCmdStr, "cp /etc/resolv.conf /tmp/resolv.conf.bk"); |
| exec_process(gCmdStr); |
| sprintf(gCmdStr, "echo nameserver %s > /etc/resolv.conf", ipconfig->pri_dns); |
| exec_process(gCmdStr); |
| /* if no secondary-dns is given along with primary-dns |
| then we'll have to show it as NOTDEF */ |
| if(strcmp(ipconfig->sec_dns, "\0")) |
| sprintf(gCmdStr, "echo nameserver %s >> /etc/resolv.conf", ipconfig->sec_dns); |
| else |
| sprintf(gCmdStr, "echo nameserver %s >> /etc/resolv.conf", "NOTDEF"); |
| exec_process(gCmdStr); |
| } |
| /* In case,no primary or secondary dns is given,it will print them as |
| NOTDEF */ |
| else |
| { |
| |
| sprintf(gCmdStr, "cp /etc/resolv.conf /tmp/resolv.conf.bk"); |
| exec_process(gCmdStr); |
| sprintf(gCmdStr, "echo nameserver %s > /etc/resolv.conf", "NOTDEF"); |
| exec_process(gCmdStr); |
| sprintf(gCmdStr, "echo nameserver %s >> /etc/resolv.conf", "NOTDEF"); |
| exec_process(gCmdStr); |
| } |
| } |
| else |
| { |
| /* dhcp is enabled */ |
| sprintf(gCmdStr, "killall -9 dhclient"); |
| exec_process(gCmdStr); |
| /* Wait for couple of seconds for dhclient to exit cleanly */ |
| asd_sleep(2); |
| if((pid = fork()) == 0) |
| { |
| close(gagtSockfd); |
| close(g_serv_sock_desc); |
| sprintf(gCmdStr, "%s %s",DHCLIENT_PATH, ipconfig->intf); |
| /* execl("/sbin/dhclient",gCmdStr,NULL);*/ |
| exec_process(gCmdStr); |
| _exit(0); |
| } |
| wait(&status); |
| } |
| /* End: Modified as per BRCM 1.3 ASD */ |
| #endif |
| |
| /* |
| * report status |
| */ |
| staSetIpResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_IP_CONFIG_RESP_TLV, 4, (BYTE *)staSetIpResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| |
| /* |
| * 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; |
| dutCmdResponse_t *verifyIpResp = &gGenericResp; |
| |
| |
| #ifdef WIN32 |
| char tempip[30]; |
| #else |
| char *tempip; |
| FILE *shell_fpt; |
| #endif |
| |
| #ifndef WFA_PING_UDP_ECHO_ONLY |
| |
| DPRINT_INFO(WFA_OUT, "Entering wfaStaVerifyIpConnection ...\n"); |
| #ifndef WIN32 |
| tempip = (char*)malloc(30); |
| #endif |
| /* set timeout value in case not set */ |
| if(verip->cmdsu.verifyIp.timeout <= 0) |
| { |
| verip->cmdsu.verifyIp.timeout = 10; |
| } |
| |
| if (strlen(verip->cmdsu.verifyIp.dipaddr) == 0 ) |
| { |
| verifyIpResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_VERIFY_IP_CONNECTION_RESP_TLV, 4, (BYTE *)&verifyIpResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| DPRINT_ERR(WFA_ERR, "Could not execute %s\n", gCmdStr); |
| return FALSE; |
| } |
| |
| strcpy(tempip,verip->cmdsu.verifyIp.dipaddr); |
| |
| strtok(tempip,". "); |
| strtok(tempip,". "); |
| strtok(tempip,". "); |
| strtok(tempip,". "); |
| |
| if( atoi(tempip) >= 255 ) |
| { |
| verifyIpResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_VERIFY_IP_CONNECTION_RESP_TLV, 4, (BYTE *)&verifyIpResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; |
| } |
| |
| #ifndef WIN32 |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| /* execute the ping command and pipe the result to a tmp file */ |
| memset(gCmdStr, 0, sizeof(gCmdStr)); |
| sprintf(gCmdStr, "%s -c 3 -q %s >>%s", PING_PATH, verip->cmdsu.verifyIp.dipaddr, PINGOUT_FILE_PATH); |
| exec_process(gCmdStr); |
| |
| asd_sleep(1); |
| verifyIpResp->status = STATUS_COMPLETE; |
| sprintf(gCmdStr, "cat %s | grep transmitted | awk '{print $4}'>%s 2>&1", |
| PINGOUT_FILE_PATH, TMP_FILE_PATH); |
| |
| if (system(gCmdStr) < 0) { |
| DPRINT_ERR(WFA_ERR, "\n Not able to execute verify ip cmd\n"); |
| verifyIpResp->cmdru.connected = 0; |
| } |
| |
| |
| shell_fpt = fopen(TMP_FILE_PATH, "rb"); |
| |
| if (shell_fpt == NULL) { |
| DPRINT_ERR(WFA_ERR, "\nShell Cmd:File open error\n"); |
| verifyIpResp->cmdru.connected = 0; |
| } |
| |
| fread(gCmdStr, sizeof(char), 20, shell_fpt); |
| fclose(shell_fpt); |
| |
| remove(TMP_FILE_PATH); |
| remove(PINGOUT_FILE_PATH); |
| if(atoi(gCmdStr) == 0) |
| verifyIpResp->cmdru.connected = 0; |
| else |
| verifyIpResp->cmdru.connected = 1; |
| |
| printf("\ngCmdStr is:%s\n", gCmdStr); |
| #ifdef DEBUG |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| #endif |
| /* End: Modified as per BRCM 1.3 ASD */ |
| #else |
| #endif |
| |
| #else |
| int btSockfd; |
| struct pollfd fds[2]; |
| int timeout = 2000; |
| char anyBuf[64]; |
| struct sockaddr_in toAddr; |
| int done = 1, cnt = 0, ret, nbytes; |
| |
| verifyIpResp->status = STATUS_COMPLETE; |
| verifyIpResp->cmdru.connected = 0; |
| |
| btSockfd = wfaCreateUDPSock("127.0.0.1", WFA_UDP_ECHO_PORT); |
| |
| if(btSockfd == -1) |
| { |
| verifyIpResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_VERIFY_IP_CONNECTION_RESP_TLV, 4, (BYTE *)verifyIpResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return FALSE; |
| } |
| |
| toAddr.sin_family = AF_INET; |
| toAddr.sin_addr.s_addr = inet_addr(verip->cmdsu.verifyIp.dipaddr); |
| toAddr.sin_port = htons(WFA_UDP_ECHO_PORT); |
| |
| while(done) |
| { |
| wfaTrafficSendTo(btSockfd, (char *)anyBuf, 64, (struct sockaddr *)&toAddr); |
| cnt++; |
| |
| fds[0].fd = btSockfd; |
| fds[0].events = POLLIN | POLLOUT; |
| |
| ret = poll(fds, 1, timeout); |
| switch(ret) |
| { |
| case 0: |
| /* it is time out, count a packet lost*/ |
| break; |
| case -1: |
| /* it is an error */ |
| default: |
| { |
| switch(fds[0].revents) |
| { |
| case POLLIN: |
| case POLLPRI: |
| case POLLOUT: |
| nbytes = wfaTrafficRecv(btSockfd, (char *)anyBuf, (struct sockaddr *)&toAddr); |
| if(nbytes != 0) |
| verifyIpResp->cmdru.connected = 1; |
| done = 0; |
| break; |
| default: |
| /* errors but not care */ |
| ; |
| } |
| } |
| } |
| if(cnt == 3) |
| { |
| done = 0; |
| } |
| } |
| #endif |
| |
| wfaEncodeTLV(WFA_STA_VERIFY_IP_CONNECTION_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)verifyIpResp, respBuf); |
| |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| |
| return TRUE; |
| } |
| |
| /* |
| * 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 |
| */ |
| |
| int wfaSetEncryption(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetEncryption_t *setEncryp = (caStaSetEncryption_t *)caCmdBuf; |
| dutCmdResponse_t *setEncrypResp = &gGenericResp; |
| int idx; /* Modified as per BRCM 1.3 ASD */ |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| int retVal = TRUE; |
| 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 { |
| memset(bso->keys[idx],0,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: |
| /* End: Modified as per BRCM 1.3 ASD */ |
| |
| setEncrypResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_ENCRYPTION_RESP_TLV, 4, (BYTE *)setEncrypResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return retVal; /* Modified as per BRCM 1.3 ASD */ |
| } |
| |
| |
| int wfaSetEncryption1(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetEncryption_t *setEncryp = (caStaSetEncryption_t *)caCmdBuf; |
| dutCmdResponse_t *setEncrypResp = &gGenericResp; |
| int idx; |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| int retVal = TRUE; |
| bcmSsidObj_t *bso; |
| char * ssidStr; |
| |
| DPRINT_INFO(WFA_OUT, "wfaSetEncryption1()\n"); |
| |
| /* Save the settings for when we need them */ |
| |
| ssidStr = setEncryp->ssid; |
| /* SetSSID */ |
| 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 { |
| memset(bso->keys[idx], 0, 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: |
| /* End: Modified as per BRCM 1.3 ASD */ |
| |
| setEncrypResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_ENCRYPTION_RESP_TLV, 4, (BYTE *)setEncrypResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return retVal; /* Modified as per BRCM 1.3 ASD */ |
| } |
| |
| |
| /* |
| * wfaStaSetEapTLS(): |
| * This is to set |
| * 1. ssid |
| * 2. encrypType - tkip or aes-ccmp |
| * 3. keyManagementType - wpa or wpa2 |
| * 4. trustedRootCA |
| * 5. clientCertificate |
| */ |
| int wfaStaSetEapTLS(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetEapTLS_t *setTLS = (caStaSetEapTLS_t *)caCmdBuf; |
| dutCmdResponse_t *setEapTlsResp = &gGenericResp; |
| bcmSsidObj_t *bso; |
| char ssidTarget[WFA_SSID_NAME_LEN]; |
| |
| DPRINT_INFO(WFA_OUT, "Entering wfaStaSetEapTLS ...\n"); |
| |
| memcpy(ssidTarget, setTLS->ssid, WFA_SSID_NAME_LEN); |
| bso = bcmWfaSsidTblSsidFind(ssidTarget); |
| if (!bso) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidTarget))) { |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed\n", ssidTarget); |
| return FALSE; |
| } |
| if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) { |
| bcmWfaSsidObjPrint(bso); |
| } |
| |
| } |
| memcpy(&(bso->eapObj.setEapTLS), setTLS, sizeof(caStaSetEapTLS_t)); |
| bso->eapType = BCM_EAP_TYPE_TLS; |
| |
| if(strstr(bso->eapObj.setEapTLS.encrptype,"aes-ccmp")) |
| strncpy(bso->eapObj.setEapTLS.encrptype, AES_ENCPTYPE, AES_LEN) ; |
| setEapTlsResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_EAPTLS_RESP_TLV, 4, (BYTE *)setEapTlsResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; |
| } |
| |
| /* |
| * 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) |
| { |
| caStaSetPSK_t *setPSK = (caStaSetPSK_t *)caCmdBuf; |
| dutCmdResponse_t *setPskResp = &gGenericResp; |
| |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| int retVal = TRUE; |
| 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); |
| |
| |
| strncpy((char *)bso->passphrase, (char *)setPSK->passphrase, 64); |
| bso->auth = 0; |
| |
| if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) { |
| bcmWfaSsidObjPrint(bso); |
| } |
| |
| retVal = TRUE; |
| |
| exit: |
| /* End: Modified as per BRCM 1.3 ASD */ |
| |
| setPskResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_PSK_RESP_TLV, 4, (BYTE *)setPskResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return retVal; /* Modified as per BRCM 1.3 ASD */ |
| } |
| |
| |
| /* |
| * wfaStaGetInfo(): |
| * Get vendor specific information in name/value pair by a wireless I/F. |
| */ |
| int wfaStaGetInfo(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| dutCmdResponse_t infoResp; |
| dutCommand_t *getInfo = (dutCommand_t *)caCmdBuf; |
| FILE *tmpfd; |
| DPRINT_INFO(WFA_OUT, "Entering wfaStaGetInfo.....\n"); |
| /* |
| * Normally this is called to retrieve the vendor information |
| * from a interface, no implement yet |
| */ |
| #ifndef WIN32 |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s nmode &> %s", rwl_client_path, TEMP_FILE_PATH); |
| #else |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s nmode > %s 2>&1", rwl_client_path, TEMP_FILE_PATH); |
| #endif |
| exec_process(gCmdStr); |
| if((tmpfd = fopen(TEMP_FILE_PATH, "r")) == NULL){ |
| infoResp.status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_GET_INFO_RESP_TLV, 4, (BYTE *)&infoResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; |
| } |
| fgets(gCmdStr, sizeof(gCmdStr), tmpfd); |
| Cleanup_File(tmpfd); |
| /* |
| * If it is n mode supported card then it wont reply Unsupported or error |
| */ |
| if (((strstr(gCmdStr, "Unsupported")) != NULL) || |
| ((strstr(gCmdStr, "error")) != NULL)) { |
| S_N_PRINTF(infoResp.cmdru.info, sizeof(infoResp.cmdru.info), "interface,%s,vendor,Broadcom,cardtype,802.11a/b/g", getInfo->intf); |
| } |
| else { |
| S_N_PRINTF(infoResp.cmdru.info, sizeof(infoResp.cmdru.info), "interface,%s,vendor,Broadcom,cardtype,802.11a/b/g/n", getInfo->intf); |
| } |
| infoResp.status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_GET_INFO_RESP_TLV, sizeof(infoResp), (BYTE *)&infoResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + sizeof(infoResp); |
| return TRUE; |
| } |
| |
| int wfaStaGetTestData(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| // dutCmdResponse_t dataResp; |
| // dutCommand_t *testData = (dutCommand_t *)caCmdBuf; |
| |
| /* |
| * This is to trasfer the test log (file) back to console |
| * It has not decided to use in-band or out of band. Will be updated |
| * in a new release soon. |
| */ |
| |
| return TRUE; |
| } |
| |
| /* |
| * 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) |
| { |
| |
| caStaSetEapTTLS_t *setTTLS = (caStaSetEapTTLS_t *)caCmdBuf; |
| dutCmdResponse_t *setEapTtlsResp = &gGenericResp; |
| bcmSsidObj_t *bso; |
| char ssidTarget[WFA_SSID_NAME_LEN]; |
| |
| memcpy(ssidTarget, setTTLS->ssid, WFA_SSID_NAME_LEN); |
| bso = bcmWfaSsidTblSsidFind(ssidTarget); |
| if (!bso) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidTarget))) { |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed\n", ssidTarget); |
| return FALSE; |
| |
| } |
| if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) { |
| bcmWfaSsidObjPrint(bso); |
| } |
| |
| } |
| |
| memcpy(&(bso->eapObj.setEapTTLS), setTTLS, sizeof(caStaSetEapTTLS_t)); |
| bso->eapType = BCM_EAP_TYPE_TTLS; |
| |
| if(strstr(bso->eapObj.setEapTTLS.encrptype,"aes-ccmp")) |
| strncpy(bso->eapObj.setEapTTLS.encrptype, AES_ENCPTYPE, AES_LEN) ; |
| setEapTtlsResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_EAPTTLS_RESP_TLV, 4, (BYTE *)setEapTtlsResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| |
| /* |
| * wfaStaSetEapSIM(): |
| * This is to set |
| * 1. ssid |
| * 2. user name |
| * 3. passwd |
| * 4. encrypType - tkip or aes-ccmp |
| * 5. keyMangementType - wpa or wpa2 |
| */ |
| int wfaStaSetEapSIM(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetEapSIM_t *setSIM = (caStaSetEapSIM_t *)caCmdBuf; |
| dutCmdResponse_t *setEapSimResp = &gGenericResp; |
| bcmSsidObj_t *bso; |
| char ssidTarget[WFA_SSID_NAME_LEN]; |
| |
| memcpy(ssidTarget, setSIM->ssid, WFA_SSID_NAME_LEN); |
| bso = bcmWfaSsidTblSsidFind(ssidTarget); |
| if (!bso) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidTarget))) { |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed\n", ssidTarget); |
| return FALSE; |
| } |
| if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) { |
| bcmWfaSsidObjPrint(bso); |
| } |
| |
| } |
| |
| memcpy(&(bso->eapObj.setEapSIM), setSIM, sizeof(caStaSetEapSIM_t)); |
| bso->eapType = BCM_EAP_TYPE_SIM; |
| |
| if(strstr(bso->eapObj.setEapSIM.encrptype,"aes-ccmp")) |
| strncpy(bso->eapObj.setEapSIM.encrptype, AES_ENCPTYPE, AES_LEN) ; |
| setEapSimResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_EAPSIM_RESP_TLV, 4, (BYTE *)setEapSimResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| |
| /* |
| * wfaStaSetPEAP() |
| * This is to set |
| * 1. ssid |
| * 2. user name |
| * 3. passwd |
| * 4. encryType - tkip or aes-ccmp |
| * 5. keyMgmtType - wpa or wpa2 |
| * 6. trustedRootCA |
| * 7. innerEAP |
| * 8. peapVersion |
| */ |
| int wfaStaSetPEAP(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetEapPEAP_t *setPEAP = (caStaSetEapPEAP_t *)caCmdBuf; |
| dutCmdResponse_t *setPeapResp = &gGenericResp; |
| bcmSsidObj_t *bso; |
| char ssidTarget[WFA_SSID_NAME_LEN]; |
| |
| memcpy(ssidTarget, setPEAP->ssid, WFA_SSID_NAME_LEN); |
| bso = bcmWfaSsidTblSsidFind(ssidTarget); |
| if (!bso) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidTarget))) { |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed\n", ssidTarget); |
| return FALSE; |
| } |
| if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) { |
| bcmWfaSsidObjPrint(bso); |
| } |
| |
| } |
| |
| memcpy(&(bso->eapObj.setEapPEAP), setPEAP, sizeof(caStaSetEapPEAP_t)); |
| bso->eapType = BCM_EAP_TYPE_PEAP; |
| |
| if(strstr(bso->eapObj.setEapPEAP.encrptype,"aes-ccmp")) |
| strncpy(bso->eapObj.setEapPEAP.encrptype, AES_ENCPTYPE, AES_LEN) ; |
| setPeapResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_PEAP_RESP_TLV, 4, (BYTE *)setPeapResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| |
| /* |
| * 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 retVal = TRUE; |
| caStaSetUAPSD_t *setUAPSD = (caStaSetUAPSD_t *)caCmdBuf; |
| /* char *ifname = setUAPSD->intf; */ /* Removed as per BRCM 1.3 ASD */ |
| dutCmdResponse_t *setUAPSDResp = &gGenericResp; |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| bcmSsidObj_t *bso; |
| char *ssidStr; |
| |
| DPRINT_INFO(WFA_OUT, "Entering StaSetUAPSD ...\n"); |
| DPRINT_INFO(WFA_OUT, "maxSPLength %d acBE %d acBK %d acVI %d acVO %d\n", |
| setUAPSD->maxSPLength, setUAPSD->acBE, setUAPSD->acBK, setUAPSD->acVI, setUAPSD->acVO); |
| |
| ssidStr = setUAPSD->ssid; |
| |
| if (!(bso = bcmWfaSsidTblSsidFind(ssidStr))) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidStr))) { |
| DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed.\n", ssidStr); |
| retVal = FALSE; |
| goto exit; |
| } |
| } |
| |
| if (rwl_wifi_flag) { |
| /* Use the batching mode */ |
| asd_sleep(1); |
| sprintf (gCmdStr,"%s seq_start",rwl_client_path); |
| exec_process (gCmdStr); |
| } |
| |
| /* Get the driver down */ |
| sprintf (gCmdStr,"%s down",rwl_client_path); |
| exec_process (gCmdStr); |
| bso->maxSPLength = setUAPSD->maxSPLength; |
| bso->acBE = setUAPSD->acBE; |
| bso->acBK = setUAPSD->acBK; |
| bso->acVI = setUAPSD->acVI; |
| bso->acVO = setUAPSD->acVO; |
| |
| sprintf(gCmdStr,"%s wme_apsd_sta %d %d %d %d %d",rwl_client_path, |
| bso->maxSPLength,bso->acBE,bso->acBK,bso->acVI,bso->acVO); |
| exec_process(gCmdStr); |
| /* Get the driver up*/ |
| sprintf (gCmdStr,"%s up",rwl_client_path); |
| exec_process (gCmdStr); |
| |
| sleep (1); |
| /* Setting up ssid */ |
| sprintf (gCmdStr,"%s join %s",rwl_client_path,setUAPSD->ssid); |
| exec_process(gCmdStr); |
| |
| if (rwl_wifi_flag) { |
| /* End the batching sequence */ |
| asd_sleep(1); |
| sprintf (gCmdStr,"%s seq_stop",rwl_client_path); |
| exec_process (gCmdStr); |
| } |
| |
| exit: |
| /* End: Modified as per BRCM 1.3 ASD */ |
| setUAPSDResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_UAPSD_RESP_TLV, 4, (BYTE *)setUAPSDResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return retVal; /* Modified as per BRCM 1.3 ASD */ |
| } |
| |
| |
| /* |
| * This funciton is to retrieve a list of interfaces and return |
| * the list back to Agent control. |
| * |
| */ |
| int wfaDeviceListIF(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| dutCmdResponse_t *infoResp = &gGenericResp; |
| dutCommand_t *ifList = (dutCommand_t *)caCmdBuf; |
| caDeviceListIFResp_t *ifListResp = &infoResp->cmdru.ifList; |
| #ifndef WIN32 |
| char adapter [10]; |
| #endif |
| DPRINT_INFO(WFA_OUT, "Entering wfaDeviceListIF ...\n"); |
| |
| switch(ifList->cmdsu.iftype) |
| { |
| case IF_80211: |
| infoResp->status = STATUS_COMPLETE; |
| ifListResp->iftype = IF_80211; |
| /*In case of the WinCE the wireless interface is BCMSDDHD1*/ |
| #ifndef WIN32 |
| GetWirelessAdapter(adapter); |
| |
| strcpy(ifListResp->ifs[0], adapter); |
| #else |
| strcpy(ifListResp->ifs[0], "BCMSDDHD1"); |
| #endif |
| strcpy(ifListResp->ifs[1], "NULL"); |
| strcpy(ifListResp->ifs[2], "NULL"); |
| break; |
| |
| case IF_ETH: |
| infoResp->status = STATUS_COMPLETE; |
| ifListResp->iftype = IF_ETH; |
| /*In case of the WinCE the ethernet interface is VMINI1*/ |
| #ifndef WIN32 |
| strcpy(ifListResp->ifs[1], "eth0 "); |
| #else |
| strcpy(ifListResp->ifs[1], "VMINI1"); |
| #endif |
| strcpy(ifListResp->ifs[1], "NULL"); |
| strcpy(ifListResp->ifs[2], "NULL"); |
| break; |
| default: |
| { |
| infoResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_DEVICE_LIST_IF_RESP_TLV, 4, (BYTE *)infoResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| } |
| |
| wfaEncodeTLV(WFA_DEVICE_LIST_IF_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)infoResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| |
| return TRUE; |
| } |
| |
| int wfaStaDebugSet(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| dutCmdResponse_t *debugResp = &gGenericResp; |
| dutCommand_t *debugSet = (dutCommand_t *)caCmdBuf; |
| |
| DPRINT_INFO(WFA_OUT, "Entering wfaStaDebugSet ...\n"); |
| |
| if(debugSet->cmdsu.dbg.state == 1) /* enable */ |
| wfa_defined_debug |= debugSet->cmdsu.dbg.level; |
| else |
| wfa_defined_debug = (~debugSet->cmdsu.dbg.level & wfa_defined_debug); |
| |
| debugResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_GET_INFO_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)debugResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| |
| return TRUE; |
| } |
| |
| |
| |
| /* |
| * wfaStaSetIBSS() |
| * This is to set |
| * 1. ssid |
| * 2. channel |
| * 3. encrypType - none or wep |
| * optional |
| * 4. key1 |
| * 5. key2 |
| * 6. key3 |
| * 7. key4 |
| * 8. activeIndex - 1, 2, 3, or 4 |
| */ |
| int wfaStaSetIBSS(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetIBSS_t *setIBSS = (caStaSetIBSS_t *)caCmdBuf; |
| dutCmdResponse_t *setIbssResp = &gGenericResp; |
| |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| int retVal = TRUE; |
| 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 { |
| memset(bso->keys[idx],0, 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: |
| /* End: Modified as per BRCM 1.3 ASD */ |
| |
| setIbssResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_IBSS_RESP_TLV, 4, (BYTE *)setIbssResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return retVal; /* Modified as per BRCM 1.3 ASD */ |
| } |
| |
| /* |
| * wfaSetMode(): |
| * The function is to set the wireless interface with a given mode (possible |
| * adhoc) |
| * Input parameters: |
| * 1. I/F |
| * 2. ssid |
| * 3. mode adhoc or managed |
| * 4. encType |
| * 5. channel |
| * 6. key(s) |
| * 7. active key |
| */ |
| int wfaStaSetMode(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetMode_t *setmode = (caStaSetMode_t *)caCmdBuf; |
| dutCmdResponse_t *SetModeResp = &gGenericResp; |
| int i; |
| bcmSsidObj_t *bso; |
| char *ssidStr; |
| int retVal = TRUE; |
| |
| DPRINT_INFO(WFA_OUT,"Entering wfaStaSetMode\r\n"); |
| |
| ssidStr = setmode->ssid; |
| if (!(bso = bcmWfaSsidTblSsidFind(ssidStr))) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidStr))) { |
| DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed.\n", ssidStr); |
| retVal = FALSE; |
| goto exit; |
| } |
| else |
| { |
| //DPRINT_INFO(WFA_OUT, "bcmWfaSsidObjTblAdd added: (%s)\n", ssidStr); |
| } |
| } |
| |
| if (setmode->channel) { |
| bso->channel = setmode->channel; |
| /* Set the channel */ |
| sprintf(gCmdStr, "%s channel %d",rwl_client_path, setmode->channel); |
| exec_process(gCmdStr); |
| } |
| |
| /* destroy the interface */ |
| sprintf(gCmdStr, "%s disassoc", rwl_client_path); |
| exec_process(gCmdStr); |
| |
| /* re-create the interface in the given mode */ |
| if(setmode->mode) |
| { |
| bso->bssType = BCM_BSS_INDEPENDENT; |
| sprintf(gCmdStr, "%s infra %d", rwl_client_path, setmode->mode); |
| exec_process(gCmdStr); |
| sprintf(gCmdStr, "%s join %s imode ibss", rwl_client_path, setmode->ssid); |
| exec_process(gCmdStr); |
| } |
| else |
| { |
| sprintf(gCmdStr, "%s infra %d", rwl_client_path, setmode->mode); |
| exec_process(gCmdStr); |
| sprintf(gCmdStr, "%s join %s", rwl_client_path, setmode->ssid); |
| exec_process(gCmdStr); |
| } |
| bso->wsec = (!setmode->encpType) ? 0 : 1; |
| asd_sleep(3); |
| sprintf(gCmdStr, "%s wsec %d", rwl_client_path, bso->wsec); |
| exec_process(gCmdStr); |
| |
| if(setmode->encpType == ENCRYPT_WEP) { |
| for (i = 0; i < 4; i++) { |
| if (setmode->keys[i][0] != '\0') { |
| strcpy(bso->keys[i], setmode->keys[i]); |
| sprintf(gCmdStr, "%s addwep %d %s", rwl_client_path, i, setmode->keys[i]); |
| exec_process(gCmdStr); |
| } |
| else { |
| memset(bso->keys[i],0, BCM_WEP_KEY_SIZE_MAX); |
| } |
| } |
| /* set active key */ |
| if ((setmode->activeKeyIdx > 0) && (setmode->activeKeyIdx < 5)) { |
| /* move the index range from (1 to 4) to (0 to 3) */ |
| bso->primary_key = setmode->activeKeyIdx - 1; |
| sprintf(gCmdStr, "%s primary_key %d", rwl_client_path, bso->primary_key); |
| exec_process(gCmdStr); |
| } |
| } |
| exit: |
| |
| SetModeResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_MODE_RESP_TLV, 4, (BYTE *)SetModeResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| |
| /* Following functions are specific to Win XP CA or Linux CA */ |
| /* |
| * 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 = &gGenericResp; |
| |
| FILE *tmpfd; |
| |
| DPRINT_INFO(WFA_OUT, "Entering wfaStaGetMacAddress ...\n"); |
| |
| /* Start: Modifed as per BRCM 1.3 ASD*/ |
| #ifndef WIN32 |
| /* Modified on 28/12/07 after getting wl dump error in 4325*/ |
| //sprintf(gCmdStr, "ifconfig %s|grep HWaddr|cut -f3 -dr", ifname); |
| sprintf(gCmdStr, "%s cur_etheraddr", rwl_client_path); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| #else |
| strcpy(gCmdStr,rwl_client_path); |
| strcat(gCmdStr," cur_etheraddr >"); |
| #endif |
| if((tmpfd = asd_Config(gCmdStr,TEMP_FILE_PATH)) == NULL){ |
| getmacResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_GET_MAC_ADDRESS_RESP_TLV, 4, (BYTE *)getmacResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| DPRINT_ERR(WFA_ERR, "Failed to get mac address\n"); |
| return FALSE; |
| } |
| fgets(gCmdStr, 15, tmpfd); |
| /*End:Modified on 28/12/07 after getting wl dump error in 4325 */ |
| 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); |
| Cleanup_File(tmpfd); |
| |
| getmacResp->status = STATUS_COMPLETE; |
| |
| wfaEncodeTLV(WFA_STA_GET_MAC_ADDRESS_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)getmacResp, respBuf); |
| |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| return TRUE; |
| } |
| |
| int wfaStaSetPwrSave(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetPwrSave_t *setps = (caStaSetPwrSave_t *)caCmdBuf; |
| dutCmdResponse_t *SetPSResp = &gGenericResp; |
| |
| sprintf(gCmdStr, "%s PM %d", rwl_client_path, setps->mode); |
| exec_process(gCmdStr); |
| |
| SetPSResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_SET_PWRSAVE_RESP_TLV, 4, (BYTE *)SetPSResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| 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) |
| { |
| /* Removed as per BRCM 1.3 ASD */ |
| FILE *tmpfd; |
| dutCmdResponse_t *staConnectResp = &gGenericResp; |
| |
| #ifdef WIN32 |
| unsigned int position; |
| #endif |
| DPRINT_INFO(WFA_OUT, "Entering isConnected ...\n"); |
| |
| /* Start: Added as per BRCM 1.3 ASD */ |
| /* Associated gets long response */ |
| #ifndef WIN32 |
| sprintf(gCmdStr, "%s assoc | wc -l", rwl_client_path); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| #else |
| strcpy(gCmdStr, rwl_client_path); |
| strcat(gCmdStr, " assoc >"); |
| #endif |
| if((tmpfd = asd_Config(gCmdStr,TEMP_FILE_PATH)) == NULL){ |
| staConnectResp->status = STATUS_ERROR; |
| printf("assoc failed\n"); |
| wfaEncodeTLV(WFA_STA_IS_CONNECTED_RESP_TLV, 4, (BYTE *)staConnectResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| DPRINT_ERR(WFA_ERR, "isconnected failed\n"); |
| return FALSE; |
| } |
| |
| #ifndef WIN32 |
| fgets(gCmdStr, sizeof(gCmdStr), tmpfd); |
| /* Short response means not associated */ |
| if (atoi(gCmdStr) <= 2) |
| staConnectResp->cmdru.connected = 0; |
| else |
| staConnectResp->cmdru.connected = 1; |
| /* End: Added as per BRCM 1.3 ASD */ |
| #else |
| if((FileSearch(tmpfd, L"Not associated", &position))!= -1) |
| staConnectResp->cmdru.connected = 0; |
| else |
| staConnectResp->cmdru.connected = 1; |
| #endif |
| /* |
| * Report back the status: Complete or Failed. |
| */ |
| Cleanup_File(tmpfd); |
| staConnectResp->status = STATUS_COMPLETE; |
| |
| wfaEncodeTLV(WFA_STA_IS_CONNECTED_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)staConnectResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| return TRUE; |
| } |
| |
| /* |
| * 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) |
| { |
| dutCmdResponse_t *statsResp = &gGenericResp; |
| FILE *fd; /* Added as per BRCM 1.3 ASD */ |
| caStaGetStatsResp_t *castatsResp = &statsResp->cmdru.ifStats; /* Added as per BRCM 1.3 ASD */ |
| #ifdef WIN32 |
| char cmdStr[256]; |
| unsigned int position; |
| #endif |
| DPRINT_INFO(WFA_OUT, "Entering wfaStaGetStats ...\n"); |
| #ifndef WIN32 |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| sprintf(gCmdStr, "%s counters | grep txframe | awk '{print $2,\"\\n\",$10}'", rwl_client_path); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| /* wl dump replaced with wl counters to get statistics */ |
| if ((fd = popen(gCmdStr, "r")) == NULL){ |
| DPRINT_ERR(WFA_ERR, "Couldn't get txframe stats\n"); |
| goto wfaStaGetStats_error; |
| } else { |
| fgets(gCmdStr, sizeof(gCmdStr), fd); /* line 1: tx frame */ |
| castatsResp->txFrames = atoi(gCmdStr); |
| fgets(gCmdStr, sizeof(gCmdStr), fd); /* line 2: rx frame */ |
| castatsResp->rxFrames = atoi(gCmdStr); |
| pclose(fd); |
| } |
| |
| sprintf(gCmdStr, "%s counters | grep d11_txmulti | awk '{print $4,\"\\n\",$8}' ", rwl_client_path); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| if ((fd = popen(gCmdStr,"r")) == NULL){ |
| DPRINT_ERR(WFA_ERR, "Couldn't get d11_txmulti stats\n"); |
| goto wfaStaGetStats_error; |
| } else { |
| fgets(gCmdStr, sizeof(gCmdStr), fd); |
| castatsResp->txMulticast = atoi(gCmdStr); |
| fgets(gCmdStr, sizeof(gCmdStr), fd); |
| castatsResp->txRetries = atoi(gCmdStr); |
| pclose(fd); |
| } |
| sprintf(gCmdStr, "%s counters | grep d11_rxmulti | awk '{print $4}'", rwl_client_path); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| if ((fd = popen(gCmdStr ,"r")) == NULL){ |
| DPRINT_ERR(WFA_ERR, "Couldn't get rxMultiFrame stats\n"); |
| goto wfaStaGetStats_error; |
| } else { |
| fgets(gCmdStr, sizeof(gCmdStr), fd); |
| castatsResp->rxMulticast = atoi(gCmdStr); |
| pclose(fd); |
| } |
| |
| sprintf(gCmdStr, "%s counters | grep rxbadfcs | awk '{print $8}'", rwl_client_path); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| if ((fd = popen(gCmdStr, "r")) == NULL){ |
| DPRINT_ERR(WFA_ERR, "Couldn't get rxbadfcs stats\n"); |
| goto wfaStaGetStats_error; |
| } else { |
| fgets(gCmdStr, sizeof(gCmdStr), fd); |
| castatsResp->fcsErrors = atoi(gCmdStr); |
| pclose(fd); |
| } |
| #else |
| strcpy(cmdStr,rwl_client_path); |
| strcat(cmdStr," counters >"); |
| /*Open the file to read the statistics*/ |
| if((fd = asd_Config(cmdStr,TEMP_FILE_PATH)) == NULL){ |
| DPRINT_ERR(WFA_ERR, "Couldn't get rxbadfcs stats\n"); |
| goto wfaStaGetStats_error; |
| } |
| else { |
| |
| GetStats(fd, L"txframe ", &position," "); |
| castatsResp->txFrames = position; |
| |
| GetStats(fd, L"rxframe ", &position," "); |
| castatsResp->rxFrames =position; |
| |
| GetStats(fd, L"d11_txmulti ", &position," "); |
| castatsResp->txMulticast =position; |
| |
| GetStats(fd, L"d11_rxmulti ", &position," "); |
| castatsResp->rxMulticast = position; |
| |
| GetStats(fd, L"d11_txretrie ", &position," "); |
| castatsResp->txRetries = position; |
| |
| GetStats(fd, L"rxbadfcs ", &position," "); |
| castatsResp->fcsErrors= position ; |
| } |
| Cleanup_File(fd); |
| #endif |
| /* End: Modified as per BRCM 1.3 ASD */ |
| statsResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_GET_STATS_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)statsResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| return TRUE; |
| |
| wfaStaGetStats_error: |
| statsResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_GET_STATS_RESP_TLV, 4, (BYTE *)statsResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return FALSE; |
| } |
| |
| int wfaDeviceGetInfo(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| dutCmdResponse_t *infoResp = &gGenericResp; |
| /*a vendor can fill in the proper info or anything non-disclosure */ |
| caDeviceGetInfoResp_t dinfo = {"WFA Lab", "DemoUnit", WFA_SYSTEM_VER}; |
| /* Start: Modified as per BRCM 1.3 ASD */ |
| FILE *fd; |
| |
| #ifndef WIN32 |
| /* get the 7th word in the string(1st line ignored( as it contains the value |
| * for dinfo.version */ |
| sprintf(gCmdStr,"%s ver | awk '{print $7}'", rwl_client_path); |
| #ifdef DEBUG |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| #endif |
| #else |
| strcpy(gCmdStr,rwl_client_path); |
| strcat(gCmdStr," ver >"); |
| #endif |
| if((fd = asd_Config(gCmdStr,TEMP_FILE_PATH)) == NULL){ |
| printf("Error executing ver\n"); |
| infoResp->status = STATUS_ERROR; |
| } |
| else { |
| #ifndef WIN32 |
| fgets(gCmdStr, sizeof(gCmdStr), fd); /* Ignore first line */ |
| fgets(gCmdStr, sizeof(gCmdStr), fd); |
| gCmdStr[strlen(gCmdStr) - 1] = 0; /* Get rid of NL */ |
| #else |
| /* The string next to version contains value for dinfo.version */ |
| while ((fscanf(fd, "%s\n", gCmdStr)) != EOF) { |
| if (strncmp(gCmdStr, "version", sizeof("version")) == 0) { |
| fscanf(fd, "%s\n", gCmdStr); |
| break; |
| } |
| } |
| #endif |
| } |
| Cleanup_File(fd); |
| memset(&dinfo, 0, sizeof(dinfo)); |
| infoResp->status = STATUS_COMPLETE; |
| sprintf(dinfo.vendor, "%.16s", "Broadcom"); |
| sprintf(dinfo.version, "%.16s", gCmdStr); |
| sprintf(dinfo.model, "%.16s", "BRCM"); |
| |
| DPRINT_INFO(WFA_OUT, "Entering wfaDeviceGetInfo ...\n"); |
| DPRINT_INFO(WFA_OUT, "status,%i,vendor,%s,model,%s,version %s\n", infoResp->status, |
| dinfo.vendor,dinfo.model, dinfo.version); |
| memcpy(&infoResp->cmdru.devInfo, &dinfo, sizeof(caDeviceGetInfoResp_t)); |
| |
| infoResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_DEVICE_GET_INFO_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)infoResp, respBuf); |
| |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| /* End: Modified as per BRCM 1.3 ASD */ |
| return TRUE; |
| } |
| |
| /* |
| * wfaStaGetBSSID(): |
| * This function is to retrieve BSSID of a specific wireless I/F. |
| */ |
| int wfaStaGetBSSID(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| FILE *tmpfd; |
| dutCmdResponse_t *bssidResp = &gGenericResp; |
| DPRINT_INFO(WFA_OUT, "Entering wfaStaGetBSSID ...\n"); |
| |
| #ifndef WIN32 |
| /* Start: Modified for BRCM 1.3 ASD */ |
| /* Associated gets long response */ |
| sprintf(gCmdStr, "%s assoc | wc -l", rwl_client_path); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| #else |
| memset(gCmdStr, 0, sizeof(gCmdStr)); |
| strcpy(gCmdStr, rwl_client_path); |
| strcat(gCmdStr, " bssid >"); |
| #endif |
| |
| if((tmpfd = asd_Config(gCmdStr,TEMP_FILE_PATH)) == NULL){ |
| printf("BSSID failed\n"); |
| bssidResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_GET_BSSID_RESP_TLV, 4, (BYTE *)bssidResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| } |
| fgets(gCmdStr, sizeof(gCmdStr), tmpfd); |
| Cleanup_File(tmpfd); |
| |
| #ifndef WIN32 |
| /* Short response means not associated */ |
| if (atoi(gCmdStr) <= 2) { |
| strcpy(bssidResp->cmdru.bssid, "00:00:00:00:00:00"); |
| } else { |
| sprintf(gCmdStr, "%s bssid", rwl_client_path); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| if ((tmpfd = popen(gCmdStr, "r")) == NULL){ |
| printf("bssid failed\n"); |
| } |
| fgets(gCmdStr, sizeof(gCmdStr), tmpfd); |
| pclose(tmpfd); |
| gCmdStr[17] = 0; /* Get rid of CR or NL */ |
| strcpy(bssidResp->cmdru.bssid, gCmdStr); |
| } |
| #else |
| gCmdStr[17] = 0; /* Get rid of CR or NL */ |
| if (gCmdStr[2] != ':'){ |
| strcpy(bssidResp->cmdru.bssid, "00:00:00:00:00:00"); |
| } |
| else { |
| strcpy(bssidResp->cmdru.bssid, gCmdStr); |
| } |
| #endif |
| bssidResp->status = STATUS_COMPLETE; |
| /* End Modified as per BRCM 1.3 ASD */ |
| wfaEncodeTLV(WFA_STA_GET_BSSID_RESP_TLV, sizeof(dutCmdResponse_t), (BYTE *)bssidResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + sizeof(dutCmdResponse_t); |
| return TRUE; |
| } |
| |
| /* |
| * exec_addts(): |
| * This function will call ./wl cac_addts |
| */ |
| int |
| exec_addts(caStaSetWMM_t *setwmm) |
| { |
| char pwr_save_str[TSPEC_BUF_SIZE], direction[TSPEC_BUF_SIZE]; |
| int stat; |
| |
| DPRINT_INFO(WFA_OUT, "ADDTS AC PARAMS: \n \ |
| dialog id: %d, \t TID: %d, \t DIRECTION: %d, \n \ |
| PSB: %d, \t UP: %d, \t Fixed %d, \n \ |
| MSDU Size: %d, \t Max MSDU Size %d, \n \ |
| MIN SERVICE INTERVAL: %d, \t MAX SERVICE INTERVAL: %d, \n \ |
| INACTIVITY: %d, \t SUSPENSION %d, \n \ |
| SERVICE START TIME: %d, \t MIN DATARATE: %d, \n \ |
| MEAN DATA RATE: %d, \t PEAK DATA RATE: %d, \n \ |
| BURSTSIZE: %d, \t DELAY BOUND: %d, \t PHYRATE: %d, \n \ |
| SPLUSBW: %f, \t MEDIUM TIME: %d, \t ACCESSCAT: %d\n", \ |
| setwmm->actions.addts.dialog_token, \ |
| setwmm->actions.addts.tspec.tsinfo.TID, \ |
| setwmm->actions.addts.tspec.tsinfo.direction, \ |
| setwmm->actions.addts.tspec.tsinfo.PSB, \ |
| setwmm->actions.addts.tspec.tsinfo.UP, \ |
| setwmm->actions.addts.tspec.Fixed, \ |
| setwmm->actions.addts.tspec.size, \ |
| setwmm->actions.addts.tspec.maxsize, \ |
| setwmm->actions.addts.tspec.min_srvc, \ |
| setwmm->actions.addts.tspec.max_srvc, \ |
| setwmm->actions.addts.tspec.inactivity, \ |
| setwmm->actions.addts.tspec.suspension, \ |
| setwmm->actions.addts.tspec.srvc_strt_tim, \ |
| setwmm->actions.addts.tspec.mindatarate, \ |
| setwmm->actions.addts.tspec.meandatarate, \ |
| setwmm->actions.addts.tspec.peakdatarate, \ |
| setwmm->actions.addts.tspec.burstsize, \ |
| setwmm->actions.addts.tspec.delaybound, \ |
| setwmm->actions.addts.tspec.PHYrate, \ |
| setwmm->actions.addts.tspec.sba, \ |
| setwmm->actions.addts.tspec.medium_time, \ |
| setwmm->actions.addts.accesscat); |
| |
| if (setwmm->actions.addts.tspec.tsinfo.direction == WMMAC_UPLINK) |
| S_N_PRINTF(direction, sizeof(direction), "uplink"); |
| else if (setwmm->actions.addts.tspec.tsinfo.direction == WMMAC_DOWNLINK) |
| S_N_PRINTF(direction, sizeof(direction), "downlink"); |
| else if (setwmm->actions.addts.tspec.tsinfo.direction == WMMAC_BIDIR) |
| S_N_PRINTF(direction, sizeof(direction), "bi-directional"); |
| |
| if (setwmm->actions.addts.tspec.tsinfo.PSB == 1) |
| S_N_PRINTF(pwr_save_str, sizeof(pwr_save_str), "U-APSD"); |
| else if (setwmm->actions.addts.tspec.tsinfo.PSB == 0) |
| S_N_PRINTF(pwr_save_str, sizeof(pwr_save_str), "legacy"); |
| |
| if(setwmm->send_trig) { |
| int Sockfd; |
| struct sockaddr_in psToAddr; |
| unsigned int TxMsg[512]; |
| Sockfd = wfaCreateUDPSock(setwmm->dipaddr, 12346); |
| memset(&psToAddr, 0, sizeof(psToAddr)); |
| psToAddr.sin_family = AF_INET; |
| psToAddr.sin_addr.s_addr = inet_addr(setwmm->dipaddr); |
| psToAddr.sin_port = htons(12346); |
| usleep(becon_int); |
| wfaTGSetPrio(Sockfd, setwmm->trig_ac); |
| printf("\r\nSending dummy Hello to %s\n",setwmm->dipaddr); |
| create_apts_msg(APTS_HELLO, TxMsg,0); |
| wfaTrafficSendTo(Sockfd, (char *)TxMsg, 256, (struct sockaddr *)&psToAddr); |
| asd_closeSocket(Sockfd); |
| } |
| |
| S_N_PRINTF(gCmdStr, sizeof(gCmdStr), "%s cac_addts %d %d %d %s %s %d %d %d" \ |
| " %d %d %d %d %d %d %d %d %d %d %d %d", \ |
| rwl_client_path, \ |
| TSPEC_VER, \ |
| setwmm->actions.addts.dialog_token, \ |
| setwmm->actions.addts.tspec.tsinfo.TID, \ |
| direction, \ |
| pwr_save_str, \ |
| setwmm->actions.addts.tspec.tsinfo.UP, \ |
| setwmm->actions.addts.tspec.size, \ |
| setwmm->actions.addts.tspec.Fixed, \ |
| setwmm->actions.addts.tspec.maxsize, \ |
| setwmm->actions.addts.tspec.min_srvc, \ |
| setwmm->actions.addts.tspec.max_srvc, \ |
| setwmm->actions.addts.tspec.inactivity, \ |
| setwmm->actions.addts.tspec.suspension, \ |
| setwmm->actions.addts.tspec.mindatarate, \ |
| setwmm->actions.addts.tspec.meandatarate, \ |
| setwmm->actions.addts.tspec.peakdatarate, \ |
| setwmm->actions.addts.tspec.burstsize, \ |
| setwmm->actions.addts.tspec.delaybound, \ |
| (int)setwmm->actions.addts.tspec.sba, \ |
| setwmm->actions.addts.tspec.PHYrate); |
| if ((stat = exec_wmmCmd(gCmdStr)) != 0) { |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| /* |
| * exec_delts(): |
| * This function will call ./wl cac_delts |
| */ |
| |
| int |
| exec_delts(caStaSetWMM_t *setwmm) |
| { |
| char *token_buf = NULL; |
| char temp_buf[WFA_BUFF_128], tsinfo_buf[MAX_TOKENS][TSPEC_BUF_SIZE], temp_resp[WFA_BUFF_128]; |
| int token_count, stat, nbyte = 0, tsinfo_flag; |
| FILE *output_fp, *error_fp; |
| |
| DPRINT_INFO(WFA_OUT, "DELTS AC PARAMS: TID: %d\n", setwmm->actions.delts); |
| S_N_PRINTF(gCmdStr, sizeof(gCmdStr), "%s cac_tslist", rwl_client_path); |
| |
| /* Execute the command "wl cac_tslist" */ |
| if ((stat = asd_Config_wmm(gCmdStr, TEMP_STD_OUT_FILE)) != 0) { |
| if ((error_fp = fopen(TEMP_STD_ERR_FILE, "r")) == NULL) { |
| DPRINT_ERR(WFA_ERR, "Error in reading error message. \n"); |
| } |
| memset(temp_resp, 0, sizeof(temp_resp)); |
| fgets(temp_resp, sizeof(temp_resp), error_fp); |
| DPRINT_ERR(WFA_ERR, "Error in executing wl cac_tslist :: %s \n", temp_resp); |
| return FALSE; |
| } |
| |
| tsinfo_flag = NO_TSINFO; |
| if ((output_fp = fopen(TEMP_STD_OUT_FILE, "r")) == NULL) { |
| printf("\nTEMP_STD_OUT_FILE::File open error\n"); |
| return FALSE; |
| } |
| else { |
| while ((feof(output_fp) == 0)) { |
| if (fseek(output_fp, nbyte, SEEK_SET) < 0) { |
| tsinfo_flag = NO_TSINFO; |
| return FALSE; |
| } |
| memset(temp_resp, 0, sizeof(temp_resp)); |
| fgets(temp_resp, sizeof(temp_resp), output_fp); |
| nbyte = nbyte + strlen(temp_resp); |
| |
| /* Get the wl cac_tslist results in temp_resp */ |
| |
| if (strlen(temp_resp) == 0) { |
| DPRINT_ERR(WFA_ERR, "temp_resp length 0. Can't execute wl cac_delts \n"); |
| tsinfo_flag = NO_TSINFO; |
| break; |
| } |
| |
| token_buf = (char *)strtok_r(temp_resp, " ", (char **) temp_buf); |
| token_count = 0; |
| while (token_buf != NULL) { |
| token_buf = (char *)strtok_r(NULL, " ", (char **) temp_buf); |
| if (token_buf != NULL) { |
| S_N_PRINTF(tsinfo_buf[token_count], |
| sizeof(tsinfo_buf[token_count]), "%s", token_buf); |
| token_count++; |
| } |
| } |
| /* if tid of cac_tslist matches with tid of sta_set_wmm then delts is performed */ |
| if (atoi(tsinfo_buf[TID_INDEX]) == setwmm->actions.delts) { |
| S_N_PRINTF(gCmdStr, sizeof(gCmdStr), "%s cac_delts %d %s %s %s", \ |
| rwl_client_path, TSPEC_VER, tsinfo_buf[BYTE_0], \ |
| tsinfo_buf[BYTE_1], tsinfo_buf[BYTE_2]); |
| /* Execute wl cac_delts */ |
| if ((stat = exec_wmmCmd(gCmdStr)) != 0) { |
| return FALSE; |
| } |
| return TRUE; |
| } |
| else { |
| tsinfo_flag = TID_MISMATCH; |
| } |
| } /* End of while */ |
| fclose(output_fp); |
| if (tsinfo_flag == NO_TSINFO) { |
| DPRINT_ERR(WFA_ERR, "Error. Cannot Execute wl cac_delts \n"); |
| return FALSE; |
| } |
| else if (tsinfo_flag == TID_MISMATCH) { |
| DPRINT_ERR(WFA_ERR, "tid did not match. Can't Execute wl cac_delts \n"); |
| return FALSE; |
| } |
| } |
| return TRUE; |
| } |
| |
| |
| /* |
| * wfaStaSetWMM(): |
| * The function is to set the WMM related parameters at the DUT. |
| * Currently the function is used for GROUPS WMM-AC and WMM general configuration for setting |
| * RTS Threshhold, Fragmentation threshold and wmm (ON/OFF) |
| * It is expected that this function will set all the WMM related parametrs for a particular GROUP. |
| */ |
| |
| int wfaStaSetWMM(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetWMM_t *setwmm = (caStaSetWMM_t *)caCmdBuf; |
| char *ifname = setwmm->intf; |
| dutCmdResponse_t *setwmmResp = &gGenericResp; |
| int stat; |
| int Sockfd; |
| struct sockaddr_in psToAddr; |
| unsigned int TxMsg[512]; |
| |
| switch(setwmm->group) |
| { |
| case GROUP_WMMAC: |
| if (setwmm->send_trig) |
| { |
| Sockfd = wfaCreateUDPSock(setwmm->dipaddr, 12346); |
| memset(&psToAddr, 0, sizeof(psToAddr)); |
| psToAddr.sin_family = AF_INET; |
| psToAddr.sin_addr.s_addr = inet_addr(setwmm->dipaddr); |
| psToAddr.sin_port = htons(12346); |
| switch (setwmm->trig_ac) |
| { |
| |
| case WMMAC_AC_VO: |
| wfaTGSetPrio(Sockfd, 7); |
| create_apts_msg(APTS_CK_VO, TxMsg, 0); |
| printf("\r\nSending AC_VO trigger packet\n"); |
| break; |
| |
| case WMMAC_AC_VI: |
| wfaTGSetPrio(Sockfd, 5); |
| create_apts_msg(APTS_CK_VI, TxMsg, 0); |
| printf("\r\nSending AC_VI trigger packet\n"); |
| break; |
| |
| case WMMAC_AC_BK: |
| wfaTGSetPrio(Sockfd, 2); |
| create_apts_msg(APTS_CK_BK, TxMsg, 0); |
| printf("\r\nSending AC_BK trigger packet\n"); |
| break; |
| |
| default: |
| case WMMAC_AC_BE: |
| wfaTGSetPrio(Sockfd, 0); |
| create_apts_msg(APTS_CK_BE, TxMsg, 0); |
| printf("\r\nSending AC_BE trigger packet\n"); |
| break; |
| } |
| sendto(Sockfd, TxMsg, 256, 0, (struct sockaddr *)&psToAddr, |
| sizeof(struct sockaddr)); |
| asd_closeSocket(Sockfd); |
| usleep(1000000); |
| } |
| else if (setwmm->action == WMMAC_ADDTS) { |
| if ((stat = exec_addts(setwmm)) == FALSE) { |
| setwmmResp->status = STATUS_ERROR; |
| break; |
| } |
| } |
| else if (setwmm->action == WMMAC_DELTS) { |
| if ((stat = exec_delts(setwmm)) == FALSE) { |
| setwmmResp->status = STATUS_ERROR; |
| break; |
| } |
| } |
| setwmmResp->status = STATUS_COMPLETE; |
| break; |
| |
| case GROUP_WMMCONF: |
| S_N_PRINTF(gCmdStr, sizeof(gCmdStr), "iwconfig %s rts_thr %d", \ |
| ifname,setwmm->actions.config.rts_thr); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, sizeof(gCmdStr), "iwconfig %s frag_thr %d", \ |
| ifname,setwmm->actions.config.frag_thr); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, sizeof(gCmdStr), "iwpriv %s wmm %d", \ |
| ifname,setwmm->actions.config.wmm); |
| exec_process(gCmdStr); |
| setwmmResp->status = STATUS_COMPLETE; |
| break; |
| |
| default: |
| DPRINT_ERR(WFA_ERR, "The group %d is not supported\n",setwmm->group); |
| setwmmResp->status = STATUS_ERROR; |
| break; |
| } |
| |
| wfaEncodeTLV(WFA_STA_SET_WMM_RESP_TLV, 4, (BYTE *)setwmmResp, respBuf); |
| DPRINT_INFO(WFA_OUT, "tag is %d\n",WFA_STA_SET_WMM_RESP_TLV); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; |
| } |
| |
| /* Start: Added BCM functions as per BRCM 1.3 ASD */ |
| int bcmSsidIsGood(char *ssidStr) |
| { |
| int ssidLen = strlen(ssidStr); |
| |
| if ((ssidLen == 0) || (ssidLen > BCM_SSID_LEN_MAX)) { |
| return (FALSE); |
| } else { |
| return (TRUE); |
| } |
| } |
| |
| bcmSsidObj_t *bcmWfaSsidTblFreeEntry() |
| { |
| bcmSsidObj_t *bso; |
| int idx; |
| |
| DPRINT_INFO(WFA_OUT, "bcmWfaSsidTblFreeEntry\n"); |
| |
| for (idx = 0; idx < BCM_SSID_MAX; idx++) { |
| bso = &bsotbl.ssidObj[idx]; |
| if (bcmSsidIsGood(bso->ssidStr) == FALSE) { |
| return bso; |
| } |
| } |
| |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidTblFreeEntry: no free entry available.\n"); |
| return (NULL); |
| } |
| |
| bcmSsidObj_t *bcmWfaSsidTblSsidFind(char *ssidStr) |
| { |
| bcmSsidObj_t *bso; |
| bcmSsidObj_t *bsoFound= NULL; |
| int idx; |
| |
| if (bcmSsidIsGood(ssidStr) == FALSE) { |
| return (NULL); |
| } |
| |
| for (idx = 0; idx < BCM_SSID_MAX; idx++) { |
| bso = &bsotbl.ssidObj[idx]; |
| if (bcmSsidIsGood(ssidStr) == FALSE) { |
| continue; |
| } |
| |
| if (strcmp(ssidStr, bso->ssidStr)) { |
| continue; |
| } else { |
| bsoFound = bso; |
| break; |
| } |
| } |
| |
| return (bsoFound); |
| } |
| |
| bcmSsidObj_t *bcmWfaSsidObjTblAdd(char *ssidStr) |
| { |
| bcmSsidObj_t *bso; |
| int idx; |
| |
| 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); |
| } |
| |
| memset(bso,0, sizeof(bcmSsidObj_t)); |
| 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 */ |
| bso->eapType = BCM_DEFAULT_SEC_MODE; /* init to non-eap mode */ |
| |
| for (idx = 0; idx < 4; idx++) { |
| S_N_PRINTF (bso->keys[idx], 2, "%s", "\0"); |
| } |
| |
| bsotbl.addCnt++; |
| bsotbl.entries++; |
| |
| return (bso); |
| } |
| |
| 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); |
| memset(bso,0, sizeof(bcmSsidObj_t)); |
| bsotbl.delCnt++; |
| bsotbl.entries--; |
| } |
| |
| void bcmWfaSsidObjPrint(bcmSsidObj_t *bso) |
| { |
| int idx; |
| |
| if (bcmSsidIsGood(bso->ssidStr) == FALSE) { |
| fprintf(WFA_OUT, "bso %p is blank.\n", bso); |
| return; |
| } |
| |
| fprintf(WFA_OUT, "bso %p\n", bso); |
| fprintf(WFA_OUT, "\tssid %s", bso->ssidStr); |
| fprintf(WFA_OUT, "\tbssType %d\n", bso->bssType); |
| fprintf(WFA_OUT, "\tchannel %d\n", bso->channel); |
| fprintf(WFA_OUT, "\twsec %d\n", bso->wsec); |
| fprintf(WFA_OUT, "\tauth %d\n", bso->auth); |
| fprintf(WFA_OUT, "\twpa_auth %d\n", bso->wpa_auth); |
| fprintf(WFA_OUT, "\tpowerSave %d\n", bso->powerSave); |
| fprintf(WFA_OUT, "\tuapsd %d\n", bso->uapsd); |
| |
| for (idx = 0; idx < 4; idx++) { |
| fprintf(WFA_OUT, "\tkeys[%d] : %s\n", idx, bso->keys[idx]); |
| } |
| fprintf(WFA_OUT, "\tprimary_key %d\n", bso->primary_key); |
| fprintf(WFA_OUT, "\tpassphrase : %s\n", bso->passphrase); |
| } |
| |
| void bcmWfaSsidObjTblPrint(void) |
| { |
| int idx; |
| |
| fprintf(WFA_OUT, "entries %d addCnt %d delCnt %d\n", |
| bsotbl.entries, bsotbl.addCnt, bsotbl.delCnt); |
| for (idx = 0; idx < BCM_SSID_MAX; idx++) { |
| bcmWfaSsidObjPrint(&bsotbl.ssidObj[idx]); |
| } |
| } |
| |
| /*Do the initialisation for the driver */ |
| void bcmWfaInit(void) |
| { |
| memset(&bsotbl,0, sizeof(bsotbl)); |
| |
| sprintf(gCmdStr, "%s ap 0", rwl_client_path); /* not AP */ |
| exec_process(gCmdStr); |
| |
| sprintf(gCmdStr, "%s radio on", rwl_client_path); /* not AP */ |
| exec_process(gCmdStr); |
| |
| sprintf(gCmdStr, "%s wsec 0", rwl_client_path); |
| exec_process(gCmdStr); |
| |
| sprintf(gCmdStr, "%s auth 0", rwl_client_path); |
| exec_process(gCmdStr); |
| |
| sprintf(gCmdStr, "%s wpa_auth 0", rwl_client_path); |
| exec_process(gCmdStr); |
| |
| sprintf(gCmdStr, "%s sup_wpa 1", rwl_client_path); /* enable in-driver supplicant */ |
| exec_process(gCmdStr); |
| |
| /* Driver should not be made up explicitly |
| * as we need to execute uapsd command in the beginning. |
| */ |
| } |
| |
| /* |
| * Implementing set systemtime |
| */ |
| |
| int wfaStaSetSystime(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| int retVal = TRUE; |
| dutCmdResponse_t *SetSystime = &gGenericResp; |
| dutCommand_t *systime = (dutCommand_t *)caCmdBuf; |
| #ifndef WIN32 |
| char *month[]= {"NULL","JAN","FEB","MAR","APR","MAY","JUN","JUL","AUG","SEP","OCT","NOV","DEC"}; |
| #else |
| SYSTEMTIME newtime; |
| int err; |
| #endif |
| DPRINT_INFO(WFA_OUT, "Entering set systime ...\n"); |
| #ifndef WIN32 |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "date -s \"%d %s %d %d:%d:%d\"", systime->cmdsu.stime.date, month[systime->cmdsu.stime.month], |
| systime->cmdsu.stime.year, systime->cmdsu.stime.hours, systime->cmdsu.stime.minutes, systime->cmdsu.stime.seconds); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| exec_process(gCmdStr); |
| #else |
| newtime.wDay = systime->cmdsu.stime.date; |
| newtime.wMonth = systime->cmdsu.stime.month; |
| newtime.wYear = systime->cmdsu.stime.year; |
| newtime.wHour = systime->cmdsu.stime.hours; |
| newtime.wMinute = systime->cmdsu.stime.minutes; |
| newtime.wSecond = systime->cmdsu.stime.seconds; |
| if ((err = SetLocalTime(&newtime)) == 0) { |
| DPRINT_ERR(WFA_OUT, "error at set system time % d\n", GetLastError()); |
| retVal = FALSE; |
| } |
| #endif /* WIN32 */ |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| if(retVal == TRUE) |
| SetSystime->status = STATUS_COMPLETE; |
| else |
| SetSystime->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SET_SYSTIME_RESP_TLV, 4, (BYTE *)SetSystime, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; |
| } |
| |
| /* |
| * Part of sigma 11n implementation. |
| * Implementing set 1n functionalities |
| */ |
| int wfaStaSet11n(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| #ifdef WFA_STA_TB |
| int retVal = TRUE; |
| FILE *tmpfd; |
| dutCmdResponse_t *Set11nresp = &gGenericResp; |
| dutCommand_t *Set11n = (dutCommand_t *)caCmdBuf; |
| DPRINT_INFO(WFA_OUT, "Entering set 11n ...\n"); |
| /* Run the commands in the batching mode in case of wifi transport*/ |
| if(rwl_wifi_flag) { |
| asd_sleep(1); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s seq_start", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s down", rwl_client_path); |
| exec_process(gCmdStr); |
| /* |
| * Showing unsupported yet to be implemented |
| * wl mimo_bw_cap need to be implemented by brcm |
| */ |
| if (Set11n->cmdsu.set11n.width == 20) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s mimo_bw_cap 0", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if((Set11n->cmdsu.set11n.width) == 40 || (Set11n->cmdsu.set11n.width == -1)) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s mimo_bw_cap 1", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| if (Set11n->cmdsu.set11n.addba_reject == 2) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s ampdu 0", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if(Set11n->cmdsu.set11n.addba_reject == 1) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s ampdu 1", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| if (Set11n->cmdsu.set11n.ampdu == 2) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s amsdu 0", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s ampdu 1", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if(Set11n->cmdsu.set11n.ampdu == 1) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s ampdu 0", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| if (Set11n->cmdsu.set11n.amsdu == 2) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s amsdu 1", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if(Set11n->cmdsu.set11n.amsdu == 1) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s amsdu 0", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| if (Set11n->cmdsu.set11n.greenfield == 2) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s mimo_preamble 1", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if(Set11n->cmdsu.set11n.greenfield == 1) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s mimo_preamble 0", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| if (Set11n->cmdsu.set11n.stbc_rx == 0) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s stbc_tx 0", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s stbc_rx 0", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if (Set11n->cmdsu.set11n.stbc_rx > 0) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s stbc_tx 1", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s stbc_rx 1", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s nrate -m 5 -w 2", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s up", rwl_client_path); |
| exec_process(gCmdStr); |
| if(rwl_wifi_flag) { |
| asd_sleep(1); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s seq_stop", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| if (Set11n->cmdsu.set11n.intolerant_40 == 2) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s obss_coex 1", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s intol40 1", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if(Set11n->cmdsu.set11n.intolerant_40 == 1) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s obss_coex 0", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s intol40 0", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| |
| if (Set11n->cmdsu.set11n.sgi20 == 2) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s sgi_tx %d", rwl_client_path, -1); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s sgi_rx %d", rwl_client_path, 3); |
| exec_process(gCmdStr); |
| } |
| else if(Set11n->cmdsu.set11n.sgi20 == 1) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s sgi_tx %d", rwl_client_path, 0); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s sgi_rx %d", rwl_client_path, 0); |
| exec_process(gCmdStr); |
| } |
| /* |
| * SMPS related commands can be ignored as of now till |
| * mimo_ps command gets implemented |
| */ |
| if (Set11n->cmdsu.set11n.smps == 1) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s mimo_ps 1", rwl_client_path); /* dynamic */ |
| exec_process(gCmdStr); |
| } |
| else if(Set11n->cmdsu.set11n.smps == 2) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s mimo_ps 0", rwl_client_path); /* static */ |
| exec_process(gCmdStr); |
| } |
| else if(Set11n->cmdsu.set11n.smps == 3) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s mimo_ps 3", rwl_client_path); /* no limit */ |
| exec_process(gCmdStr); |
| } |
| if ((Set11n->cmdsu.set11n.mcs_fixedrate >= 0) && (Set11n->cmdsu.set11n.mcs_fixedrate <= 31)) { |
| |
| #ifndef WIN32 |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s nrate -m %d &> %s", rwl_client_path, Set11n->cmdsu.set11n.mcs_fixedrate, TEMP_FILE_PATH); |
| #else |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s nrate -m %d > %s 2>&1", rwl_client_path, Set11n->cmdsu.set11n.mcs_fixedrate, TEMP_FILE_PATH); |
| #endif |
| exec_process(gCmdStr); |
| if((tmpfd = fopen(TEMP_FILE_PATH, "r")) == NULL){ |
| Set11nresp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SET_11N_RESP_TLV, 4, (BYTE *)Set11nresp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; |
| } |
| fgets(gCmdStr, sizeof(gCmdStr), tmpfd); |
| Cleanup_File(tmpfd); |
| /* |
| * wl rate is issued to check if the 11N supported chip is SISO or MIMO. |
| * If the response is 72Mbps then it is SISO, |
| * Checking if wl returning saying not in range, then invalid |
| */ |
| if ((strstr(gCmdStr, "Range")) != NULL) { |
| DPRINT_INFO(WFA_OUT, "This card Doesnt Support this range\n"); |
| Set11nresp->status = STATUS_INVALID; |
| wfaEncodeTLV(WFA_STA_SET_11N_RESP_TLV, 4, (BYTE *)Set11nresp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; |
| } |
| |
| } |
| |
| |
| |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| if(retVal == TRUE) |
| Set11nresp->status = STATUS_COMPLETE; |
| else |
| Set11nresp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SET_11N_RESP_TLV, 4, (BYTE *)Set11nresp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| #endif /* WFA_STA_TB */ |
| return TRUE; |
| } |
| |
| /* |
| * Part of sigma 11n implementation. |
| * Implementing RIFS test |
| */ |
| |
| int wfaStaSetRifsTest(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| #ifdef WFA_STA_TB |
| int retVal = TRUE; |
| dutCmdResponse_t *RIFStest = &gGenericResp; |
| dutCommand_t *rifstest = (dutCommand_t *)caCmdBuf; |
| if(rifstest->cmdsu.action_rifs == 2) { /* enabled */ |
| if(rwl_wifi_flag) { |
| asd_sleep(1); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s seq_start", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s down", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s ampdu 0", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s up", rwl_client_path); |
| exec_process(gCmdStr); |
| if(rwl_wifi_flag) { |
| asd_sleep(1); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s seq_stop", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| /* |
| * nrate support 0-7 in SISO |
| * nrate support 0-31 in MIMO |
| */ |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s nrate -m 12", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s rifs 1", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if(rifstest->cmdsu.action_rifs == 1) { /* disable */ |
| if(rwl_wifi_flag) { |
| asd_sleep(1); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s seq_start", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s down", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s up", rwl_client_path); |
| exec_process(gCmdStr); |
| if(rwl_wifi_flag) { |
| asd_sleep(1); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s seq_stop", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s rifs 0", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s band b", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s rate -1", rwl_client_path); |
| exec_process(gCmdStr); |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s band auto", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| if(retVal == TRUE) |
| RIFStest->status = STATUS_COMPLETE; |
| else |
| RIFStest->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SET_RIFS_TEST_RESP_TLV, 4, (BYTE *)RIFStest, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| #endif /* WFA_STA_TB */ |
| return TRUE; |
| } |
| |
| /* |
| * Part of sigma 11n implementation. |
| * Implementing set wireless utility |
| */ |
| |
| int wfaStaSetWireless(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| #ifdef WFA_STA_TB |
| int retVal = TRUE; |
| dutCmdResponse_t *SetWireless = &gGenericResp; |
| dutCommand_t *wireless = (dutCommand_t *)caCmdBuf; |
| if(strcasecmp(wireless->cmdsu.wireless_band, "2.4") == 0) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s band b", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else if(strcasecmp(wireless->cmdsu.wireless_band, "5") == 0) { |
| /* |
| * Band a setting doesnt supported |
| * Gives error -13 |
| */ |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s band a", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| else { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s band auto", rwl_client_path); |
| exec_process(gCmdStr); |
| } |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| if(retVal == TRUE) |
| SetWireless->status = STATUS_COMPLETE; |
| else |
| SetWireless->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SET_WIRELESS_RESP_TLV, 4, (BYTE *)SetWireless, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| #endif /* WFA_STA_TB */ |
| return TRUE; |
| } |
| |
| int wfaStaResetDefault(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaResetDefault_t *reset = (caStaResetDefault_t *)caCmdBuf; |
| dutCmdResponse_t *ResetResp = &gGenericResp; |
| |
| /* need to implement based on program, defaults for each program set. */ |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s prog %s ", rwl_client_path, reset->prog); |
| exec_process(gCmdStr); |
| |
| ResetResp->status = STATUS_COMPLETE; |
| wfaEncodeTLV(WFA_STA_RESET_DEFAULT_RESP_TLV, 4, (BYTE *)ResetResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| |
| /* |
| * Part of sigma 11n implementation. |
| * Implementing send addba |
| */ |
| |
| int wfaStaSendAddba(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| #ifdef WFA_STA_TB |
| int retVal = TRUE; |
| dutCmdResponse_t *SendAddba = &gGenericResp; |
| dutCommand_t *addba = (dutCommand_t *)caCmdBuf; |
| FILE *tmpfd; |
| char mac[WFA_MAC_ADDR_STR_LEN]; |
| if(addba->cmdsu.tid) { |
| #ifndef WIN32 |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s bssid", rwl_client_path); |
| #else |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s bssid >", rwl_client_path); |
| #endif |
| if((tmpfd = asd_Config(gCmdStr,TEMP_FILE_PATH)) == NULL) { |
| DPRINT_ERR(WFA_OUT, "Error executing ssid\n"); |
| SendAddba->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SEND_ADDBA_RESP_TLV, 4, (BYTE *)SendAddba, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| return TRUE; |
| } |
| else { |
| while((fscanf(tmpfd, "%s\n", gCmdStr)) != EOF) { |
| memset(mac, 0, WFA_MAC_ADDR_STR_LEN); |
| strncpy(mac, gCmdStr, strlen(gCmdStr)); |
| } |
| } |
| Cleanup_File(tmpfd); |
| if (mac[2] != ':') /* if STA is not associated */ |
| strcpy(mac, "00:00:00:00:00:00"); |
| DPRINT_INFO(WFA_OUT, "MAC %s\n", mac); |
| /* |
| * If STA not associated then error -2 displays |
| */ |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s ampdu_send_addba %d %s", |
| rwl_client_path, addba->cmdsu.tid, mac); |
| exec_process(gCmdStr); |
| |
| } |
| else |
| retVal = FALSE; |
| |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| if(retVal == TRUE) |
| SendAddba->status = STATUS_COMPLETE; |
| else |
| SendAddba->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SEND_ADDBA_RESP_TLV, 4, (BYTE *)SendAddba, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| #endif /* WFA_STA_TB */ |
| return TRUE; |
| } |
| |
| |
| /* |
| * Part of sigma 11n implementation. |
| * Implementing sending coexist management |
| */ |
| |
| int wfaStaSendCoexistMgmt(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| #ifdef WFA_STA_TB |
| int retVal = FALSE; /* changed to make sure one of BSS or MHZ value presnt */ |
| dutCmdResponse_t *CoexistMgmt = &gGenericResp; |
| dutCommand_t *coexist = (dutCommand_t *)caCmdBuf; |
| int mhz, bss; |
| /* |
| * Either of BSS, MHZ value should be present in the option |
| */ |
| if (coexist->cmdsu.coexistmgmt.Mhz[0] != '\0') { |
| mhz = atoi(coexist->cmdsu.coexistmgmt.Mhz); |
| retVal = TRUE; |
| } |
| else { |
| mhz = 0; |
| } |
| if (coexist->cmdsu.coexistmgmt.bss[0] != '\0') { |
| bss = atoi(coexist->cmdsu.coexistmgmt.bss); |
| retVal = TRUE; |
| } |
| else { |
| bss = 0; |
| } |
| if (bss > 1 || bss < 0 || mhz >1 || mhz < 0) { |
| /* they can only have 0/1 */ |
| DPRINT_INFO(WFA_OUT, "BSS or MHz can have value 1/0\n"); |
| retVal = FALSE; |
| } |
| /* |
| * This command also yet to be implemented from brcm |
| */ |
| if (coexist->cmdsu.coexistmgmt.ChnlRepo[0] != '\0' && |
| coexist->cmdsu.coexistmgmt.ChnlRepo) { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s obss_coex_action -i %d -w %d -c %s", rwl_client_path, mhz, bss, |
| coexist->cmdsu.coexistmgmt.ChnlRepo); |
| } |
| else { |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s obss_coex_action -i %d -w %d", rwl_client_path, mhz, bss); |
| } |
| if (retVal == TRUE) |
| exec_process(gCmdStr); |
| else |
| DPRINT_INFO(WFA_OUT, "should enter atleast one option in MHZ or BSS\n"); |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| if(retVal == TRUE) |
| CoexistMgmt->status = STATUS_COMPLETE; |
| else |
| CoexistMgmt->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SEND_COEXIST_MGMT_RESP_TLV, 4, (BYTE *)CoexistMgmt, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| #endif /* WFA_STA_TB */ |
| return TRUE; |
| } |
| |
| /* |
| * Part of sigma 11n implementation. |
| * Implementing disconnect |
| */ |
| |
| int wfaStaSetDisconnect(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| #ifdef WFA_STA_TB |
| int retVal = TRUE; |
| dutCmdResponse_t *Disconnect = &gGenericResp; |
| dutCommand_t *discon = (dutCommand_t *)caCmdBuf; |
| DPRINT_INFO(WFA_OUT, "Entering set disconnect...\n"); |
| DPRINT_INFO(WFA_OUT, "interface entered %s\n", discon->intf); |
| |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s disassoc", rwl_client_path); |
| exec_process(gCmdStr); |
| if(retVal == TRUE) |
| Disconnect->status = STATUS_COMPLETE; |
| else |
| Disconnect->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_DISCONNECT_RESP_TLV, 4, (BYTE *)Disconnect, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| #endif /* WFA_STA_TB */ |
| return TRUE; |
| } |
| |
| /* |
| * Part of sigma 11n implementation. |
| * Implementing sending neighborhood request |
| */ |
| |
| int wfaStaSendNeigreq(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| #ifdef WFA_STA_TB |
| int retVal = TRUE; |
| dutCmdResponse_t *SendNeigreq = &gGenericResp; |
| dutCommand_t *neigreq = (dutCommand_t *)caCmdBuf; |
| char ssidTarget[WFA_SSID_NAME_LEN]; |
| bcmSsidObj_t *bso; |
| DPRINT_INFO(WFA_OUT, "Entering send neighbourhood request ...\n"); |
| memcpy(ssidTarget, neigreq->cmdsu.ssid, WFA_SSID_NAME_LEN); |
| bso = bcmWfaSsidTblSsidFind(ssidTarget); |
| if (!bso) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidTarget))) { |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed\n", ssidTarget); |
| return FALSE; |
| } |
| } |
| /* |
| * wl rrm_nbr_req need to have support for ssid parameter, currently it takes |
| * something else which is not recommended by wi-fi |
| */ |
| S_N_PRINTF(gCmdStr, WFA_CMD_STR_SZ, "%s rrm_nbr_req %s", rwl_client_path, ssidTarget); |
| DPRINT_INFO(WFA_OUT, "%s\n", gCmdStr); |
| exec_process(gCmdStr); |
| /* |
| * Then report back to control PC for completion. |
| * This does not have failed/error status. The result only tells |
| * a completion. |
| */ |
| if(retVal == TRUE) |
| SendNeigreq->status = STATUS_COMPLETE; |
| else |
| SendNeigreq->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SEND_NEIGREQ_RESP_TLV, 4, (BYTE *)SendNeigreq, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| #endif /* WFA_STA_TB */ |
| return TRUE; |
| } |
| |
| /* |
| * wfaStaSetFAST() |
| * This is to set |
| * 1. ssid |
| * 2. user name |
| * 3. passwd |
| * 4. encryType - tkip or aes-ccmp |
| * 5. keyMgmtType - wpa or wpa2 |
| * 6. trustedRootCA |
| * 7. innerEAP |
| * 8. validateserver |
| * 9. PACfile |
| */ |
| int wfaStaSetEapFAST(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetEapFAST_t *setFAST = (caStaSetEapFAST_t *)caCmdBuf; |
| int retVal = TRUE; |
| dutCmdResponse_t *setFastResp = &gGenericResp; |
| bcmSsidObj_t *bso; |
| char ssidTarget[WFA_SSID_NAME_LEN]; |
| |
| memcpy(ssidTarget, setFAST->ssid, WFA_SSID_NAME_LEN); |
| bso = bcmWfaSsidTblSsidFind(ssidTarget); |
| if (!bso) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidTarget))) { |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed\n", ssidTarget); |
| retVal = FALSE; |
| } |
| if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) { |
| bcmWfaSsidObjPrint(bso); |
| } |
| |
| } |
| |
| memcpy(&(bso->eapObj.setEapFAST), setFAST, sizeof(caStaSetEapFAST_t)); |
| bso->eapType = BCM_EAP_TYPE_FAST; |
| |
| if(strstr(bso->eapObj.setEapFAST.encrptype,"aes-ccmp")) |
| strncpy(bso->eapObj.setEapFAST.encrptype, AES_ENCPTYPE, AES_LEN) ; |
| if(retVal == TRUE) |
| setFastResp->status = STATUS_COMPLETE; |
| else |
| setFastResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SET_EAPFAST_RESP_TLV, 4, (BYTE *)setFastResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |
| |
| /* |
| * wfaStaSetEapAKA() |
| * This is to set |
| * 1. ssid |
| * 2. user name |
| * 3. passwd |
| * 4. encryType - tkip or aes-ccmp |
| * 5. keyMgmtType - wpa or wpa2 |
| */ |
| int wfaStaSetEapAKA(int len, BYTE *caCmdBuf, int *respLen, BYTE *respBuf) |
| { |
| caStaSetEapAKA_t *setAKA = (caStaSetEapAKA_t *)caCmdBuf; |
| dutCmdResponse_t *setAkaResp = &gGenericResp; |
| bcmSsidObj_t *bso; |
| int retVal = TRUE; |
| char ssidTarget[WFA_SSID_NAME_LEN]; |
| |
| memcpy(ssidTarget, setAKA->ssid, WFA_SSID_NAME_LEN); |
| bso = bcmWfaSsidTblSsidFind(ssidTarget); |
| if (!bso) { |
| if (!(bso = bcmWfaSsidObjTblAdd(ssidTarget))) { |
| DPRINT_ERR(WFA_OUT, "bcmWfaSsidObjTblAdd(%s) failed\n", ssidTarget); |
| retVal = FALSE; |
| } |
| if (wfa_defined_debug & (WFA_DEBUG_ERR | WFA_DEBUG_INFO)) { |
| bcmWfaSsidObjPrint(bso); |
| } |
| |
| } |
| |
| memcpy(&(bso->eapObj.setEapAKA), setAKA, sizeof(caStaSetEapAKA_t)); |
| bso->eapType = BCM_EAP_TYPE_AKA; |
| |
| if(strstr(bso->eapObj.setEapAKA.encrptype,"aes-ccmp")) |
| strncpy(bso->eapObj.setEapAKA.encrptype, AES_ENCPTYPE, AES_LEN) ; |
| if(retVal == TRUE) |
| setAkaResp->status = STATUS_COMPLETE; |
| else |
| setAkaResp->status = STATUS_ERROR; |
| wfaEncodeTLV(WFA_STA_SET_EAPAKA_RESP_TLV, 4, (BYTE *)setAkaResp, respBuf); |
| *respLen = WFA_TLV_HDR_LEN + 4; |
| |
| return TRUE; |
| } |