/*
* osapi.c
*
* Copyright 2001-2009 Texas Instruments, Inc. - http://www.ti.com/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/****************************************************************************
*
* MODULE: osapi.c
*
* PURPOSE:
*
* DESCRIPTION:
* ============
* OS Memory API for user mode application (CUDK)
*
****************************************************************************/
/* includes */
/************/
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include "cu_os.h"
#include "cu_osapi.h"
/* defines */
/***********/
#define MAX_HOST_MESSAGE_SIZE 512
S32 ipc_pipe[2];
extern S32 user_main (S32 argc, PPS8 argv);
/**
* \fn main
* \brief Main entry point to a user-mode program
*
* This is the main() function for a user mode program, or the entry point
* called by the OS, This calls an OS-abstracted main function
*
* \param argc - command line argument count
* \param argv - command line arguments
* \return 0 on success, any other value indicates error
* \sa user_main
*/
int main (int argc, char** argv)
{
return user_main (argc, (PPS8)argv);
}
/****************************************************************************************
* os_error_printf()
****************************************************************************************
DESCRIPTION: This function prints a debug message
ARGUMENTS: OsContext - our adapter context.
arg_list - string to output with arguments
RETURN: None
*****************************************************************************************/
VOID os_error_printf(S32 debug_level, const PS8 arg_list ,...)
{
static int g_debug_level = CU_MSG_ERROR; /* TODO ronen: create debug logic for CLI */
S8 msg[MAX_HOST_MESSAGE_SIZE];
va_list ap;
#ifdef OS_CLI_LOG_TO_FILE
char file_name[30]="/cli.log";
FILE *ftmp;
#endif
if (debug_level < g_debug_level)
return;
/* Format the message */
va_start(ap, arg_list);
vsprintf((char *)msg, (char *)arg_list, ap);
va_end(ap);
/* print the message */
fprintf(stderr, (char *)msg);
#ifdef OS_CLI_LOG_TO_FILE
ftmp = fopen(file_name, "a");
if (ftmp != NULL) {
fprintf(ftmp,(char *)msg);
fclose(ftmp);
}
#endif
}
/****************************************************************************************
* os_strcpy()
****************************************************************************************
DESCRIPTION: wrapper to the OS strcpy fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
inline PS8 os_strcpy(PS8 dest, const PS8 src)
{
return (PS8)strcpy((char*)dest, (char*)src);
}
/****************************************************************************************
* os_strncpy()
****************************************************************************************
DESCRIPTION: wrapper to the OS strncpy fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
PS8 os_strncpy(PS8 dest, const PS8 src, S32 n)
{
return (PS8)strncpy((char*)dest, (char*)src, n);
}
/****************************************************************************************
* os_sprintf()
****************************************************************************************
DESCRIPTION: wrapper to the OS sprintf fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
S32 os_sprintf(PS8 str, const PS8 arg_list, ...)
{
va_list ap;
S8 msg[MAX_HOST_MESSAGE_SIZE];
va_start(ap, arg_list);
vsprintf((char*)msg, (char*)arg_list, ap);
va_end(ap);
return sprintf((char*)str, (char*)msg);
}
/****************************************************************************************
* os_Printf()
****************************************************************************************
DESCRIPTION: wrapper to the OS printf fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
S32 os_Printf(const PS8 buffer)
{
return printf((char*)buffer);
}
/****************************************************************************************
* os_strcat()
****************************************************************************************
DESCRIPTION: wrapper to the OS strcat fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
PS8 os_strcat(PS8 dest, const PS8 src)
{
return (PS8)strcat((char*)dest, (char*)src);
}
/****************************************************************************************
* os_strlen()
****************************************************************************************
DESCRIPTION: wrapper to the OS strlen fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
U32 os_strlen(const PS8 s)
{
return strlen((char*)s);
}
/****************************************************************************************
* os_memoryCAlloc()
****************************************************************************************
DESCRIPTION: Allocates an array in memory with elements initialized to 0.
ARGUMENTS: OsContext - our adapter context.
Number - Number of elements
Size - Length in bytes of each element
RETURN: Pointer to the allocated memory.
*****************************************************************************************/
PVOID os_MemoryCAlloc(U32 Number, U32 Size)
{
return calloc(Number, Size);
}
/****************************************************************************************
* os_memoryAlloc()
****************************************************************************************
DESCRIPTION: Allocates resident (nonpaged) system-space memory.
ARGUMENTS: OsContext - our adapter context.
Size - Specifies the size, in bytes, to be allocated.
RETURN: Pointer to the allocated memory.
*****************************************************************************************/
PVOID os_MemoryAlloc(U32 Size)
{
return malloc(Size);
}
/****************************************************************************************
* os_memoryFree()
****************************************************************************************
DESCRIPTION: This function releases a block of memory previously allocated with the
os_memoryAlloc function.
ARGUMENTS: OsContext - our adapter context.
pMemPtr - Pointer to the base virtual address of the allocated memory.
This address was returned by the os_memoryAlloc function.
Size - Redundant, needed only for kernel mode.
RETURN: None
*****************************************************************************************/
VOID os_MemoryFree(PVOID pMemPtr)
{
free(pMemPtr);
}
/****************************************************************************************
* os_memset()
****************************************************************************************
DESCRIPTION: wrapper to the OS memset fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
PVOID os_memset(PVOID s, U8 c, U32 n)
{
return memset(s, c, n);
}
/****************************************************************************************
* os_memcpy()
****************************************************************************************
DESCRIPTION: wrapper to the OS memcpy fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
PVOID os_memcpy(PVOID dest, const PVOID src, U32 n)
{
return memcpy(dest, src, n);
}
/****************************************************************************************
* os_memcmp()
****************************************************************************************
DESCRIPTION: wrapper to the OS memcmp fucntion
ARGUMENTS:
RETURN:
*****************************************************************************************/
S32 os_memcmp(const PVOID s1, const PVOID s2, S32 n)
{
return memcmp(s1, s2, n);
}
/************************************************************************
* os_strcmp *
************************************************************************
DESCRIPTION: wrapper to the OS strcmp fucntion
CONTEXT:
************************************************************************/
S32 os_strcmp(const PS8 s1, const PS8 s2)
{
return strcmp((char*)s1,(char*)s2);
}
/************************************************************************
* os_strncmp *
************************************************************************
DESCRIPTION: wrapper to the OS strcmp fucntion
CONTEXT:
************************************************************************/
S32 os_strncmp(const PS8 s1, const PS8 s2, U32 n)
{
return strncmp((char*)s1,(char*)s2,n);
}
/************************************************************************
* os_sscanf *
************************************************************************
DESCRIPTION: wrapper to the OS sscanf fucntion
CONTEXT:
************************************************************************/
S32 os_sscanf(const PS8 str, const PS8 arg_list, ...)
{
va_list ap;
S8 msg[MAX_HOST_MESSAGE_SIZE];
va_start(ap, arg_list);
vsprintf((char*)msg, (char*)arg_list, ap);
va_end(ap);
return sscanf((char*)str, (char*)msg);
}
/************************************************************************
* os_strchr *
************************************************************************
DESCRIPTION: wrapper to the OS strchr fucntion
CONTEXT:
************************************************************************/
PS8 os_strchr(const PS8 s, S32 c)
{
return (PS8)strchr((char*)s,c);
}
/************************************************************************
* os_strtol *
************************************************************************
DESCRIPTION: wrapper to the OS strtol fucntion
CONTEXT:
************************************************************************/
S32 os_strtol(const PS8 nptr, PPS8 endptr, S32 base)
{
return strtol((char*)nptr, (char**)endptr, base);
}
/************************************************************************
* os_strtoul *
************************************************************************
DESCRIPTION: wrapper to the OS strtoul fucntion
CONTEXT:
************************************************************************/
U32 os_strtoul(const PS8 nptr, PPS8 endptr, S32 base)
{
return strtoul((char*)nptr, (char**)endptr, base);
}
/************************************************************************
* os_tolower *
************************************************************************
DESCRIPTION: wrapper to the OS tolower fucntion
CONTEXT:
************************************************************************/
S32 os_tolower(S32 c)
{
return tolower(c);
}
/************************************************************************
* os_tolower *
************************************************************************
DESCRIPTION: wrapper to the OS tolower fucntion
CONTEXT:
************************************************************************/
S32 os_isupper(S32 c)
{
return isupper(c);
}
/************************************************************************
* os_tolower *
************************************************************************
DESCRIPTION: wrapper to the OS tolower fucntion
CONTEXT:
************************************************************************/
S32 os_toupper(S32 c)
{
return toupper(c);
}
/************************************************************************
* os_atoi *
************************************************************************
DESCRIPTION: wrapper to the OS atoi fucntion
CONTEXT:
************************************************************************/
S32 os_atoi(const PS8 str)
{
return (S32)atoi(str);
}
/************************************************************************
* os_fopen *
************************************************************************
DESCRIPTION: wrapper to the OS fopen fucntion
CONTEXT:
************************************************************************/
PVOID os_fopen(const PS8 path, os_fopen_mode_e mode)
{
switch(mode)
{
case OS_FOPEN_READ:
return fopen((char*)path, "r");
case OS_FOPEN_READ_BINARY:
return fopen((char*)path, "rb");
case OS_FOPEN_WRITE:
return fopen(path, "w");
case OS_FOPEN_WRITE_BINARY:
return fopen(path, "wb");
default:
return NULL;
}
}
/************************************************************************
* 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;
}
/************************************************************************
* os_fgets *
************************************************************************
DESCRIPTION: wrapper to the OS fgets fucntion
CONTEXT:
************************************************************************/
inline PS8 os_fgets(PS8 s, S32 size, PVOID stream)
{
return (PS8)fgets((char*)s, size, stream);
}
/************************************************************************
* os_fread *
************************************************************************
DESCRIPTION: wrapper to the OS fread fucntion
CONTEXT:
************************************************************************/
inline S32 os_fread (PVOID ptr, S32 size, S32 nmemb, PVOID stream)
{
return fread (ptr, size, nmemb, stream);
}
/************************************************************************
* os_fwrite *
************************************************************************
DESCRIPTION: wrapper to the OS fwrite fucntion
CONTEXT:
************************************************************************/
S32 os_fwrite (PVOID ptr, S32 size, S32 nmemb, PVOID stream)
{
return fwrite (ptr, size, nmemb, stream);
}
/************************************************************************
* os_fclose *
************************************************************************
DESCRIPTION: wrapper to the OS fclose fucntion
CONTEXT:
************************************************************************/
inline S32 os_fclose(PVOID stream)
{
return fclose(stream);
}
/************************************************************************
* 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 ) == NULL )
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");
}
VOID os_OsSpecificCmdParams(S32 argc, PS8* argv)
{
}
VOID os_InitOsSpecificModules(VOID)
{
}
VOID os_DeInitOsSpecificModules(VOID)
{
}
TI_SIZE_T os_get_last_error()
{
return errno;
}