// vsprintf to an IString, starting at offset
int IString_VSprintfTo (
IStringPtr self,
u32 offset,
ZString format,
va_list args
)
{
u32 len;
int result = 0;
ESIF_ASSERT(self);
len = esif_ccb_vscprintf(format, args);
offset = (self->data_len > 0 ? esif_ccb_min(offset, self->data_len - 1) : 0);
if (offset + len + 1 > self->buf_len) {
#ifdef ISTRING_AUTOGROW
if (IString_Resize(self, offset + len + 1 + ISTRING_AUTOGROW) == NULL)
#endif
return 0;
}
result = esif_ccb_vsprintf(self->buf_len - offset, (ZString)self->buf_ptr + offset, format, args);
self->data_len = offset + result + 1;
return result;
}
// Read DataVault from Disk
eEsifError DataVault_ReadVault (DataVaultPtr self)
{
eEsifError rc = ESIF_E_UNSPECIFIED; // TODO
int vrc = EPERM;
DataVaultHeader header;
UInt32 min_version;
UInt32 max_version;
esif_flags_t item_flags;
IOStreamPtr vault = self->stream;
// TODO: Locking
// Open File or Memory Block
if ((vrc = IOStream_Open(vault)) != 0) {
if (vrc == ENOENT) {
rc = ESIF_E_NOT_FOUND;
}
return rc;
}
// Read and Verify File Header
// The DataVault's Major.Minor Version must be <= the App's Major.Minor Version and at least Major.0
memset(&header, 0, sizeof(header));
IOStream_Read(vault, &header, 4); // E51F#### where #### is header size, including this
IOStream_Read(vault, ((UInt8*)&header) + 4, esif_ccb_min(header.headersize, sizeof(header)) - 4);
min_version = ESIFDV_VERSION(ESIFDV_MAJOR_VERSION, 0, 0);
max_version = ESIFDV_VERSION(ESIFDV_MAJOR_VERSION, ESIFDV_MINOR_VERSION, ESIFDV_MAX_REVISION);
if (memcmp(header.signature, ESIFDV_SIGNATURE, sizeof(header.signature)) != 0 || header.version > max_version || header.version < min_version) {
IOStream_Close(vault);
return ESIF_E_NOT_SUPPORTED;
}
if (header.headersize > sizeof(header)) {
IOStream_Seek(vault, header.headersize - sizeof(header), SEEK_CUR);
}
self->flags = header.flags;
if (IOStream_GetType(vault) == StreamMemory) {
self->flags |= ESIF_SERVICE_CONFIG_STATIC;
}
rc = ESIF_OK;
// Read Data and add to DataVault
while (IOStream_Read(vault, &item_flags, sizeof(item_flags)) == sizeof(item_flags)) {
EsifData key;
EsifData value;
// Read Key
EsifData_ctor(&key);
EsifData_ctor(&value);
key.type = ESIF_DATA_STRING;
IOStream_Read(vault, &key.data_len, sizeof(key.data_len));
if (key.data_len > MAX_DV_DATALEN) {
rc = ESIF_E_PARAMETER_IS_OUT_OF_BOUNDS;
break;
}
switch (IOStream_GetType(vault)) {
case StreamMemory:
key.buf_len = 0;
key.buf_ptr = IOStream_GetMemoryBuffer(vault) + IOStream_GetOffset(vault);
IOStream_Seek(vault, key.data_len, SEEK_CUR);
item_flags &= ~ESIF_SERVICE_CONFIG_NOCACHE; // ignore for Memory Vaults
break;
case StreamFile:
default:
key.buf_len = key.data_len;
key.buf_ptr = esif_ccb_malloc(key.buf_len);
if (!key.buf_ptr) {
rc = ESIF_E_NO_MEMORY;
break;
}
IOStream_Read(vault, key.buf_ptr, key.data_len);
((esif_string)(key.buf_ptr))[key.data_len - 1] = 0;
break;
}
if (rc != ESIF_OK) {
EsifData_dtor(&key);
break;
}
// Read Value
IOStream_Read(vault, &value.type, sizeof(value.type));
IOStream_Read(vault, &value.data_len, sizeof(value.data_len));
if (value.data_len > MAX_DV_DATALEN) {
EsifData_dtor(&key);
break;
}
// If NOCACHE mode, use buf_ptr to store the file offset of the data and skip the file
if (item_flags & ESIF_SERVICE_CONFIG_NOCACHE) {
size_t offset = IOStream_GetOffset(vault);
IOStream_Seek(vault, value.data_len, SEEK_CUR);
value.buf_ptr = (void*)offset;
value.buf_len = 0; // data_len = original length
} else {
// Use static pointer for static data vaults (unless encrypted), otherwise make a dynamic copy
if (IOStream_GetType(vault) == StreamMemory && !(item_flags & ESIF_SERVICE_CONFIG_ENCRYPT)) {
value.buf_len = 0; // static
value.buf_ptr = IOStream_GetMemoryBuffer(vault) + IOStream_GetOffset(vault);
IOStream_Seek(vault, value.data_len, SEEK_CUR);
} else {
value.buf_len = value.data_len; // dynamic
value.buf_ptr = esif_ccb_malloc(value.buf_len);
if (!value.buf_ptr) {
EsifData_dtor(&key);
rc = ESIF_E_NO_MEMORY;
break;
}
IOStream_Read(vault, value.buf_ptr, value.data_len);
}
// Decrypt Encrypted Data?
if (item_flags & ESIF_SERVICE_CONFIG_ENCRYPT) {
UInt32 byte;
for (byte = 0; byte < value.data_len; byte++)
((UInt8*)(value.buf_ptr))[byte] = ~((UInt8*)(value.buf_ptr))[byte];
}
}
// Add value (including allocated buf_ptr) to cache
DataCache_SetValue(self->cache, (esif_string)key.buf_ptr, value, item_flags);
value.buf_ptr = 0;
item_flags = 0;
EsifData_dtor(&key);
EsifData_dtor(&value);
}
IOStream_Close(vault);
return rc;
}
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;
}
