S32 IpcWpa_CommandWithResp(THandle hIpcWpa, PS8 cmd, S32 print, PS8 pResp, PU32 pRespLen)
{
TIpcWpa* pIpcWpa = (TIpcWpa*)hIpcWpa;
S32 ret;
*pRespLen = IPC_WPA_RESP_MAX_LEN - 1;
ret = wpa_ctrl_request(pIpcWpa->pWpaCtrl, (char*)cmd, os_strlen(cmd), (char*)pResp, (size_t*)pRespLen, NULL);
if (ret == -2)
{
os_error_printf(CU_MSG_ERROR, (PS8)"'%s' command timed out.\n", cmd);
return EOALERR_IPC_WPA_ERROR_CMD_TIMEOUT;
}
else if (ret < 0)
{
os_error_printf(CU_MSG_ERROR, (PS8)"'%s' command failed.\n", cmd);
return EOALERR_IPC_WPA_ERROR_CMD_FAILED;
}
if (print)
{
pResp[*pRespLen] = '\0';
os_error_printf(CU_MSG_INFO2, (PS8)"%s", pResp);
}
return OK;
}
static S32 IpcEvent_Handle_Parent_Event(IpcEvent_Child_t* pIpcEventChild)
{
S8 msg[IPC_EVENT_MSG_MAX_LEN];
S32 msgLen = read(pIpcEventChild->pipe_from_parent,msg, IPC_EVENT_MSG_MAX_LEN);
/* If read() fails it returns -1. Avoid buffer out of boundary */
if (msgLen < 0) {
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Handle_Parent_Event - read() failed!\n");
return FALSE;
}
msg[msgLen] = 0;
if (!os_strcmp(msg, (PS8)IPC_EVENT_MSG_KILL)) {
return TRUE;
}
if (!os_strcmp(msg, (PS8)IPC_EVENT_MSG_UPDATE_DEBUG_LEVEL)) {
/* g_debug_level= pIpcEventChild->p_shared_memory->content.debug_level;*/
return FALSE;
} else
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Handle_Parent_Event - unknown msgLen=%d msg=|%s| \n",msgLen,msg);
return FALSE;
}
static S32 RunShellCmd(S8 *cmd)
{
/* We'd like to execute the command using the regular call to system(). But system() assumes the existence of
/bin/sh in the file system which doesn't exist in Android zoom2 shell, where shell is in /system/bin/sh
So if /bin/sh is not found run the command using fork&exec and assume that the shell is invoked using /system/bin/sh
*/
if (access("/bin/sh", F_OK) != -1)
{
return system(cmd);
}
else
{
/*Spawn a child to run the program.*/
pid_t pid=fork();
if (pid == -1)
{
os_error_printf(CU_MSG_ERROR, (PS8)("Fork failed!\n"));
return -1;
}
else if (pid==0)
{
/* child process */
execl("/system/bin/sh", "sh", "-c", cmd, NULL);
os_error_printf(CU_MSG_ERROR, (PS8)("Exec failed!\n"));
return -1;
}
else
{ /* pid!=0; parent process */
waitpid(pid,0,0); /* wait for child to exit */
}
}
return 0;
}
S32 print_usage(VOID)
{
os_error_printf (CU_MSG_INFO1, (PS8)"Usage: ./wlan_loader [driver_name] [options]\n");
os_error_printf (CU_MSG_INFO1, (PS8)" -e <filename> - eeprom image file name. default=./nvs_map.bin\n");
os_error_printf (CU_MSG_INFO1, (PS8)" -n - no eeprom file\n");
os_error_printf (CU_MSG_INFO1, (PS8)" -i <filename> - init file name. default=tiwlan.ini\n");
os_error_printf (CU_MSG_INFO1, (PS8)" -f <filename> - firmware image file name. default=firmware.bin\n");
return 1;
}
THandle IpcEvent_Create(VOID)
{
IpcEvent_t* pIpcEvent = (IpcEvent_t*)os_MemoryCAlloc(sizeof(IpcEvent_t), sizeof(U8));
if(pIpcEvent == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Create - cant allocate control block\n");
return NULL;
}
/* create a shared memory space */
pIpcEvent->p_shared_memory = mmap(0, sizeof(IpcEvent_Shared_Memory_t), PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
if ( pIpcEvent->p_shared_memory == ((PVOID)-1))
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Create - cant allocate shared memory\n");
IpcEvent_Destroy(pIpcEvent);
return NULL;
}
/* create a pipe */
pipe(pIpcEvent->p_shared_memory->pipe_fields);
/* set the event mask to all disabled */
pIpcEvent->p_shared_memory->event_mask = 0;
/* Create a child process */
pIpcEvent->child_process_id = fork();
if (0 == pIpcEvent->child_process_id)
{
/******************/
/* Child process */
/****************/
IpcEvent_Child_t* pIpcEventChild = (IpcEvent_Child_t*)os_MemoryCAlloc(sizeof(IpcEvent_Child_t), sizeof(U8));
if(pIpcEventChild == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Create - cant allocate child control block\n");
_exit(1);
}
pIpcEventChild->p_shared_memory = pIpcEvent->p_shared_memory;
pIpcEventChild->pipe_from_parent = pIpcEventChild->p_shared_memory->pipe_fields[PIPE_READ];
close(pIpcEventChild->p_shared_memory->pipe_fields[PIPE_WRITE]);
IpcEvent_Child(pIpcEventChild);
os_MemoryFree(pIpcEventChild);
_exit(0);
}
pIpcEvent->pipe_to_child = pIpcEvent->p_shared_memory->pipe_fields[PIPE_WRITE];
close(pIpcEvent->p_shared_memory->pipe_fields[PIPE_READ]);
return pIpcEvent;
}
VOID IpcEvent_ReconfigHostapd(void)
{
int res =0 ;
char cmd[100];
char temp = '"';
sprintf(cmd, "/bin/sh -c %cbusybox killall -SIGHUP hostapd%c",temp ,temp);
os_error_printf(CU_MSG_ERROR, "\nReconfiguring Hostapd Started... \n" );
res = system(cmd);
os_error_printf(CU_MSG_ERROR, "\nReconfiguring Hostapd Finished. \n" );
}
static VOID IpcEvent_Handle_STA_Event(IpcEvent_Child_t* pIpcEventChild)
{
S8 buf[512];
S32 left;
struct sockaddr_nl from;
socklen_t fromlen;
struct nlmsghdr *h;
fromlen = sizeof(from);
left = recvfrom(pIpcEventChild->STA_socket, buf, sizeof(buf), MSG_DONTWAIT,
(struct sockaddr *) &from, &fromlen);
if (left < 0)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Handle_STA_Event - cant recv from socket %X .\n",
pIpcEventChild->STA_socket);
return;
}
h = (struct nlmsghdr *) buf;
while (left >= sizeof(*h))
{
S32 len, plen;
len = h->nlmsg_len;
plen = len - sizeof(*h);
if (len > left || plen < 0) {
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Handle_STA_Event - Malformed netlink message: len=%d left=%d plen=%d",
len, left, plen);
break;
}
switch (h->nlmsg_type)
{
case RTM_NEWLINK:
IpcEvent_wext_event_rtm_newlink(pIpcEventChild, h, plen);
break;
}
len = NLMSG_ALIGN(len);
left -= len;
h = (struct nlmsghdr *) ((char *) h + len);
}
if (left > 0)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Handle_STA_Event - %d extra bytes in the end of netlink ",
left);
IpcEvent_Handle_STA_Event(pIpcEventChild);
}
}
static VOID IpcEvent_Child(IpcEvent_Child_t* pIpcEventChild)
{
/* open the socket from the driver */
pIpcEventChild->STA_socket = IpcEvent_Sockets_Open();
if(pIpcEventChild->STA_socket < 0)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Create - cant open socket for communication with the driver (%d)\n",pIpcEventChild->STA_socket);
return;
}
while(1)
{
fd_set read_set; /* File descriptors for select */
S32 ret;
FD_ZERO(&read_set);
FD_SET(pIpcEventChild->STA_socket, &read_set);
FD_SET(pIpcEventChild->pipe_from_parent, &read_set);
#ifndef ANDROID
ret = select(max(pIpcEventChild->pipe_from_parent,pIpcEventChild->STA_socket) + 1,
&read_set, NULL, NULL, NULL);
#else
ret = select(pIpcEventChild->STA_socket + 1,
&read_set, NULL, NULL, NULL);
#endif
if(ret < 0)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcEvent_Child - Unhandled signal - exiting...\n");
break;
}
if(ret == 0) { continue; } /* Check for interface discovery events. */
if(FD_ISSET(pIpcEventChild->STA_socket, &read_set))
IpcEvent_Handle_STA_Event(pIpcEventChild);
#ifndef ANDROID
if(FD_ISSET(pIpcEventChild->pipe_from_parent, &read_set))
{
S32 exit = IpcEvent_Handle_Parent_Event(pIpcEventChild);
if(exit)
break;
}
#endif
}
IpcEvent_Child_Destroy(pIpcEventChild);
}
S32 IPC_STA_Private_Send(THandle hIpcSta, U32 ioctl_cmd, PVOID bufIn, U32 sizeIn,
PVOID bufOut, U32 sizeOut)
{
IpcSta_t* pIpcSta = (IpcSta_t*)hIpcSta;
S32 res;
pIpcSta ->private_cmd.cmd = ioctl_cmd;
if(bufOut == NULL)
pIpcSta ->private_cmd.flags = PRIVATE_CMD_SET_FLAG;
else
pIpcSta ->private_cmd.flags = PRIVATE_CMD_GET_FLAG;
pIpcSta ->private_cmd.in_buffer = bufIn;
pIpcSta ->private_cmd.in_buffer_len = sizeIn;
pIpcSta ->private_cmd.out_buffer = bufOut;
pIpcSta ->private_cmd.out_buffer_len = sizeOut;
pIpcSta->wext_req.u.data.pointer = &pIpcSta->private_cmd;
pIpcSta->wext_req.u.data.length = sizeof(ti_private_cmd_t);
pIpcSta->wext_req.u.data.flags = 0;
res = ioctl(pIpcSta->STA_socket, SIOCIWFIRSTPRIV, &pIpcSta->wext_req);
if(res != OK)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IPC_STA_Private_Send - error sending Wext private IOCTL to STA driver (ioctl_cmd = %x, res = %d, errno = %d)\n", ioctl_cmd,res,errno);
return EOALERR_IPC_STA_ERROR_SENDING_WEXT;
}
return OK;
}
THandle WpaCore_Create(PS32 pRes, PS8 pSupplIfFile)
{
TWpaCore* pWpaCore = (TWpaCore*)os_MemoryCAlloc(sizeof(TWpaCore), sizeof(U8));
if(pWpaCore == NULL)
{
*pRes = OK;
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - WpaCore_Create - cant allocate control block\n");
return NULL;
}
pWpaCore->hIpcWpa = IpcWpa_Create(pRes, pSupplIfFile);
if(pWpaCore->hIpcWpa == NULL)
{
WpaCore_Destroy(pWpaCore);
return NULL;
}
WpaCore_InitWpaParams(pWpaCore);
pWpaCore->CurrentNetwork = -1;
/* send default configuration to the supplicant */
IpcWpa_Command(pWpaCore->hIpcWpa, (PS8)"AP_SCAN 2", FALSE);
return pWpaCore;
}
S32 WpaCore_SetEncryptionGroup(THandle hWpaCore, OS_802_11_ENCRYPTION_TYPES EncryptionType)
{
TWpaCore* pWpaCore = (TWpaCore*)hWpaCore;
pWpaCore->WpaParams.EncryptionTypeGroup = EncryptionType;
switch (EncryptionType)
{
case OS_ENCRYPTION_TYPE_NONE:
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - WpaCore_SetEncryptionGroup - group encryption cant be NONE\n");
break;
case OS_ENCRYPTION_TYPE_WEP:
pWpaCore->WpaSupplParams.group = WPA_CIPHER_WEP40;
break;
case OS_ENCRYPTION_TYPE_TKIP:
pWpaCore->WpaSupplParams.group = WPA_CIPHER_TKIP;
break;
case OS_ENCRYPTION_TYPE_AES:
pWpaCore->WpaSupplParams.group = WPA_CIPHER_CCMP;
break;
}
return OK;
}
S32 CuOs_Start_Scan(THandle hCuWext, OS_802_11_SSID* ssid, U8 scanType)
{
TCuWext* pCuWext = (TCuWext*)hCuWext;
struct iw_scan_req tReq;
S32 res;
if (ssid->SsidLength > IW_ESSID_MAX_SIZE) {
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuOs_Start_Scan - too long SSID (%lu)\n",ssid->SsidLength);
return OSAL_ERROR;
}
if (ssid->Ssid[0] && ssid->SsidLength) {
os_memset(&tReq, 0, sizeof(tReq));
tReq.essid_len = ssid->SsidLength;
/*
* tReq.bssid.sa_family = ARPHRD_ETHER;
* os_memset(tReq.bssid.sa_data, 0xff, ETH_ALEN);
*/
os_memcpy(tReq.essid, ssid->Ssid, ssid->SsidLength);
pCuWext->scan_req = &tReq;
pCuWext->req_data.data.flags = IW_SCAN_THIS_ESSID;
} else {
pCuWext->req_data.data.flags = 0;
}
tReq.scan_type = scanType;
pCuWext->req_data.data.pointer = &tReq;
pCuWext->req_data.data.length = sizeof(struct iw_scan_req);
res = IPC_STA_Wext_Send(pCuWext->hIpcSta, SIOCSIWSCAN, &pCuWext->req_data, sizeof(struct iw_point));
if(res != OK)
return res;
return OK;
}
S32 WpaCore_SetAuthMode(THandle hWpaCore, OS_802_11_AUTHENTICATION_MODE AuthMode)
{
TWpaCore* pWpaCore = (TWpaCore*)hWpaCore;
pWpaCore->WpaParams.AuthMode = AuthMode;
switch (AuthMode)
{
case os802_11AuthModeOpen:
pWpaCore->WpaSupplParams.proto = 0;
pWpaCore->WpaSupplParams.key_mgmt = WPA_KEY_MGMT_NONE;
pWpaCore->WpaSupplParams.auth_alg = WPA_AUTH_ALG_OPEN;
break;
case os802_11AuthModeShared:
pWpaCore->WpaSupplParams.proto = 0;
pWpaCore->WpaSupplParams.key_mgmt = WPA_KEY_MGMT_NONE;
pWpaCore->WpaSupplParams.auth_alg = WPA_AUTH_ALG_SHARED;
break;
case os802_11AuthModeAutoSwitch:
pWpaCore->WpaSupplParams.proto = 0;
pWpaCore->WpaSupplParams.key_mgmt = WPA_KEY_MGMT_NONE;
pWpaCore->WpaSupplParams.auth_alg = (WPA_AUTH_ALG_SHARED | WPA_AUTH_ALG_OPEN);
break;
case os802_11AuthModeWPANone:
pWpaCore->WpaSupplParams.proto = WPA_PROTO_WPA;
pWpaCore->WpaSupplParams.key_mgmt = WPA_KEY_MGMT_WPA_NONE;
pWpaCore->WpaSupplParams.auth_alg = WPA_AUTH_ALG_OPEN;
break;
case os802_11AuthModeWPAPSK:
pWpaCore->WpaSupplParams.proto = WPA_PROTO_WPA;
pWpaCore->WpaSupplParams.key_mgmt = WPA_KEY_MGMT_PSK;
pWpaCore->WpaSupplParams.auth_alg = WPA_AUTH_ALG_OPEN;
break;
case os802_11AuthModeWPA2PSK:
pWpaCore->WpaSupplParams.proto = WPA_PROTO_RSN;
pWpaCore->WpaSupplParams.key_mgmt = WPA_KEY_MGMT_PSK;
pWpaCore->WpaSupplParams.auth_alg = WPA_AUTH_ALG_OPEN;
break;
case os802_11AuthModeWPA:
pWpaCore->WpaSupplParams.proto = WPA_PROTO_WPA;
pWpaCore->WpaSupplParams.key_mgmt = WPA_KEY_MGMT_IEEE8021X;
pWpaCore->WpaSupplParams.auth_alg = WPA_AUTH_ALG_OPEN;
break;
case os802_11AuthModeWPA2:
pWpaCore->WpaSupplParams.proto = WPA_PROTO_RSN;
pWpaCore->WpaSupplParams.key_mgmt = WPA_KEY_MGMT_IEEE8021X;
pWpaCore->WpaSupplParams.auth_alg = WPA_AUTH_ALG_OPEN;
break;
default:
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - WpaCore_SetAuthMode - unknown authentication mode (%d)!!!\n", AuthMode);
return ECUERR_WPA_CORE_ERROR_UNKNOWN_AUTH_MODE;
}
return OK;
}
int check_and_set_property(char *prop_name, char *prop_val)
{
char prop_status[PROPERTY_VALUE_MAX];
int count;
for(count=4;( count != 0 );count--) {
property_set(prop_name, prop_val);
if( property_get(prop_name, prop_status, NULL) &&
(strcmp(prop_status, prop_val) == 0) )
break;
}
if( count ) {
os_error_printf(CU_MSG_ERROR, (PS8)"Set property %s = %s - Ok\n", prop_name, prop_val);
}
else {
os_error_printf(CU_MSG_ERROR, (PS8)"Set property %s = %s - Fail\n", prop_name, prop_val);
}
return( count );
}
TI_BOOL loggerConn_sendMsg (THandle loggerConn, PS8 buffer, U32 bufferSize)
{
PLOG_CONN_DATA LogConn = (PLOG_CONN_DATA) loggerConn;
if(LogConn->data_sock == NULL)
{
os_error_printf(CU_MSG_ERROR, "**** ERROR LogConn->data_sock is NULL ****\n");
return FALSE;
}
return os_sockSend(LogConn->data_sock, buffer, bufferSize);
}
S32 WpaCore_Disassociate(THandle hWpaCore)
{
TWpaCore* pWpaCore = (TWpaCore*)hWpaCore;
S8 cmd[256];
os_sprintf(cmd, (PS8)"DISABLE_NETWORK %d", pWpaCore->CurrentNetwork);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 1))
{
os_error_printf(CU_MSG_ERROR, (PS8)"Failed to disconnect from current ssid\n");
return ECUERR_WPA_CORE_ERROR_FAILED_DISCONNECT_SSID;
}
pWpaCore->CurrentNetwork = -1;
IpcWpa_Command(pWpaCore->hIpcWpa, (PS8)"SAVE_CONFIG", 0);
#if 0 /* for futur WPS work */
if(pWpaCore->CurrentNetwork == -1)
{
os_sprintf(cmd, (PS8)"LIST_NETWORKS");
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 1))
{
os_error_printf(CU_MSG_ERROR, (PS8)"Failed to disconnect from current ssid\n");
return ECUERR_WPA_CORE_ERROR_FAILED_DISCONNECT_SSID;
}
}
else
{
os_sprintf(cmd, (PS8)"DISABLE_NETWORK %d", pWpaCore->CurrentNetwork);
if (IpcWpa_Command(pWpaCore->hIpcWpa, cmd, 1))
{
os_error_printf(CU_MSG_ERROR, (PS8)"Failed to disconnect from current ssid\n");
return ECUERR_WPA_CORE_ERROR_FAILED_DISCONNECT_SSID;
}
pWpaCore->CurrentNetwork = -1;
IpcWpa_Command(pWpaCore->hIpcWpa, (PS8)"SAVE_CONFIG", 0);
}
#endif /* #if 0 for futur WPS work */
return OK;
}
THandle CuOs_Create(THandle hIpcSta)
{
TCuWext* pCuWext = (TCuWext*)os_MemoryCAlloc(sizeof(TCuWext), sizeof(U8));
if(pCuWext == NULL) {
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuOs_Create - cant allocate control block\n");
return NULL;
}
pCuWext->hIpcSta = hIpcSta;
return pCuWext;
}
S32 CuOs_GetBssidList(THandle hCuWext, OS_802_11_BSSID_LIST_EX *bssidList)
{
TCuWext* pCuWext = (TCuWext*)hCuWext;
S32 res, NumberOfItems;
/* allocate the scan result buffer */
U8* buffer = os_MemoryCAlloc(IW_SCAN_MAX_DATA, sizeof(U8));
if(buffer == NULL) {
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - CuOs_Get_BssidList - cant allocate scan result buffer\n");
return EOALERR_CU_WEXT_ERROR_CANT_ALLOCATE;
}
NumberOfItems = 0;
pCuWext->req_data.data.pointer = buffer;
pCuWext->req_data.data.flags = 0;
do {
pCuWext->req_data.data.length = IW_SCAN_MAX_DATA;
res = IPC_STA_Wext_Send(pCuWext->hIpcSta, SIOCGIWSCAN, &pCuWext->req_data, sizeof(struct iw_point));
if(res != OK) {
os_MemoryFree(buffer);
return res;
}
/* parse the scan results */
if(pCuWext->req_data.data.length) {
struct iw_event iwe;
struct stream_descr stream;
S32 ret;
/* init the event stream */
os_memset((char *)&stream, '\0', sizeof(struct stream_descr));
stream.current = (char *)buffer;
stream.end = (char *)(buffer + pCuWext->req_data.data.length);
do {
/* Extract an event and print it */
ret = ParsEvent_GetEvent(&stream, &iwe);
if(ret > 0)
NumberOfItems += CuWext_FillBssidList(&iwe, bssidList->Bssid, NumberOfItems);
} while(ret > 0);
}
} while(pCuWext->req_data.data.flags);
bssidList->NumberOfItems = NumberOfItems;
/* free the scan result buffer */
os_MemoryFree(buffer);
return OK;
}
/************************************************************************
* os_getFileSize *
************************************************************************
DESCRIPTION: wrapper to the OS fopen fucntion
CONTEXT:
************************************************************************/
S32 os_getFileSize (PVOID file)
{
S32 size;
if (fseek(file, 0, SEEK_END))
{
os_error_printf (CU_MSG_ERROR, (PS8)"Cannot seek file to end\n");
return -1;
}
size = ftell(file);
rewind(file);
return size;
}
THandle IpcSta_Create(const PS8 device_name)
{
IpcSta_t* pIpcSta = (IpcSta_t*)os_MemoryCAlloc(sizeof(IpcSta_t), sizeof(U8));
if(pIpcSta == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcSta_Create - cant allocate control block\n");
return NULL;
}
/* open the socket to the driver */
pIpcSta->STA_socket = IpcSta_Sockets_Open();
if(pIpcSta->STA_socket == -1)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcSta_Create - cant open socket for communication with the driver\n");
return NULL;
}
/* set the driver name */
os_strcpy((PS8)pIpcSta->wext_req.ifr_ifrn.ifrn_name, device_name);
return pIpcSta;
}
VOID CuCmd_ReportSeverityLevel(THandle hCuCmd, ConParm_t parm[], U16 nParms)
{
CuCmd_t* pCuCmd = (CuCmd_t*)hCuCmd;
U8 SeverityTable[REPORT_SEVERITY_MAX];
S32 index = 0;
PS8 SeverityValue = (PS8)(parm[0].value);
/* Get the current report severity */
if (!CuCommon_GetBuffer(pCuCmd->hCuCommon, REPORT_SEVERITY_TABLE_PARAM, SeverityTable, REPORT_SEVERITY_MAX))
{
if(nParms == 0)
{
S32 i;
os_error_printf(CU_MSG_INFO2, (PS8)"Severity:\n");
os_error_printf(CU_MSG_INFO2, (PS8)"-------------------------------\n");
os_error_printf(CU_MSG_INFO2, (PS8)"%14s\tState\t%s\n", (PS8)"Severity level", (PS8)"Desc");
for( i=1; i<SIZE_ARR(report_severity); i++ )
{
os_error_printf(CU_MSG_INFO2, (PS8)"%d\t%c\t%s\n", report_severity[i].value, (SeverityTable[i] == '1') ? '+' : ' ', report_severity[i].name );
}
os_error_printf(CU_MSG_INFO2, (PS8)"* Use '0' to clear all table.\n");
os_error_printf(CU_MSG_INFO2, (PS8)"* Use '%d' (max index) to set all table.\n", REPORT_SEVERITY_MAX);
}
else
{
for (index = 0; index < REPORT_SEVERITY_MAX; index ++)
{
if (SeverityValue[index] == '0')
{
SeverityTable[index] = '0';
}
else
{
SeverityTable[index] = '1';
}
}
CuCommon_SetBuffer(pCuCmd->hCuCommon, REPORT_SEVERITY_TABLE_PARAM, SeverityTable, REPORT_SEVERITY_MAX);
}
}
else
{
os_error_printf(CU_MSG_ERROR, (PS8)"Error retriving the severity table from the driver\n");
}
}
S32 IPC_STA_Wext_Send(THandle hIpcSta, U32 wext_request_id, PVOID p_iwreq_data, U32 len)
{
IpcSta_t* pIpcSta = (IpcSta_t*)hIpcSta;
S32 res;
os_memcpy(&pIpcSta->wext_req.u.data, p_iwreq_data, len);
res = ioctl(pIpcSta->STA_socket, wext_request_id, &pIpcSta->wext_req);
if(res != OK)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IPC_STA_Wext_Send - error sending Wext IOCTL to STA driver (wext_request_id = 0x%x, res = %d, errno = %d)\n",wext_request_id,res,errno);
return EOALERR_IPC_STA_ERROR_SENDING_WEXT;
}
os_memcpy(p_iwreq_data, &pIpcSta->wext_req.u.data, len);
return OK;
}
static VOID IpcEvent_wext_event_rtm_newlink(IpcEvent_Child_t* pIpcEventChild, struct nlmsghdr *h,
S32 len)
{
struct ifinfomsg *ifi;
S32 attrlen, nlmsg_len, rta_len;
struct rtattr * attr;
if (len < sizeof(*ifi))
return;
ifi = NLMSG_DATA(h);
/*
if ((if_nametoindex("wlan") != ifi->ifi_index) && (if_nametoindex("wifi") != ifi->ifi_index))
{
os_error_printf(CU_MSG_ERROR, "ERROR - IpcEvent_wext_event_rtm_newlink - Ignore event for foreign ifindex %d",
ifi->ifi_index);
return;
}
*/
nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg));
attrlen = h->nlmsg_len - nlmsg_len;
if (attrlen < 0)
return;
attr = (struct rtattr *) (((char *) ifi) + nlmsg_len);
rta_len = RTA_ALIGN(sizeof(struct rtattr));
while (RTA_OK(attr, attrlen)) {
if (attr->rta_type == IFLA_WIRELESS)
{
IpcEvent_wext_event_wireless(pIpcEventChild, ((PS8) attr) + rta_len,
attr->rta_len - rta_len);
}
else if (attr->rta_type == IFLA_IFNAME)
{
os_error_printf(CU_MSG_WARNING, (PS8)"WARNING - IpcEvent_wext_event_rtm_newlink - unsupported rta_type = IFLA_IFNAME\n");
}
attr = RTA_NEXT(attr, attrlen);
}
}
THandle IpcWpa_Create(PS32 pRes, PS8 pSupplIfFile)
{
TIpcWpa* pIpcWpa = (TIpcWpa*)os_MemoryCAlloc(sizeof(TIpcWpa), sizeof(U8));
if (pIpcWpa == NULL)
{
*pRes = OK;
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcWpa_Create - cant allocate control block\n");
return NULL;
}
*pRes = IpcWpa_Sockets_Open(pIpcWpa, pSupplIfFile);
if (*pRes)
{
IpcWpa_Destroy(pIpcWpa);
return NULL;
}
return pIpcWpa;
}
static S32 IpcWpa_Sockets_Open(TIpcWpa* pIpcWpa, PS8 pSupplIfFile)
{
S32 i;
for (i=0; i< IPC_WPA_CTRL_OPEN_RETRIES; i++)
{
pIpcWpa->pWpaCtrl = wpa_ctrl_open((char*)pSupplIfFile);
if (pIpcWpa->pWpaCtrl)
break;
}
if (pIpcWpa->pWpaCtrl == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - IpcWpa_Sockets_Open - can't connect the socket\n");
return EOALERR_IPC_WPA_ERROR_CANT_CONNECT_TO_SUPPL;
}
return OK;
}
THandle CuCommon_Create(THandle *pIpcSta, const PS8 device_name)
{
CuCommon_t* pCuCommon = (CuCommon_t*)os_MemoryCAlloc(sizeof(CuCommon_t), sizeof(U8));
if(pCuCommon == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)("ERROR - CuCommon_Create - cant allocate control block\n") );
return NULL;
}
pCuCommon->hIpcSta = IpcSta_Create(device_name);
if(pCuCommon->hIpcSta == NULL)
{
CuCommon_Destroy(pCuCommon);
return NULL;
}
*pIpcSta = pCuCommon->hIpcSta;
return pCuCommon;
}
S32 CuCommon_Radio_Test(THandle hCuCommon,TTestCmd* data)
{
CuCommon_t* pCuCommon = (CuCommon_t*)hCuCommon;
S32 res;
res = IPC_STA_Private_Send(pCuCommon->hIpcSta,
TWD_RADIO_TEST_PARAM,
(PVOID)data,
sizeof(TTestCmd),
(PVOID)data,
sizeof(TTestCmd));
if(res == EOALERR_IPC_STA_ERROR_SENDING_WEXT)
{
os_error_printf(CU_MSG_INFO2, (PS8)"In CuCommon_Radio_Test: IPC_STA_Private_Send failed\n");
return ECUERR_CU_COMMON_ERROR;
}
return OK;
}
/************************************************************************
* os_getInputString *
************************************************************************
DESCRIPTION: get the input string for the console from the appropiate inputs
CONTEXT:
************************************************************************/
S32 os_getInputString(PS8 inbuf, S32 len)
{
fd_set read_set;
S32 max_fd_index;
S32 result;
S32 pid;
/*
* Wait for one of two external events:
* -----------------------------------
*
* 1. Data received from STDIN
* 2. Data received from the event process
*/
/* Prepare the read set fields */
FD_ZERO(&read_set);
FD_SET(0, &read_set);
FD_SET(ipc_pipe[0], &read_set);
/* Determine the maximum index of the file descriptor */
max_fd_index = max(0, ipc_pipe[0]) + 1;
/* Wait for event - blocking */
result = select(max_fd_index, &read_set, NULL, NULL, NULL);
if (result > 0)
{
if (FD_ISSET(0, &read_set))
{
/* Data received from STDIN */
if ( fgets( (char*)inbuf, len, stdin ) <= 0 )
return FALSE;
else
return TRUE;
}
if (FD_ISSET(ipc_pipe[0], &read_set))
{
/**********************************/
/* Data received from TCP client */
/********************************/
result = read(ipc_pipe[0], inbuf, len);
/* Get the pid of the calling process */
pid = *(inbuf + 0) | (*(inbuf + 1) << 8);
/*
Signal the calling process (tell him that we have
received the command, and he can send us another one
*/
if (pid != 0xFFFF)
{
kill(pid, SIGUSR1);
}
if ( result <= 0 )
return FALSE;
else
return TRUE;
}
}
/* Error */
os_error_printf(CU_MSG_ERROR, (PS8)"Input selection mismatch (0x%x)...\n", read_set);
return FALSE;
}
/************************************************************************
* os_Catch_CtrlC_Signal *
************************************************************************
DESCRIPTION: register to catch the Ctrl+C signal
CONTEXT:
************************************************************************/
VOID os_Catch_CtrlC_Signal(PVOID SignalCB)
{
if(signal(SIGINT, SignalCB) == SIG_ERR)
os_error_printf(CU_MSG_ERROR, (PS8)"ERROR - os_Catch_CtrlC_Signal - cant catch Ctrl+C signal\n");
}
static VOID IpcEvent_PrintEvent(IpcEvent_Child_t* pIpcEventChild, U32 EventId, TI_UINT8* pData, S32 DataLen)
{
if(pIpcEventChild->p_shared_memory->event_mask & ((u64)1<<EventId))
{
switch(EventId)
{
case IPC_EVENT_DISASSOCIATED:
{
OS_802_11_DISASSOCIATE_REASON_T *pDisAssoc;
if (NULL == pData)
{
return;
}
else
{
pDisAssoc = (OS_802_11_DISASSOCIATE_REASON_T*)pData;
}
switch(pDisAssoc->eDisAssocType)
{
case OS_DISASSOC_STATUS_UNSPECIFIED:
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated with unspecified reason (User/SG/Recovery)\n");
break;
case OS_DISASSOC_STATUS_AUTH_REJECT:
if (pDisAssoc->uStatusCode == STATUS_PACKET_REJ_TIMEOUT)
{
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated due to no Auth response \n");
}
else
{
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated due to Auth response packet with reason = %d\n", pDisAssoc->uStatusCode);
}
break;
case OS_DISASSOC_STATUS_ASSOC_REJECT:
if (pDisAssoc->uStatusCode == STATUS_PACKET_REJ_TIMEOUT)
{
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated due to no Assoc response \n");
}
else
{
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated due to Assoc response packet with reason = %d\n", pDisAssoc->uStatusCode);
}
break;
case OS_DISASSOC_STATUS_SECURITY_FAILURE:
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated due to RSN failure\n");
break;
case OS_DISASSOC_STATUS_AP_DEAUTHENTICATE:
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated due to AP deAuthenticate packet with reason = %d\n", pDisAssoc->uStatusCode);
break;
case OS_DISASSOC_STATUS_AP_DISASSOCIATE:
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated due to AP disAssoc packet with reason = %d\n", pDisAssoc->uStatusCode);
break;
case OS_DISASSOC_STATUS_ROAMING_TRIGGER:
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated due to roaming trigger = %d\n", pDisAssoc->uStatusCode);
break;
default:
os_error_printf(CU_MSG_ERROR, "CLI Event - Disassociated with unknown reason = %d\n", pDisAssoc->eDisAssocType);
break;
}
break; /* the end of the IPC_EVENT_DISASSOCIATED case */
}
case IPC_EVENT_ASSOCIATED:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_ASSOCIATED\n");
break;
case IPC_EVENT_MEDIA_SPECIFIC:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_MEDIA_SPECIFIC\n");
break;
case IPC_EVENT_SCAN_COMPLETE:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_SCAN_COMPLETE\n");
break;
/* custom events */
case IPC_EVENT_SCAN_STOPPED:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_SCAN_STOPPED\n");
break;
case IPC_EVENT_LINK_SPEED:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_LINK_SPEED\n");
break;
case IPC_EVENT_AUTH_SUCC:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_AUTH_SUCC\n");
break;
case IPC_EVENT_CCKM_START:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_CCKM_START\n");
break;
case IPC_EVENT_EAPOL:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_EAPOL\n");
break;
case IPC_EVENT_RE_AUTH_STARTED:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_RE_AUTH_STARTED\n");
break;
case IPC_EVENT_RE_AUTH_COMPLETED:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_RE_AUTH_COMPLETED\n");
break;
case IPC_EVENT_RE_AUTH_TERMINATED:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_RE_AUTH_TERMINATED\n");
break;
case IPC_EVENT_BOUND:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_BOUND\n");
break;
case IPC_EVENT_UNBOUND:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_UNBOUND\n");
break;
case IPC_EVENT_PREAUTH_EAPOL:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_PREAUTH_EAPOL\n");
break;
case IPC_EVENT_LOW_RSSI:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_LOW_RSSI\n");
break;
case IPC_EVENT_TSPEC_STATUS:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_TSPEC_STATUS\n");
OS_802_11_QOS_TSPEC_PARAMS* tspec = (OS_802_11_QOS_TSPEC_PARAMS*)pData;
os_error_printf(CU_MSG_ERROR, "CLI Event - IPC_EVENT_TSPEC_STATUS -- (ReasonCode = %d) \n",tspec->uReasonCode);
os_error_printf(CU_MSG_ERROR, "Tspec Parameters (as received through event handler):\n");
os_error_printf(CU_MSG_ERROR, "-----------------------------------------------------\n");
os_error_printf(CU_MSG_ERROR, "userPriority = %d\n",tspec->uUserPriority);
os_error_printf(CU_MSG_ERROR, "uNominalMSDUsize = %d\n",tspec->uNominalMSDUsize);
os_error_printf(CU_MSG_ERROR, "uMeanDataRate = %d\n",tspec->uMeanDataRate);
os_error_printf(CU_MSG_ERROR, "uMinimumPHYRate = %d\n",tspec->uMinimumPHYRate);
os_error_printf(CU_MSG_ERROR, "uSurplusBandwidthAllowance = %d\n",tspec->uSurplusBandwidthAllowance);
os_error_printf(CU_MSG_ERROR, "uAPSDFlag = %d\n",tspec->uAPSDFlag);
os_error_printf(CU_MSG_ERROR, "MinimumServiceInterval = %d\n",tspec->uMinimumServiceInterval);
os_error_printf(CU_MSG_ERROR, "MaximumServiceInterval = %d\n",tspec->uMaximumServiceInterval);
os_error_printf(CU_MSG_ERROR, "uMediumTime = %d\n\n",tspec->uMediumTime);
break;
case IPC_EVENT_TSPEC_RATE_STATUS:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_TSPEC_RATE_STATUS\n");
break;
case IPC_EVENT_MEDIUM_TIME_CROSS:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_MEDIUM_TIME_CROSS\n");
break;
case IPC_EVENT_ROAMING_COMPLETE:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_ROAMING_COMPLETE\n");
break;
case IPC_EVENT_EAP_AUTH_FAILURE:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_EAP_AUTH_FAILURE\n");
break;
case IPC_EVENT_WPA2_PREAUTHENTICATION:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_WPA2_PREAUTHENTICATION\n");
break;
case IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED:
{
U32 *crossInfo = (U32 *)pData;
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED\n");
os_error_printf(CU_MSG_ERROR, (PS8)"Threshold(High=0, Low=1) crossed= %d\n", crossInfo[0]);
os_error_printf(CU_MSG_ERROR, (PS8)"Direction(Above=0, Below=1) crossed= %d\n", crossInfo[1]);
break;
}
case IPC_EVENT_SCAN_FAILED:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_SCAN_FAILED\n");
break;
case IPC_EVENT_WPS_SESSION_OVERLAP:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_WPS_SESSION_OVERLAP\n");
break;
case IPC_EVENT_RSSI_SNR_TRIGGER:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_RSSI_SNR_TRIGGER (index = %d), Data = %d\n", (S8)(*(pData + 2) - 1),(S8)(*pData));
break;
case IPC_EVENT_TIMEOUT:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_TIMEOUT\n");
break;
case IPC_EVENT_GWSI:
os_error_printf(CU_MSG_ERROR, (PS8)"IpcEvent_PrintEvent - received IPC_EVENT_GWSI\n");
break;
case IPC_EVENT_LOGGER:
#ifdef ETH_SUPPORT
ProcessLoggerMessage(pData, (U16)DataLen);
#endif
break;
default :
os_error_printf(CU_MSG_ERROR, (PS8)"**** Unknow EventId %d ****\n", EventId);
}
}
}
