// Recursively create a path if it does not already exist
static int esif_ccb_makepath (char *path)
{
int rc = -1;
struct stat st = {0};
// create path only if it does not already exist
if ((rc = esif_ccb_stat(path, &st)) != 0) {
size_t len = esif_ccb_strlen(path, MAX_PATH);
char dir[MAX_PATH];
char *slash;
// trim any trailing slash
esif_ccb_strcpy(dir, path, MAX_PATH);
if (len > 0 && dir[len - 1] == *ESIF_PATH_SEP) {
dir[len - 1] = 0;
}
// if path doesn't exist and can't be created, recursively create parent folder(s)
if ((rc = esif_ccb_stat(dir, &st)) != 0 && (rc = esif_ccb_mkdir(dir)) != 0) {
if ((slash = esif_ccb_strrchr(dir, *ESIF_PATH_SEP)) != 0) {
*slash = 0;
if ((rc = esif_ccb_makepath(dir)) == 0) {
*slash = *ESIF_PATH_SEP;
rc = esif_ccb_mkdir(dir);
}
}
}
}
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);
}
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;
}
// Initialize Pathname List
enum esif_rc esif_pathlist_init(esif_string paths)
{
static esif_pathmap pathmap[] = {
{ "HOME", ESIF_PATHTYPE_HOME },
{ "TEMP", ESIF_PATHTYPE_TEMP },
{ "DV", ESIF_PATHTYPE_DV },
{ "LOG", ESIF_PATHTYPE_LOG },
{ "BIN", ESIF_PATHTYPE_BIN },
{ "LOCK", ESIF_PATHTYPE_LOCK },
{ "EXE", ESIF_PATHTYPE_EXE },
{ "DLL", ESIF_PATHTYPE_DLL },
{ "DPTF", ESIF_PATHTYPE_DPTF },
{ "DSP", ESIF_PATHTYPE_DSP },
{ "CMD", ESIF_PATHTYPE_CMD },
{ "UI", ESIF_PATHTYPE_UI },
{ NULL }
};
static int num_paths = (sizeof(pathmap)/sizeof(*pathmap)) - 1;
esif_string *pathlist = NULL;
enum esif_rc rc = ESIF_OK;
if (!g_pathlist.initialized) {
char *buffer = NULL;
char *filename = ESIF_PATHLIST_FILENAME;
FILE *fp = NULL;
struct stat st={0};
// Use pathlist file, if it exists
if (esif_ccb_stat(filename, &st) == 0 && esif_ccb_fopen(&fp, filename, "rb") == 0) {
if ((buffer = (char *) esif_ccb_malloc(st.st_size + 1)) != NULL) {
if (esif_ccb_fread(buffer, st.st_size, sizeof(char), st.st_size, fp) != (size_t)st.st_size) {
rc = ESIF_E_IO_ERROR;
}
}
esif_ccb_fclose(fp);
}
// Otherwise, use default pathlist
else if (buffer == NULL && paths != NULL) {
buffer = esif_ccb_strdup(paths);
}
if ((buffer == NULL) || ((pathlist = (esif_string *)esif_ccb_malloc(num_paths * sizeof(esif_string))) == NULL)) {
esif_ccb_free(buffer);
buffer = NULL;
rc = ESIF_E_NO_MEMORY;
}
// Parse key/value pairs into pathlist
if (rc == ESIF_OK && buffer != NULL) {
char *ctxt = 0;
char *keypair = esif_ccb_strtok(buffer, "\r\n", &ctxt);
char *value = 0;
int id=0;
g_pathlist.initialized = 1;
g_pathlist.pathmap = pathmap;
g_pathlist.num_paths = num_paths;
g_pathlist.pathlist = pathlist;
while (keypair != NULL) {
value = esif_ccb_strchr(keypair, '=');
if (value) {
*value++ = 0;
for (id = 0; id < g_pathlist.num_paths && g_pathlist.pathmap[id].name; id++) {
if (esif_ccb_stricmp(keypair, g_pathlist.pathmap[id].name) == 0) {
esif_pathlist_set(g_pathlist.pathmap[id].type, value);
break;
}
}
}
keypair = esif_ccb_strtok(NULL, "\r\n", &ctxt);
}
}
esif_ccb_free(buffer);
}
return rc;
}
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;
}
// 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;
}
