static void EsifDataLogFire(int isHeader)
{
int i = 0;
char outLine[MAX_LOG_LINE] = { 0 };
EsifLogType logtype = ESIF_LOG_UI;
time_t now = time(NULL);
struct tm time = { 0 };
esif_ccb_time_t msec = 0;
esif_ccb_system_time(&msec);
if (isHeader > 0) {
esif_ccb_sprintf(MAX_LOG_LINE, outLine, "Time,Server Msec,");
}
else {
if (esif_ccb_localtime(&time, &now) == 0) {
esif_ccb_sprintf(MAX_LOG_LINE, outLine, "%04d-%02d-%02d %02d:%02d:%02d,%llu,",
time.tm_year + 1900, time.tm_mon + 1, time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec, msec);
}
}
for (i = 0; i < MAX_PARTICIPANT_ENTRY; i++) {
eEsifError rc = ESIF_OK;
DataLogParticipant currentParticipant = g_dataLogParticipants[i];
if (currentParticipant.participantNumFields > 0) {
rc = EsifDataLogAddParticipant(outLine, i, isHeader);
}
}
EsifLogFile_Write(logtype, "%s\n", outLine);
}
// backwards compatibility
eEsifError EsifConfigSet (
EsifDataPtr nameSpace,
EsifDataPtr path,
esif_flags_t flags,
EsifDataPtr value
)
{
eEsifError rc = ESIF_OK;
// Get the NameSpace or create it if it does not exist
DataVaultPtr DB = DataBank_GetNameSpace(g_DataBankMgr, (StringPtr)(nameSpace->buf_ptr));
if (!DB) {
struct esif_ccb_file dv_file = {0};
DB = DataBank_OpenNameSpace(g_DataBankMgr, (StringPtr)nameSpace->buf_ptr);
if (!DB) {
return ESIF_E_NOT_FOUND;
}
// esif_ccb_sprintf(MAX_PATH, dv_file.filename, "%s%s", esif_build_path(dv_file.filename, MAX_PATH, NULL, DB->name), ESIFDV_FILEEXT);
esif_ccb_sprintf(MAX_PATH, dv_file.filename, "%s%s%s", ESIFDV_DIR, DB->name, ESIFDV_FILEEXT);
IOStream_SetFile(DB->stream, dv_file.filename, "rb");
rc = DataVault_ReadVault(DB);
if (rc == ESIF_E_NOT_FOUND) {
rc = ESIF_OK;
}
}
if (rc == ESIF_OK) {
rc = DataVault_SetValue(DB, path, value, flags);
}
return rc;
}
// Automatically Load all Static DataVaults and *.dv files in the current folder into the DataBank
eEsifError DataBank_LoadDataVaults (DataBankPtr self)
{
eEsifError rc = ESIF_OK;
esif_ccb_file_find_handle find_handle = INVALID_HANDLE_VALUE;
char file_path[MAX_PATH] = {0};
char file_pattern[MAX_PATH] = {0};
struct esif_ccb_file *ffd_ptr;
UInt32 idx;
ASSERT(self);
// Import all Static DataVaults into ReadOnly DataVaults
for (idx = 0; g_StaticDataVaults[idx].name; idx++) {
DataVaultPtr DB = DataBank_OpenNameSpace(self, g_StaticDataVaults[idx].name);
if (DB) {
IOStream_SetMemory(DB->stream, g_StaticDataVaults[idx].buffer, g_StaticDataVaults[idx].buf_len);
DB->flags |= (ESIF_SERVICE_CONFIG_READONLY | ESIF_SERVICE_CONFIG_NOCACHE);
DataVault_ReadVault(DB);
}
}
// Create DataVault Directory if it doesn't exit
esif_build_path(file_path, sizeof(file_path), ESIF_PATHTYPE_DV, NULL, NULL);
esif_ccb_makepath(file_path);
// Import all matching *.dv files into ReadWrite DataVaults
esif_ccb_sprintf(MAX_PATH, file_pattern, "*%s", ESIFDV_FILEEXT);
ffd_ptr = (struct esif_ccb_file*)esif_ccb_malloc(sizeof(*ffd_ptr));
if (NULL == ffd_ptr) {
rc = ESIF_E_NO_MEMORY;
}
if (rc == ESIF_OK) {
find_handle = esif_ccb_file_enum_first(file_path, file_pattern, ffd_ptr);
}
if (INVALID_HANDLE_VALUE != find_handle) {
do {
struct esif_ccb_file dv_file = {0};
DataVaultPtr DB = 0;
// Read DataVault File, unless it's already been loaded as a Static DataVault
if (esif_ccb_strlen(ffd_ptr->filename, MAX_PATH) > sizeof(ESIFDV_FILEEXT)) {
ffd_ptr->filename[esif_ccb_strlen(ffd_ptr->filename, MAX_PATH) - (sizeof(ESIFDV_FILEEXT) - 1)] = 0; // Truncate ".dv" extension
if (DataBank_GetNameSpace(self, ffd_ptr->filename) == NULL) {
DB = DataBank_OpenNameSpace(self, ffd_ptr->filename);
if (DB) {
esif_build_path(dv_file.filename, sizeof(dv_file.filename), ESIF_PATHTYPE_DV, DB->name, ESIFDV_FILEEXT);
IOStream_SetFile(DB->stream, dv_file.filename, "rb");
DataVault_ReadVault(DB);
}
}
}
} while (esif_ccb_file_enum_next(find_handle, file_pattern, ffd_ptr));
esif_ccb_file_enum_close(find_handle);
}
esif_ccb_free(ffd_ptr);
return rc;
}
void esif_ws_server_set_ipaddr_port(const char *ipaddr, u32 portPtr, Bool restricted)
{
if (ipaddr == NULL) {
ipaddr = (restricted ? WEBSOCKET_RESTRICTED_IPADDR : WEBSOCKET_DEFAULT_IPADDR);
}
if (portPtr == 0) {
portPtr = atoi(restricted ? WEBSOCKET_RESTRICTED_PORT : WEBSOCKET_DEFAULT_PORT);
}
esif_ccb_strcpy(g_ws_ipaddr, ipaddr, sizeof(g_ws_ipaddr));
esif_ccb_sprintf(sizeof(g_ws_port), g_ws_port, "%d", portPtr);
g_ws_restricted = restricted;
}
void ipc_connect ()
{
g_ipc_handle = esif_ipc_connect((char*)SESSION_ID);
if (g_ipc_handle != ESIF_INVALID_HANDLE) {
char *kern_str = esif_cmd_info(g_out_buf);
ESIF_TRACE_DEBUG("ESIF IPC Kernel Device Opened\n");
if (NULL != kern_str) {
ESIF_TRACE_DEBUG("%s", kern_str);
esif_ccb_sprintf(sizeof(g_esif_kernel_version), g_esif_kernel_version, "%s", kern_str);
}
}
}
/* IPC OS Connect */
esif_handle_t esif_os_ipc_connect(char *session_id)
{
int fd = 0;
char device[MAX_PATH] = { 0 };
esif_ccb_sprintf(sizeof(device), device, "/dev/%s", IPC_DEVICE);
fd = open(device, O_RDWR);
ESIF_TRACE_DEBUG("linux_%s: session_id=%s device=%s handle=%d\n",
__func__, session_id, device, fd);
return fd;
}
static void esif_ws_http_send_error_code (
ClientRecordPtr connection,
int error_code
)
{
char buffer[MAX_PATH]={0};
char *message = (error_code==404 ? "Not Found" : "Error");
esif_ccb_sprintf(sizeof(buffer), buffer, (char*)"HTTP/1.1 %d %s\r\n\r\n<h1>%d %s</h1>", error_code, message, error_code, message);
send(connection->socket, buffer, (int)esif_ccb_strlen(buffer, sizeof(buffer)), ESIF_WS_SEND_FLAGS);
esif_ws_client_close_client(connection);
}
// Write to Transaction Log
// NOTE: This version is just a dumb text log, not a recoverable transaction log
//
static void DataVault_WriteLog (
DataVaultPtr self,
esif_string action,
esif_string nameSpace,
EsifDataPtr path,
esif_flags_t flags,
EsifDataPtr value
)
{
#ifdef ESIF_CONFIG_LOG
UNREFERENCED_PARAMETER(self);
UNREFERENCED_PARAMETER(action);
UNREFERENCED_PARAMETER(nameSpace);
UNREFERENCED_PARAMETER(path);
UNREFERENCED_PARAMETER(flags);
UNREFERENCED_PARAMETER(value);
#else
struct esif_ccb_file log_file = {0};
FILE *filePtr = NULL;
time_t now;
char theTime[30];
UNREFERENCED_PARAMETER(self);
if (!flags) {
return;
}
esif_ccb_sprintf(MAX_PATH, log_file.filename, "%s%s", esif_build_path(log_file.filename, MAX_PATH, ESIF_DIR_LOG, (EsifString)nameSpace), ESIFDV_LOGFILEEXT);
esif_ccb_fopen(&filePtr, log_file.filename, "ab");
if (NULL == filePtr) {
return;
}
time(&now);
esif_ccb_ctime(theTime, sizeof(theTime), &now);
esif_ccb_fprintf(filePtr, "%.24s: %-6s %s flags=%d",
theTime,
action,
(EsifString)path->buf_ptr,
flags);
if (NULL != value) {
UInt32 ch;
esif_ccb_fprintf(filePtr, " type=%d buf_len=%d data_len=%d buf_ptr=%s", value->type, value->buf_len, value->data_len, (value->buf_ptr ? "0x" : "NULL"));
for (ch = 0; NULL != value->buf_ptr && ch < value->data_len; ch++)
esif_ccb_fprintf(filePtr, "%02X", (int)((UInt8*)(value->buf_ptr))[ch]);
}
esif_ccb_fprintf(filePtr, "\r\n");
fclose(filePtr);
#endif
}
static void esif_ws_http_send_error_code (
int fd,
int error_code
)
{
char buffer[BUFFER_LENGTH];
error_code = error_code;
(void)esif_ccb_sprintf(BUFFER_LENGTH, buffer, (char*)"HTTP/1.1 404 Not Found\r\n\r\n");
(void)send(fd, buffer, (int)esif_ccb_strlen(buffer, MAX_SIZE), 0);
esif_uf_ccb_sock_close(fd);
}
static eEsifError GetPrompt(
EsifAppMgr *THIS,
EsifDataPtr promptPtr
)
{
enum esif_rc rc = ESIF_OK;
EsifAppPtr a_app_ptr = THIS->fSelectedAppPtr;
if (NULL == a_app_ptr) {
esif_ccb_sprintf(promptPtr->buf_len, (esif_string)promptPtr->buf_ptr, "esif(%u)->", g_dst);
} else {
ESIF_DATA(data_prompt, ESIF_DATA_STRING, promptPtr->buf_ptr, promptPtr->buf_len);
rc = a_app_ptr->fInterface.fAppGetPromptFuncPtr(a_app_ptr->fHandle, &data_prompt);
}
return rc;
}
// IPC Connect
eEsifError ipc_connect()
{
eEsifError rc = ESIF_OK;
int check_kernel_version = ESIF_TRUE;
ESIF_TRACE_ENTRY_INFO();
// Exit if IPC already connected
if (g_ipc_handle != ESIF_INVALID_HANDLE) {
return ESIF_OK;
}
// Connect to LF
g_ipc_handle = esif_ipc_connect((char *)SESSION_ID);
if (g_ipc_handle == ESIF_INVALID_HANDLE) {
ESIF_TRACE_WARN("ESIF LF is not available\n");
rc = ESIF_E_NO_LOWER_FRAMEWORK;
}
else {
char *outbuf = esif_ccb_malloc(OUT_BUF_LEN);
char *kern_str = (outbuf != NULL ? esif_cmd_info(outbuf) : NULL);
ESIF_TRACE_DEBUG("ESIF IPC Kernel Device Opened\n");
if (NULL != kern_str) {
// Extract just the Kernel LF Version from the result string
extract_kernel_version(kern_str, OUT_BUF_LEN);
// Bypass Kernel Version check for DEBUG builds
#if defined(ESIF_ATTR_DEBUG)
check_kernel_version = ESIF_FALSE;
#endif
// Validate Kernel LF version is compatible with UF version
if (check_kernel_version == ESIF_FALSE || esif_ccb_strcmp(kern_str, ESIF_VERSION) == 0) {
ESIF_TRACE_INFO("Kernel Version: %s\n", kern_str);
esif_ccb_sprintf(sizeof(g_esif_kernel_version), g_esif_kernel_version, "%s", kern_str);
}
else {
ESIF_TRACE_ERROR("ESIF_LF Version (%s) Incompatible with ESIF_UF Version (%s)\n", kern_str, ESIF_VERSION);
ipc_disconnect();
rc = ESIF_E_NOT_SUPPORTED;
}
}
esif_ccb_free(outbuf);
}
ESIF_TRACE_EXIT_INFO_W_STATUS(rc);
return rc;
}
static void esif_ws_http_send_401 (int fd)
{
char buffer[256];
char tmpbuffer[128];
char *fileType = "text/html";
FILE *file_fp = NULL;
int len;
struct stat st;
int ret;
char *fileName = "error.html";
printf("fileName :%s\n", fileName);
esif_ccb_fopen(&file_fp, fileName, "r");
if (NULL == file_fp) {
printf("failed to open file: \n");
return;
}
if (esif_ccb_stat(fileName, &st) != 0) {
printf("Could not stat file descriptor \n");
return;
}
len = (long)fseek(file_fp, (off_t)0, SEEK_END);
(void)fseek(file_fp, (off_t)0, SEEK_SET);
(void)esif_ccb_sprintf(256, buffer, (char*)"HTTP/1.1 401 Unauthorized\n"
"Server: server/%d.0\nLast-Modified: %s\nDate: %s\n"
"Content-Type: %s\nContent-Length: %ld\nConnection: close\n\n",
VERSION, esif_ws_http_time_stamp(st.st_mtime, tmpbuffer), esif_ws_http_time_stamp(time(0), tmpbuffer), fileType, (long)st.st_size);
(void)send(fd, buffer, (int)esif_ccb_strlen(buffer), 0);
while ((ret = (int)fread(buffer, 1, 256, file_fp)) > 0)
(void)send(fd, buffer, ret, 0);
fclose(file_fp);
}
eEsifError EsifActStart (EsifActPtr actionPtr)
{
eEsifError rc = ESIF_OK;
GetIfaceFuncPtr iface_func_ptr = NULL;
EsifString iface_func_name = "GetActionInterface";
char libPath[ESIF_LIBPATH_LEN];
esif_lib_t lib_handle = 0;
ESIF_TRACE_DEBUG("%s name=%s\n", ESIF_FUNC, actionPtr->fLibNamePtr);
esif_ccb_sprintf(ESIF_LIBPATH_LEN, libPath, "%s.%s",
esif_build_path(libPath, ESIF_LIBPATH_LEN, ESIF_DIR_PRG, actionPtr->fLibNamePtr), ESIF_LIB_EXT);
lib_handle = esif_ccb_library_load(libPath);
if (0 == lib_handle) {
rc = ESIF_E_UNSPECIFIED;
ESIF_TRACE_DEBUG("%s esif_ccb_library_load() %s failed.\n", ESIF_FUNC, libPath);
goto exit;
}
ESIF_TRACE_DEBUG("%s esif_ccb_library_load() %s completed.\n", ESIF_FUNC, libPath);
iface_func_ptr = (GetIfaceFuncPtr)
esif_ccb_library_get_func(lib_handle, (EsifString)iface_func_name);
if (NULL == iface_func_ptr) {
rc = ESIF_E_UNSPECIFIED;
ESIF_TRACE_DEBUG("%s esif_ccb_library_get_func() %s failed.\n",
ESIF_FUNC, iface_func_name);
goto exit;
}
ESIF_TRACE_DEBUG("%s esif_ccb_library_get_func() %s completed.\n",
ESIF_FUNC, iface_func_name);
rc = ActionCreate(actionPtr, iface_func_ptr);
ESIF_TRACE_DEBUG("%s ActionCreate completed.\n", ESIF_FUNC);
exit:
return rc;
}
static eEsifError EsifDataLogOpenLogFile()
{
eEsifError rc = ESIF_OK;
EsifLogType logtype = ESIF_LOG_UI;
char logname[35] = { 0 };
int append = ESIF_FALSE;
char fullpath[MAX_PATH] = { 0 };
time_t now = time(NULL);
struct tm time = { 0 };
if (esif_ccb_localtime(&time, &now) == 0) {
esif_ccb_sprintf(sizeof(logname), logname, "data_log_%04d-%02d-%02d-%02d%02d%02d.csv",
time.tm_year + 1900, time.tm_mon + 1, time.tm_mday, time.tm_hour, time.tm_min, time.tm_sec);
}
EsifLogFile_Open(logtype, logname, append);
EsifLogFile_GetFullPath(fullpath, sizeof(fullpath), logname);
if (!EsifLogFile_IsOpen(logtype)) {
rc = ESIF_E_IO_ERROR;
goto exit;
}
exit:
return rc;
}
static void esif_ws_cgi_redirect_output (
char *script,
int fd
)
{
int current_out;
char buffer[BUFFER_LENGTH];
int ret;
FILE *dataFile = NULL;
#define MAX_SIZE 100
printf("esif_ws_cgi_redirect_output-> full_script_name: %s\n", script);
current_out = esif_ccb_dup(1);
if (current_out == -1) {
perror("_dup( 1 ) failure");
exit(1);
}
esif_ccb_fopen(&dataFile, "data", "w");
if (NULL == dataFile) {
printf("failed to open file in writing mode \n");
return;
}
if (-1 == esif_ccb_dup2(dataFile, 1)) {
perror("Can't _dup2 stdout");
exit(1);
}
printf("Execute the script\n");
system(script);
fflush(stdout);
fclose(dataFile);
esif_ccb_dup3(current_out, 1);
esif_ccb_flushall();
esif_ccb_fopen(&dataFile, "data", "r");
if (NULL == dataFile) {
printf("failed to open file in readig mode: \n");
return;
}
(long)fseek(dataFile, (off_t)0, SEEK_END);
(void)fseek(dataFile, (off_t)0, SEEK_SET);
(void)esif_ccb_sprintf(BUFFER_LENGTH, buffer, (char*)"HTTP/1.1 200 OK\n");
(void)send(fd, buffer, (int)esif_ccb_strlen(buffer, MAX_SIZE), 0);
while ((ret = (int)fread(buffer, 1, BUFFER_LENGTH, dataFile)) > 0)
(void)send(fd, buffer, ret, 0);
fclose(dataFile);
esif_ws_server_initialize_clients();
esif_ws_http_set_login_requested(1);
esif_ws_http_set_authenticated(1);
}
EsifString EsifDspMgr_SelectDsp(
EsifDspQuery query
)
{
int i = 0; // Loop index for DSP table.
int weight = 0; // Total weight of DSP query
int primaryWeight = 0; // Weight of items sufficient for selection.
int secondaryWeight = 0; // Weight of items allowed to sway results, but cannot stand alone.
int heaviest = -1; // Heaviest Row Found.
EsifString dspNamePtr = NULL; // DSP Name/Code To Use.
int best = 0; // Best Weight Possible.
char *defaultDsp = GetDSPFromList(query.participantName); // Default DSP based on Participant Name
/*
** Query table for weighted match highest score wins. It is
** unlikely that the table would change but we lock it just
** to be sure it can't.
*/
// LOCK
esif_ccb_read_lock(&g_dm.lock);
for (i = 0; i < g_dm.dme_count; i++) {
EsifDspPtr dspPtr = g_dm.dme[i].dsp_ptr;
char busEnum[ENUM_TO_STRING_LEN] = { 0 };
if (dspPtr == NULL) {
continue;
}
esif_ccb_sprintf(ENUM_TO_STRING_LEN, busEnum, "%d", *dspPtr->bus_enum);
// Primary weight indicates items that can result in a match
primaryWeight =
compare_and_weight_minterm(dspPtr->device_id, query.deviceId, PCI_DEVICE_ID_WEIGHT) +
compare_and_weight_minterm(dspPtr->acpi_device, query.hid, ACPI_HID_WEIGHT) +
compare_and_weight_minterm(dspPtr->acpi_type, query.ptype, ACPI_PTYPE_WEIGHT) +
compare_and_weight_minterm(dspPtr->code_ptr, defaultDsp, PARTICIPANT_NAME_WEIGHT);
// Secondary items can contribute only if at least one primary match is found
secondaryWeight =
compare_and_weight_minterm(dspPtr->acpi_uid, query.uid, ACPI_UID_WEIGHT) +
compare_and_weight_minterm(dspPtr->vendor_id, query.vendorId, PCI_VENDOR_ID_WEIGHT) +
compare_and_weight_minterm(busEnum, query.enumerator, ENUMERATOR_TYPE_WEIGHT);
// Items in secondary can weigh in on the results but cannot be the sole factor
if (primaryWeight < MIN_VIABLE_DSP_WEIGHT) {
weight = primaryWeight;
}
else {
weight = primaryWeight + secondaryWeight;
}
ESIF_TRACE_DEBUG("DSP: %s Weight: %d\n", (esif_string) dspPtr->code_ptr, weight);
//Keep track of row with most weight.
if (weight > heaviest) {
heaviest = weight;
dspNamePtr = dspPtr->code_ptr;
}
}
// UNLOCK
esif_ccb_read_unlock(&g_dm.lock);
if (dspNamePtr != NULL) {
ESIF_TRACE_DEBUG("Selected DSP: %s Score: %d of %d\n", dspNamePtr, heaviest, best);
}
else {
ESIF_TRACE_ERROR("No DSP selected for %s. \n", query.participantName);
}
return dspNamePtr;
}
static int esif_ws_http_process_static_pages (
ClientRecordPtr connection,
char *buffer,
char *resource,
ssize_t ret,
char *fileType
)
{
struct stat st={0};
char tmpbuffer[128]={0};
char file_to_open[MAX_PATH]={0};
char content_disposition[MAX_PATH]={0};
FILE *file_fp = NULL;
esif_build_path(file_to_open, sizeof(file_to_open), ESIF_PATHTYPE_UI, resource, NULL);
esif_ccb_fopen(&file_fp, (esif_string)file_to_open, (esif_string)"rb");
// Log file workaround: If not found in HTML folder, look in LOG folder
if (NULL == file_fp) {
char logpath[MAX_PATH]={0};
esif_build_path(logpath, sizeof(logpath), ESIF_PATHTYPE_LOG, resource, NULL);
esif_ccb_fopen(&file_fp, (esif_string)logpath, (esif_string)"rb");
if (NULL != file_fp)
esif_ccb_strcpy(file_to_open, logpath, sizeof(file_to_open));
}
ESIF_TRACE_DEBUG("HTTP: file=%s, type=%s\n", file_to_open, fileType);
if (NULL == file_fp) {
ESIF_TRACE_DEBUG("failed to open file: %s\n", file_to_open);
return 404;
}
if (esif_ccb_stat(file_to_open, &st) != 0) {
ESIF_TRACE_DEBUG("Could not stat file descriptor \n");
fclose(file_fp);
return 404;
}
fseek(file_fp, (off_t)0, SEEK_END);
fseek(file_fp, (off_t)0, SEEK_SET);
// Add Content-Disposition header to prompt user with Save-As Dialog if unknown file type
if (esif_ccb_strcmp(fileType, UNKNOWN_MIME_TYPE) == 0) {
esif_ccb_sprintf(sizeof(content_disposition), content_disposition, "Content-Disposition: attachment; filename=\"%s\";\n", resource);
}
esif_ccb_sprintf(WS_BUFFER_LENGTH, buffer,
"HTTP/1.1 200 OK\n"
"Server: ESIF_UF/%s\n"
"Last-Modified: %s\n"
"Date: %s\n"
"Content-Type: %s\n"
"Content-Length: %ld\n"
"%s"
"Connection: close\n"
"\n",
ESIF_UF_VERSION,
esif_ws_http_time_stamp(st.st_mtime, tmpbuffer),
esif_ws_http_time_stamp(time(0), tmpbuffer),
fileType,
(long)st.st_size,
content_disposition);
send(connection->socket, buffer, (int)esif_ccb_strlen(buffer, WS_BUFFER_LENGTH), ESIF_WS_SEND_FLAGS);
while ((ret = (int)fread(buffer, 1, WS_BUFFER_LENGTH, file_fp)) > 0) {
send(connection->socket, buffer, (int)ret, ESIF_WS_SEND_FLAGS);
}
fclose(file_fp);
return 0;
}
int EsifTraceMessage(
esif_tracemask_t module,
int level,
const char *func,
const char *file,
int line,
const char *msg,
...)
{
int rc=0;
char *appname = "";
char *fmtDetail= "%s%s:[<%s>%s@%s#%d]<%llu ms>: ";
char *fmtInfo = "%s%s:[<%s>]<%llu ms>: ";
const char *sep=NULL;
size_t fmtlen=esif_ccb_strlen(msg, 0x7FFFFFFF);
int detailed_message = (level >= DETAILED_TRACELEVEL ? ESIF_TRUE : ESIF_FALSE);
va_list args;
esif_ccb_time_t msec = 0;
enum esif_tracemodule moduleid = ESIF_TRACEMODULE_DEFAULT;
const char *module_name = NULL;
esif_ccb_system_time(&msec);
while (module >>= 1)
moduleid++;
module_name = EsifTraceModule_ToString(moduleid);
level = esif_ccb_min(level, ESIF_TRACELEVEL_MAX);
level = esif_ccb_max(level, ESIF_TRACELEVEL_FATAL);
if ((sep = strrchr(file, *ESIF_PATH_SEP)) != NULL)
file = sep+1;
// Do not log function/file/line information for DPTF app interface messages logged from EsifSvcWriteLog
if (moduleid == ESIF_TRACEMODULE_DPTF) {
detailed_message = ESIF_FALSE;
}
if (g_traceinfo[level].routes & ESIF_TRACEROUTE_CONSOLE) {
if (detailed_message)
rc = CMD_CONSOLE(fmtDetail, appname, g_traceinfo[level].label, module_name, func, file, line, msec);
else
rc = CMD_CONSOLE(fmtInfo, appname, g_traceinfo[level].label, module_name, msec);
va_start(args, msg);
rc += EsifConsole_WriteConsole(msg, args);
va_end(args);
if (fmtlen && msg[fmtlen-1]!='\n')
CMD_CONSOLE("\n");
}
if (g_traceinfo[level].routes & ESIF_TRACEROUTE_LOGFILE && EsifLogFile_IsOpen(ESIF_LOG_TRACE)) {
time_t now=0;
char timestamp[MAX_CTIME_LEN]={0};
time(&now);
esif_ccb_ctime(timestamp, sizeof(timestamp), &now);
timestamp[20] = 0; // truncate year
if (detailed_message)
rc = EsifLogFile_Write(ESIF_LOG_TRACE, fmtDetail, timestamp + 4, g_traceinfo[level].label, module_name, func, file, line, msec);
else
rc = EsifLogFile_Write(ESIF_LOG_TRACE, fmtInfo, timestamp+4, g_traceinfo[level].label, module_name, msec);
va_start(args, msg);
rc += EsifLogFile_WriteArgsAppend(ESIF_LOG_TRACE, "\n", msg, args);
va_end(args);
}
#ifdef ESIF_ATTR_OS_WINDOWS
if (g_traceinfo[level].routes & (ESIF_TRACEROUTE_DEBUGGER)) {
size_t msglen=0;
char *buffer=0;
int offset=0;
va_start(args, msg);
msglen = esif_ccb_vscprintf(msg, args) + esif_ccb_strlen(g_traceinfo[level].label, MAX_PATH) + esif_ccb_strlen(appname, MAX_PATH) + esif_ccb_strlen(func, MAX_PATH) + esif_ccb_strlen(file, MAX_PATH) + esif_ccb_strlen(module_name, MAX_PATH) + 22;
va_end(args);
msglen += (detailed_message ? esif_ccb_strlen(fmtDetail, MAX_PATH) : esif_ccb_strlen(fmtInfo, MAX_PATH));
buffer = (char *)esif_ccb_malloc(msglen);
if (NULL != buffer) {
if (detailed_message)
rc = esif_ccb_sprintf(msglen, buffer, fmtDetail, appname, g_traceinfo[level].label, module_name, func, file, line, msec);
else
rc = esif_ccb_sprintf(msglen, buffer, fmtInfo, appname, g_traceinfo[level].label, module_name, msec);
offset = rc;
va_start(args, msg);
rc += esif_ccb_vsprintf(msglen-offset, buffer+offset, msg, args);
va_end(args);
if (rc && buffer[rc-1]!='\n')
esif_ccb_strcat(buffer, "\n", msglen);
OutputDebugStringA(buffer);
esif_ccb_free(buffer);
}
}
if (g_traceinfo[level].routes & (ESIF_TRACEROUTE_EVENTLOG)) {
size_t msglen=0;
char *buffer=0;
char *replaced=0;
int offset=0;
int backset=0;
WORD eventType;
appname = "";
fmtInfo = "%sESIF(%s) TYPE: %s MODULE: %s TIME %llu ms\n\n";
fmtDetail= "%sESIF(%s) TYPE: %s MODULE: %s FUNC: %s FILE: %s LINE: %d TIME: %llu ms\n\n";
backset = 0;
va_start(args, msg);
msglen = esif_ccb_vscprintf(msg,args) + esif_ccb_strlen(g_traceinfo[level].label, MAX_PATH) + esif_ccb_strlen(appname, MAX_PATH) + esif_ccb_strlen(func, MAX_PATH) + esif_ccb_strlen(file, MAX_PATH) + esif_ccb_strlen(module_name, MAX_PATH) + 32;
va_end(args);
msglen += (detailed_message ? esif_ccb_strlen(fmtDetail, MAX_PATH) : esif_ccb_strlen(fmtInfo, MAX_PATH));
buffer = (char *)esif_ccb_malloc(msglen);
if (NULL != buffer) {
if (detailed_message)
rc = esif_ccb_sprintf(msglen, buffer, fmtDetail, appname, ESIF_UF_VERSION, g_traceinfo[level].label, module_name, func, file, line, msec);
else
rc = esif_ccb_sprintf(msglen, buffer, fmtInfo, appname, ESIF_UF_VERSION, g_traceinfo[level].label, module_name, msec);
if (backset && backset < rc)
buffer[rc-backset-1] = 0;
offset = rc-backset;
va_start(args, msg);
rc += esif_ccb_vsprintf(msglen-(offset+backset), buffer+offset+backset, msg, args);
va_end(args);
if (rc && buffer[rc-1]=='\n')
buffer[--rc] = 0;
switch (g_traceinfo[level].level) {
case ESIF_TRACELEVEL_FATAL:
case ESIF_TRACELEVEL_ERROR:
eventType = EVENTLOG_ERROR_TYPE;
break;
case ESIF_TRACELEVEL_WARN:
eventType = EVENTLOG_WARNING_TYPE;
break;
case ESIF_TRACELEVEL_INFO:
case ESIF_TRACELEVEL_DEBUG:
default:
eventType = EVENTLOG_INFORMATION_TYPE;
break;
}
// Escape any "%" in message before writing to EventLog
if ((replaced = esif_str_replace(buffer, "%", "%%")) != NULL) {
esif_ccb_free(buffer);
buffer = replaced;
replaced = NULL;
}
report_event_to_event_log(CATEGORY_GENERAL, eventType, buffer);
esif_ccb_free(buffer);
}
}
#endif
#ifdef ESIF_ATTR_OS_LINUX
if (g_traceinfo[level].routes & (ESIF_TRACEROUTE_EVENTLOG|ESIF_TRACEROUTE_DEBUGGER)) {
size_t msglen=0;
char *buffer=0;
int offset=0;
int priority;
fmtDetail= "%s:[<%s>%s@%s#%d]<%llu ms>: ";
fmtInfo = "%s:[<%s>]<%llu ms>: ";
va_start(args, msg);
msglen = esif_ccb_vscprintf(msg,args) + esif_ccb_strlen(g_traceinfo[level].label, MAX_PATH) + esif_ccb_strlen(func, MAX_PATH) + esif_ccb_strlen(file, MAX_PATH) + esif_ccb_strlen(module_name, MAX_PATH) + 22;
va_end(args);
msglen += (detailed_message ? esif_ccb_strlen(fmtDetail, MAX_PATH) : esif_ccb_strlen(fmtInfo, MAX_PATH));
buffer = (char *)esif_ccb_malloc(msglen);
if (NULL != buffer) {
char *lf;
if (detailed_message)
rc = esif_ccb_sprintf(msglen, buffer, fmtDetail, g_traceinfo[level].label, module_name, func, file, line, msec);
else
rc = esif_ccb_sprintf(msglen, buffer, fmtInfo, g_traceinfo[level].label, module_name, msec);
offset = rc;
va_start(args, msg);
rc += esif_ccb_vsprintf(msglen-offset, buffer+offset, msg, args);
va_end(args);
if (rc && buffer[rc-1]=='\n')
buffer[--rc] = 0;
while ((lf = esif_ccb_strchr(buffer, '\n')) != NULL)
*lf = '\t';
switch (g_traceinfo[level].level) {
case ESIF_TRACELEVEL_FATAL:
priority = ESIF_PRIORITY_FATAL;
break;
case ESIF_TRACELEVEL_ERROR:
priority = ESIF_PRIORITY_ERROR;
break;
case ESIF_TRACELEVEL_WARN:
priority = ESIF_PRIORITY_WARNING;
break;
case ESIF_TRACELEVEL_INFO:
priority = ESIF_PRIORITY_INFO;
break;
case ESIF_TRACELEVEL_DEBUG:
default:
priority = ESIF_PRIORITY_DEBUG;
break;
}
#ifdef ESIF_ATTR_OS_ANDROID
__android_log_write(priority, IDENT, buffer);
#else
openlog(IDENT, OPTION, FACILITY);
syslog(priority, "%s", buffer);
closelog();
#endif
esif_ccb_free(buffer);
}
}
#endif
return rc;
}
//
// PUBLIC INTERFACE---------------------------------------------------------------------
//
char *EsifShellCmdDataLog(EsifShellCmdPtr shell)
{
eEsifError rc = ESIF_OK;
int argc = shell->argc;
char **argv = shell->argv;
char *output = shell->outbuf;
char participantList[MAX_LOG_LINE] = { 0 };
/*
* Serialize access to the datalog state.
*/
while (atomic_set(&g_dataLogLock, ESIF_TRUE)) {
esif_ccb_sleep_msec(ESIF_DATALOG_LOCK_SLEEP_MS);
}
if (argc < 2) {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging is: %s\n", (EsifDataIsLogStarted() ? "started" : "stopped"));
}
else if (esif_ccb_stricmp(argv[1], "start") == 0) {
if (EsifDataIsLogStarted()){
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging is already started.\n");
goto exit;
}
g_dataLogInterval = DEFAULT_STATUS_LOG_INTERVAL;
if (argc > 2) {
if ((int)esif_atoi(argv[2]) >= MIN_STATUS_LOG_INTERVAL) {
g_dataLogInterval = (esif_ccb_time_t)esif_atoi(argv[2]);
}
else {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Invalid sampling period specified (minimum is %d ms).\n", MIN_STATUS_LOG_INTERVAL);
goto exit;
}
}
if (argc > 3) {
esif_ccb_sprintf(sizeof(participantList), participantList, "%s", argv[3]);
}
rc = EsifDataLogValidateParticipantList(participantList);
if (rc != ESIF_OK) {
esif_ccb_sprintf(OUT_BUF_LEN, output, "There was a problem with your participant list. You may have selected invalid participants, or too many participants. \n");
goto exit;
}
rc = EsifDataLogOpenLogFile();
if (rc != ESIF_OK) {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Error opening log file... \n");
goto exit;
}
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging starting... \n");
EsifDataLogStart();
}
else if (esif_ccb_stricmp(argv[1], "schedule") == 0) {
UInt32 startTime = 1000;
/* initialize */
if (dataLogContextPtr == NULL) {
dataLogContextPtr = (struct dataLogContext *)esif_ccb_malloc(sizeof(struct dataLogContext));
if (dataLogContextPtr == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
dataLogContextPtr->dataLogScheduleTimer = (esif_ccb_timer_t *) esif_ccb_malloc(sizeof(esif_ccb_timer_t));
if (dataLogContextPtr->dataLogScheduleTimer == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
dataLogContextPtr->dataLogParticipantList = NULL;
}
dataLogContextPtr->dataLogInterval = DEFAULT_STATUS_LOG_INTERVAL;
/* start time (in ms from now) */
if (argc > 2) {
if ((int) esif_atoi(argv[2]) >= MIN_STATUS_LOG_SCHEDULE) {
startTime = (esif_ccb_time_t) esif_atoi(argv[2]);
}
else {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Invalid schedule time specified (minimum is %d ms).\n", MIN_STATUS_LOG_INTERVAL);
goto exit;
}
}
/* log interval */
if (argc > 3) {
if ((int) esif_atoi(argv[3]) >= MIN_STATUS_LOG_INTERVAL) {
dataLogContextPtr->dataLogInterval = (esif_ccb_time_t) esif_atoi(argv[3]);
}
else {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Invalid sampling period specified (minimum is %d ms).\n", MIN_STATUS_LOG_INTERVAL);
goto exit;
}
}
if (argc > 4) {
dataLogContextPtr->dataLogParticipantList = esif_ccb_strdup(argv[4]);
if (dataLogContextPtr->dataLogParticipantList == NULL) {
rc = ESIF_E_NO_MEMORY;
goto exit;
}
}
rc = esif_ccb_timer_init(dataLogContextPtr->dataLogScheduleTimer, (esif_ccb_timer_cb) EsifDataLogSchedule, NULL);
if (ESIF_OK != rc) {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Error starting timer... \n");
goto exit;
}
rc = esif_ccb_timer_set_msec(dataLogContextPtr->dataLogScheduleTimer, startTime);
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging scheduled for start in %d ms at an interval of %d... \n", startTime, dataLogContextPtr->dataLogInterval);
}
else if (esif_ccb_stricmp(argv[1], "stop") == 0) {
EsifDataLogStop();
esif_ccb_sprintf(OUT_BUF_LEN, output, "Data logging stopped...\n");
g_dataLogActive = ESIF_FALSE;
}
else {
esif_ccb_sprintf(OUT_BUF_LEN, output, "Invalid parameter specified\n");
}
exit:
atomic_set(&g_dataLogLock, ESIF_FALSE);
return output;
}
static int esif_ws_http_server_static_pages (
char *buffer,
char *resource,
int fd,
ssize_t ret,
char *fileType
)
{
struct stat st;
char tmpbuffer[128];
char file_to_open[1000];
FILE *file_fp = NULL;
#define MAX_SIZE 200
esif_ccb_memcpy(file_to_open, g_server_root, esif_ccb_strlen(g_server_root, MAX_SIZE));
file_to_open[esif_ccb_strlen(g_server_root, MAX_SIZE)] = '\0';
// printf("file to open after esif_ccb_memcpy: %s\n", file_to_open);
// printf("resource : %s\n", resource);
#ifdef ESIF_ATTR_OS_WINDOWS
strcat_s((esif_string)file_to_open, 1000, resource);
esif_ccb_fopen(&file_fp, (esif_string)file_to_open, (esif_string)"rb");
#else
strcat((esif_string)file_to_open, resource);
esif_ccb_fopen(&file_fp, (esif_string)file_to_open, (esif_string)"r");
#endif
printf("file to open: %s\n", file_to_open);
printf("file type: %s\n", fileType);
if (NULL == file_fp) {
printf("failed to open file: %s\n", file_to_open);
return 404;
}
if (esif_ccb_stat(file_to_open, &st) != 0) {
printf("Could not stat file descriptor \n");
fclose(file_fp);
return 404;
}
(long)fseek(file_fp, (off_t)0, SEEK_END);
(void)fseek(file_fp, (off_t)0, SEEK_SET);
if (!strcmp(fileType, "text/xml")) {
(void)esif_ccb_sprintf(BUFFER_LENGTH, buffer, (char*)"HTTP/1.1 200 OK\n<?xml version==\"1.0\" encoding=\"utf-8\"?>\n"
"Server: server/%d.0\n"
"Content-Type: %s\nContent-Length: %ld\nConnection: close\n\n",
VERSION, fileType, (long)st.st_size);
} else {
(void)esif_ccb_sprintf(BUFFER_LENGTH, buffer, (char*)"HTTP/1.1 200 OK\n"
"Server: server/%d.0\nLast-Modified: %s\nDate: %s\n"
"Content-Type: %s\nContent-Length: %ld\nConnection: close\n\n",
VERSION,
esif_ws_http_time_stamp(st.st_mtime, tmpbuffer), esif_ws_http_time_stamp(time(0), tmpbuffer), fileType, (long)st.st_size);
}
(void)send(fd, buffer, (int)esif_ccb_strlen(buffer, MAX_SIZE), 0);
while ((ret = (int)fread(buffer, 1, BUFFER_LENGTH, file_fp)) > 0)
(void)send(fd, buffer, ret, 0);
fclose(file_fp);
return 0;
}
/*
* This function processes the socket when it is in the "opening" state
*/
static eEsifError esif_ws_client_open_client(
ClientRecordPtr clientPtr,
char *bufferPtr,
size_t bufferSize,
size_t messageLength
)
{
eEsifError result = ESIF_OK;
FrameType frameType;
size_t frameSize = 0;
ESIF_ASSERT(clientPtr->state == STATE_OPENING);
ESIF_ASSERT(messageLength > 0);
ESIF_TRACE_DEBUG("Socket in its opening state\n");
/*Determine the initial frame type: http frame type or websocket frame type */
frameType = esif_ws_socket_get_initial_frame_type(bufferPtr, messageLength, &clientPtr->prot);
if ((INCOMPLETE_FRAME == frameType) || (ERROR_FRAME == frameType)) {
if (INCOMPLETE_FRAME == frameType) {
ESIF_TRACE_DEBUG("Incomplete frame received\n");
} else {
ESIF_TRACE_DEBUG("Improper format for frame\n");
}
/*
* If the socket frame type is in error or is incomplete and happens to
* be in its opening state, send a message to the client that the request is bad
*/
frameSize = esif_ccb_sprintf(bufferSize,
(char*)bufferPtr,
"HTTP/1.1 400 Bad Request\r\n"
"Content-Type: text/html\r\n\r\n"
"<html>"
"<head></head>"
" <body>"
" ERROR: HTTP/1.1 400 Bad Request"
" </body>"
"</html>");
esif_ws_client_write_to_socket(clientPtr, bufferPtr, frameSize);
result = ESIF_E_WS_DISC;
goto exit;
}
if (OPENING_FRAME == frameType) {
if (esif_ws_socket_build_protocol_change_response(&clientPtr->prot, bufferPtr, bufferSize, &frameSize) != 0) {
ESIF_TRACE_DEBUG("Unable to build response header\n");
result = ESIF_E_WS_DISC;
goto exit;
}
if (esif_ws_client_write_to_socket(clientPtr, bufferPtr, frameSize) == EXIT_FAILURE) {
result = ESIF_E_WS_DISC;
goto exit;
}
/**************************** This is a now a websocket connection ****************************/
clientPtr->state = STATE_NORMAL;
}
if (HTTP_FRAME == frameType) {
result = esif_ws_http_process_reqs(clientPtr, g_ws_http_buffer, messageLength);
}
exit:
return result;
}
// Write DataVault to Disk
eEsifError DataVault_WriteVault (DataVaultPtr self)
{
eEsifError rc = ESIF_E_NOT_FOUND;
DataVaultHeader header;
struct esif_ccb_file dv_file = {0};
struct esif_ccb_file dv_filebak = {0};
IOStreamPtr vault = 0;
IOStreamPtr vaultBak = 0;
u32 idx;
if (FLAGS_TEST(self->flags, ESIF_SERVICE_CONFIG_STATIC | ESIF_SERVICE_CONFIG_READONLY)) {
return ESIF_E_READONLY;
}
// TODO: Locking
vault = IOStream_Create();
if (!vault) {
return ESIF_E_NO_MEMORY;
}
// If any rows contain NOCACHE PERSIST values, we need to make a copy the original DataVault while creating the new one
// esif_ccb_sprintf(MAX_PATH, dv_file.filename, "%s%s", esif_build_path(dv_file.filename, MAX_PATH, NULL, self->name), ESIFDV_FILEEXT);
esif_ccb_sprintf(MAX_PATH, dv_file.filename, "%s%s%s", ESIFDV_DIR, self->name, ESIFDV_FILEEXT);
for (idx = 0; idx < self->cache->size; idx++)
if (FLAGS_TESTALL(self->cache->elements[idx].flags, ESIF_SERVICE_CONFIG_NOCACHE | ESIF_SERVICE_CONFIG_PERSIST) &&
self->cache->elements[idx].value.buf_len == 0) {
struct stat filebak_stat = {0};
esif_ccb_sprintf(MAX_PATH, dv_filebak.filename, "%s%s%s", ESIFDV_DIR, self->name, ESIFDV_BAKFILEEXT);
// Delete BAK file if it exists
if (esif_ccb_stat(dv_filebak.filename, &filebak_stat) == 0) {
esif_ccb_unlink(dv_filebak.filename);
}
if (esif_ccb_rename(dv_file.filename, dv_filebak.filename) == 0) {
if ((vaultBak = IOStream_Create()) == NULL) {
rc = ESIF_E_NO_MEMORY;
}
if (!vaultBak || IOStream_OpenFile(vaultBak, dv_filebak.filename, "rb") != 0) {
IOStream_Destroy(vault);
IOStream_Destroy(vaultBak);
return rc;
}
}
break;
}
// Create DataVault, Overwrite if necessary
IOStream_SetFile(vault, self->stream->file.name, "wb");
if (IOStream_Open(vault) != 0) {
if (vaultBak) {
IOStream_Destroy(vaultBak);
esif_ccb_unlink(dv_filebak.filename);
}
IOStream_Destroy(vault);
return rc;
}
// Create File Header
memset(&header, 0, sizeof(header));
esif_ccb_memcpy(&header.signature, ESIFDV_SIGNATURE, sizeof(header.signature));
header.headersize = sizeof(header);
header.version = ESIFDV_VERSION(ESIFDV_MAJOR_VERSION, ESIFDV_MINOR_VERSION, ESIFDV_REVISION);
header.flags = 0; // TODO: get from self->flags
// Write File Header
IOStream_Seek(vault, 0, SEEK_SET);
IOStream_Write(vault, &header, sizeof(header));
rc = ESIF_OK;
// Write All Persisted Rows from Sorted List to DataVault
for (idx = 0; idx < self->cache->size; idx++) {
DataCacheEntryPtr keypair = &self->cache->elements[idx];
if (keypair->flags & ESIF_SERVICE_CONFIG_PERSIST) {
UInt8 *buffer = 0;
UInt32 buffer_len = 0;
UInt32 byte = 0;
IOStream_Write(vault, &keypair->flags, sizeof(keypair->flags));
IOStream_Write(vault, &keypair->key.data_len, sizeof(keypair->key.data_len));
IOStream_Write(vault, keypair->key.buf_ptr, keypair->key.data_len);
IOStream_Write(vault, &keypair->value.type, sizeof(keypair->value.type));
IOStream_Write(vault, &keypair->value.data_len, sizeof(keypair->value.data_len));
// Read NOCACHE Entries from Backup file
if (keypair->flags & ESIF_SERVICE_CONFIG_NOCACHE) {
size_t offset = IOStream_GetOffset(vault);
// Read Block from BAK file
if (keypair->value.buf_len == 0) {
size_t bakoffset = (size_t)keypair->value.buf_ptr;
buffer = (UInt8*)esif_ccb_malloc(keypair->value.data_len);
buffer_len = keypair->value.data_len;
if (!buffer) {
rc = ESIF_E_NO_MEMORY;
break;
}
if (IOStream_Seek(vaultBak, bakoffset, SEEK_SET) != 0 || IOStream_Read(vaultBak, buffer, buffer_len) != buffer_len) {
esif_ccb_free(buffer);
rc = ESIF_E_UNSPECIFIED;// TODO: ESIF_E_IOERROR;
break;
}
keypair->value.buf_ptr = (void*)offset;
}
// Convert internal storage to NOCACHE
else {
buffer = (UInt8*)keypair->value.buf_ptr;
buffer_len = keypair->value.data_len;
keypair->value.buf_ptr = (void*)offset;
keypair->value.buf_len = 0;
}
}
// Encrypt Data?
if (keypair->flags & ESIF_SERVICE_CONFIG_ENCRYPT) {
if (!buffer) {
buffer = (UInt8*)esif_ccb_malloc(keypair->value.data_len);
buffer_len = keypair->value.data_len;
if (!buffer) {
rc = ESIF_E_NO_MEMORY;
break;
}
}
for (byte = 0; byte < keypair->value.data_len; byte++)
buffer[byte] = ~((UInt8*)(keypair->value.buf_ptr))[byte];
}
if (buffer) {
IOStream_Write(vault, buffer, buffer_len);
esif_ccb_free(buffer);
} else {
IOStream_Write(vault, keypair->value.buf_ptr, keypair->value.data_len);
}
}
}
// Rollback on Error
if (rc != ESIF_OK) {
IOStream_Destroy(vaultBak);
IOStream_Destroy(vault);
esif_ccb_unlink(dv_file.filename);
IGNORE_RESULT(esif_ccb_rename(dv_filebak.filename, dv_file.filename));
return rc;
}
// Remove BAK file and Commit
if (vaultBak) {
IOStream_Close(vaultBak);
esif_ccb_unlink(dv_filebak.filename);
IOStream_Destroy(vaultBak);
}
IOStream_Close(vault);
IOStream_Destroy(vault);
return rc;
}
void esif_ws_server_execute_rest_cmd(
const char *dataPtr,
const size_t dataSize
)
{
char *command_buf = NULL;
if (atomic_read(&g_ws_quit))
return;
command_buf = strchr(dataPtr, ':');
if (NULL != command_buf) {
u32 msg_id = atoi(dataPtr);
*command_buf = 0;
command_buf++;
// Ad-Hoc UI Shell commands begin with "0:", so verify ESIF shell is enabled and command is valid
if (msg_id == 0 || g_ws_restricted) {
char *response = NULL;
if (msg_id == 0 && !g_shell_enabled) {
response = "Shell Disabled";
}
else {
static char *whitelist[] = { "status", "participants", NULL };
static char *blacklist[] = { "shell", "web", "exit", "quit", NULL };
Bool blocked = ESIF_FALSE;
int j = 0;
if (g_ws_restricted) {
for (j = 0; whitelist[j] != NULL; j++) {
if (esif_ccb_strnicmp(command_buf, whitelist[j], esif_ccb_strlen(whitelist[j], MAX_PATH)) == 0) {
break;
}
}
if (whitelist[j] == NULL) {
blocked = ESIF_TRUE;
}
}
else {
for (j = 0; blacklist[j] != NULL; j++) {
if (esif_ccb_strnicmp(command_buf, blacklist[j], esif_ccb_strlen(blacklist[j], MAX_PATH)) == 0) {
blocked = ESIF_TRUE;
break;
}
}
}
if (blocked) {
response = "Unsupported Command";
}
}
// Exit if shell or command unavailable
if (response) {
char buffer[MAX_PATH] = { 0 };
esif_ccb_sprintf(sizeof(buffer), buffer, "%d:%s", msg_id, response);
esif_ccb_free(g_rest_out);
g_rest_out = esif_ccb_strdup(buffer);
goto exit;
}
}
// Lock Shell so we can capture output before another thread executes another command
#ifdef ESIF_ATTR_SHELL_LOCK
esif_ccb_mutex_lock(&g_shellLock);
#endif
if (!atomic_read(&g_ws_quit)) {
EsifString cmd_results = esif_shell_exec_command(command_buf, dataSize, ESIF_TRUE);
if (NULL != cmd_results) {
size_t out_len = esif_ccb_strlen(cmd_results, OUT_BUF_LEN) + 12;
esif_ccb_free(g_rest_out);
g_rest_out = (EsifString) esif_ccb_malloc(out_len);
if (g_rest_out) {
esif_ccb_sprintf(out_len, g_rest_out, "%u:%s", msg_id, cmd_results);
}
}
}
#ifdef ESIF_ATTR_SHELL_LOCK
esif_ccb_mutex_unlock(&g_shellLock);
#endif
}
exit:
return;
}
// Automatically Load all Static DataVaults and *.dv files in the current folder into the DataBank
eEsifError DataBank_LoadDataVaults (DataBankPtr self)
{
eEsifError rc = ESIF_OK;
esif_ccb_file_find_handle find_handle;
esif_string file_path = 0;
char file_pattern[MAX_PATH];
char file_path_buf[MAX_PATH] = {0};
struct esif_ccb_file *ffd_ptr;
UInt32 idx;
ASSERT(self);
esif_ccb_lock_init(&self->lock);
// TODO: Locking
// Import all Static DataVaults into ReadOnly DataVaults
for (idx = 0; g_StaticDataVaults[idx].name; idx++) {
DataVaultPtr DB = DataBank_OpenNameSpace(self, g_StaticDataVaults[idx].name);
if (DB) {
IOStream_SetMemory(DB->stream, g_StaticDataVaults[idx].buffer, g_StaticDataVaults[idx].buf_len);
DB->flags |= (ESIF_SERVICE_CONFIG_READONLY | ESIF_SERVICE_CONFIG_NOCACHE);
DataVault_ReadVault(DB);
}
}
// Create ESIFDV_DIR if it doesn't exit (only 1 level deep for now)
esif_ccb_makepath(ESIFDV_DIR);
// Import all matching *.dv files into ReadWrite DataVaults
esif_ccb_strcpy(file_path_buf, ESIFDV_DIR, sizeof(file_path_buf));
file_path = file_path_buf;
esif_ccb_sprintf(MAX_PATH, file_pattern, "*%s", ESIFDV_FILEEXT);
ffd_ptr = (struct esif_ccb_file*)esif_ccb_malloc(sizeof(*ffd_ptr));
if (NULL == ffd_ptr) {
return ESIF_E_NO_MEMORY;
}
find_handle = esif_ccb_file_enum_first(file_path, file_pattern, ffd_ptr);
if (INVALID_HANDLE_VALUE == find_handle) {
rc = ESIF_OK; // No Persisted DataVaults found
} else {
do {
struct esif_ccb_file dv_file = {0};
DataVaultPtr DB = 0;
// Read DataVault File, unless it's already been loaded as a Static DataVault
if (esif_ccb_strlen(ffd_ptr->filename, MAX_PATH) > sizeof(ESIFDV_FILEEXT)) {
ffd_ptr->filename[esif_ccb_strlen(ffd_ptr->filename, MAX_PATH) - (sizeof(ESIFDV_FILEEXT) - 1)] = 0; // Truncate ".dv" extension
if (DataBank_GetNameSpace(self, ffd_ptr->filename) == NULL) {
DB = DataBank_OpenNameSpace(self, ffd_ptr->filename);
if (DB) {
esif_ccb_sprintf(MAX_PATH, dv_file.filename, "%s%s%s", file_path, DB->name, ESIFDV_FILEEXT);
IOStream_SetFile(DB->stream, dv_file.filename, "rb");
DataVault_ReadVault(DB);
}
}
}
} while (esif_ccb_file_enum_next(find_handle, file_pattern, ffd_ptr));
esif_ccb_file_enum_close(find_handle);
}
esif_ccb_free(ffd_ptr);
return rc;
}
