NEOERR * rcfs_listdir (const char *path, ULIST **list)
{
NEOERR *err;
DIR *dp;
ULIST *files;
struct dirent *de;
int l;
char *f;
*list = NULL;
err = uListInit (&files, 10, 0);
if (err) return nerr_pass (err);
dp = opendir(path);
if (dp == NULL)
{
uListDestroy(&files, ULIST_FREE);
if (errno == ENOENT)
return nerr_raise (NERR_NOT_FOUND, "Directory %s doesn't exist", path);
return nerr_raise_errno (NERR_IO, "Unable to open directory %s", path);
}
while ((de = readdir (dp)) != NULL)
{
l = strlen (de->d_name);
if (l>4 && !strcmp (de->d_name+l-4, ",log"))
{
f = (char *) malloc ((l-3) * sizeof(char));
if (f == NULL)
{
uListDestroy (&files, ULIST_FREE);
closedir(dp);
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for filename %s", de->d_name);
}
strncpy (f, de->d_name, l-4);
f[l-4] = '\0';
err = uListAppend (files, f);
if (err)
{
free (f);
uListDestroy (&files, ULIST_FREE);
closedir(dp);
return nerr_pass (err);
}
}
}
*list = files;
closedir(dp);
return STATUS_OK;
}
void wdb_destroy (WDB **wdb)
{
WDB *my_wdb;
my_wdb = *wdb;
if (my_wdb == NULL) return;
if (my_wdb->defn_dirty)
{
wdb_save_defn (my_wdb, my_wdb->path);
}
if (my_wdb->attrs != NULL)
{
dictDestroy (my_wdb->attrs);
}
if (my_wdb->cols != NULL)
{
dictDestroy (my_wdb->cols);
}
if (my_wdb->cols_l != NULL)
{
uListDestroy(&(my_wdb->cols_l), 0);
}
if (my_wdb->ondisk != NULL)
{
skipFreeList(my_wdb->ondisk);
}
if (my_wdb->db != NULL)
{
my_wdb->db->close (my_wdb->db, 0);
my_wdb->db = NULL;
}
if (my_wdb->path != NULL)
{
free(my_wdb->path);
my_wdb->path = NULL;
}
if (my_wdb->name != NULL)
{
free(my_wdb->name);
my_wdb->name = NULL;
}
if (my_wdb->key != NULL)
{
free(my_wdb->key);
my_wdb->key = NULL;
}
free (my_wdb);
*wdb = NULL;
return;
}
/* Ok, this version avoids the bubble sort by walking the level once to
* load them all into a ULIST, qsort'ing the list, and then dumping them
* back out... */
NEOERR *hdf_sort_obj (HDF *h, int (*compareFunc)(const void *, const void *))
{
NEOERR *err = STATUS_OK;
ULIST *level = NULL;
HDF *p, *c;
int x;
if (h == NULL) return STATUS_OK;
c = h->child;
if (c == NULL) return STATUS_OK;
do {
err = uListInit(&level, 40, 0);
if (err) return nerr_pass(err);
for (p = c; p; p = p->next) {
err = uListAppend(level, p);
if (err) break;
}
err = uListSort(level, compareFunc);
if (err) break;
uListGet(level, 0, (void *)&c);
h->child = c;
for (x = 1; x < uListLength(level); x++)
{
uListGet(level, x, (void *)&p);
c->next = p;
p->next = NULL;
c = p;
}
h->last_child = c;
} while (0);
uListDestroy(&level, 0);
return nerr_pass(err);
}
int main(int argc, char **argv)
{
char *path;
ULIST *files = NULL;
char *filename;
NEOERR *err;
int x;
if (argc > 1)
path = argv[1];
else
path = ".";
ne_warn("Testing ne_listdir()");
err = ne_listdir(path, &files);
if (err)
{
nerr_log_error(err);
return -1;
}
for (x = 0; x < uListLength(files); x++)
{
err = uListGet(files, x, (void *)&filename);
printf("%s\n", filename);
}
uListDestroy(&files, ULIST_FREE);
ne_warn("Testing ne_listdir_match() with *.c");
err = ne_listdir_match(path, &files, "*.c");
if (err)
{
nerr_log_error(err);
return -1;
}
for (x = 0; x < uListLength(files); x++)
{
err = uListGet(files, x, (void *)&filename);
printf("%s\n", filename);
}
uListDestroy(&files, ULIST_FREE);
return 0;
}
NEOERR *wdb_keys (WDB *wdb, char **primary_key, ULIST **data)
{
NEOERR *err;
int x, len;
WDBColumn *col;
ULIST *my_data;
char *my_key = NULL;
char *my_col = NULL;
*data = NULL;
*primary_key = NULL;
my_key = strdup(wdb->key);
if (my_key == NULL)
return nerr_raise (NERR_NOMEM, "Unable to allocate memory for keys");
len = uListLength(wdb->cols_l);
err = uListInit (&my_data, len, 0);
if (err != STATUS_OK)
{
free(my_key);
return nerr_pass(err);
}
for (x = 0; x < len; x++)
{
err = uListGet (wdb->cols_l, x, (void *)&col);
if (err) goto key_err;
my_col = strdup(col->name);
if (my_col == NULL)
{
err = nerr_raise (NERR_NOMEM, "Unable to allocate memory for keys");
goto key_err;
}
err = uListAppend (my_data, my_col);
my_col = NULL;
if (err) goto key_err;
}
*data = my_data;
*primary_key = my_key;
return STATUS_OK;
key_err:
if (my_key != NULL) free (my_key);
if (my_col != NULL) free (my_col);
*primary_key = NULL;
uListDestroy (&my_data, 0);
return nerr_pass(err);
}
NEOERR* ldml_parse_file(char *dir, char *name, HASH *outhash)
{
char fname[_POSIX_PATH_MAX], *attrval = NULL;
HDF *node, *child, *dhdf;
STRING str;
NEOERR *err;
memset(fname, 0x0, sizeof(fname));
snprintf(fname, sizeof(fname), "%s/%s", dir, name);
err = hdf_init(&node);
if (err != STATUS_OK) return nerr_pass(err);
err = hdf_read_file(node, fname);
if (err != STATUS_OK) return nerr_pass(err);
child = hdf_obj_child(node);
while (child != NULL) {
mtc_dbg("parse node %s", hdf_obj_name(child));
string_init(&str);
attrval = mcs_obj_attr(child, "merge");
if (attrval) {
ULIST *list;
string_array_split(&list, attrval, ",", 10);
ITERATE_MLIST(list) {
snprintf(fname, sizeof(fname), "%s/%s",
dir, neos_strip((char*)list->items[t_rsv_i]));
err = hdf_init(&dhdf);
JUMP_NOK(err, wnext);
err = hdf_read_file(dhdf, fname);
JUMP_NOK(err, wnext);
err = hdf_copy(child, NULL, dhdf);
JUMP_NOK(err, wnext);
}
uListDestroy(&list, ULIST_FREE);
}
wnext:
string_clear(&str);
child = hdf_obj_next(child);
}
err = hash_insert(outhash, (void*)strdup(name), (void*)node);
JUMP_NOK(err, wnext);
return STATUS_OK;
}
NEOERR *ne_listdir_fmatch(const char *path, ULIST **files, MATCH_FUNC fmatch,
void *rock)
{
DIR *dp;
struct dirent *de;
ULIST *myfiles = NULL;
NEOERR *err = STATUS_OK;
if (files == NULL)
return nerr_raise(NERR_ASSERT, "Invalid call to ne_listdir_fmatch");
if (*files == NULL)
{
err = uListInit(&myfiles, 10, 0);
if (err) return nerr_pass(err);
}
else
{
myfiles = *files;
}
if ((dp = opendir (path)) == NULL)
{
return nerr_raise_errno(NERR_IO, "Unable to opendir %s", path);
}
while ((de = readdir (dp)) != NULL)
{
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (fmatch != NULL && !fmatch(rock, de->d_name))
continue;
err = uListAppend(myfiles, strdup(de->d_name));
if (err) break;
}
closedir(dp);
if (err && *files == NULL)
{
uListDestroy(&myfiles, ULIST_FREE);
}
else if (*files == NULL)
{
*files = myfiles;
}
return nerr_pass(err);
}
static void plan_prepare_time(HDF *node, char *date, struct tm *todaystm, float km)
{
if (!node || !date || !todaystm) return;
char datetime[LEN_TM] = {0}, *stime, *sdate;
time_t tm;
/*
* epochsec seted, so, return
*/
if (hdf_get_value(node, "epochsec", NULL)) return;
stime = hdf_get_value(node, "stime", "08:00:00");
sdate = hdf_get_value(node, "sdate", "2011-11-11");
int repeat = hdf_get_int_value(node, "repeat", PLAN_RPT_NONE);
if (repeat == PLAN_RPT_DAY) {
/*
* use date as datepart
*/
snprintf(datetime, LEN_TM, "%s %s", date, stime);
} else if (repeat == PLAN_RPT_WEEK) {
/*
* use the nearest date as datepart
*/
int minday = 7, thatday;
/* 1,2,3,4,5 */
if (sdate) {
int today = todaystm->tm_wday + 1;
ULIST *list;
string_array_split(&list, sdate, ",", 100);
ITERATE_MLIST(list) {
thatday = atoi(list->items[t_rsv_i]);
if (abs(minday) > abs(thatday - today))
minday = thatday - today;
}
uListDestroy(&list, ULIST_FREE);
}
tm = m_thatsec + (minday*60*60*24);
struct tm *stm = localtime(&tm);
char s[LEN_DT];
strftime(s, LEN_DT, "%Y-%m-%d", stm);
snprintf(datetime, LEN_TM, "%s %s", s, stime);
} else {
int file_get_infos_by_uri(mdb_conn *conn, char *uri, ULIST **files, int *noksn)
{
ULIST *urls;
int listlen;
NEOERR *err;
int ret;
err = string_array_split(&urls, uri, URI_SPLITER, MAX_URI_ITEM);
RETURN_V_NOK(err, RET_RBTOP_INPUTE);
listlen = uListLength(urls);
if (listlen < 1) {
mtc_warn("%s not a valid request", uri);
return RET_RBTOP_INPUTE;
}
ret = file_get_infos_by_list(conn, urls, files, noksn);
if (urls != NULL)
uListDestroy(&urls, ULIST_FREE);
return ret;
}
NEOERR* session_init(CGI *cgi, HASH *dbh, session_t **ses)
{
session_t *lses;
HDF *node, *onode;
char tok[LEN_HDF_KEY], *s;
NEOERR *err;
/*
* follow cgi_parse(), to process _type_object
*/
s = hdf_get_value(cgi->hdf, PRE_QUERY"._type_object", NULL);
if (s) {
ULIST *list;
string_array_split(&list, s, ",", 50);
ITERATE_MLIST(list) {
snprintf(tok, sizeof(tok), "%s.%s",
PRE_QUERY, neos_strip((char*)list->items[t_rsv_i]));
onode = hdf_get_obj(cgi->hdf, tok);
if (onode) {
err = mjson_string_to_hdf(onode, NULL, MJSON_EXPORT_NONE);
TRACE_NOK(err);
}
}
uListDestroy(&list, ULIST_FREE);
}
*ses = NULL;
lses = calloc(1, sizeof(session_t));
if (!lses) return nerr_raise(NERR_NOMEM, "calloc memory for session_t failure");
/*
* mname
*/
HDF_FETCH_STR(cgi->hdf, PRE_COOKIE".mname", s);
if (!s) HDF_FETCH_STR(cgi->hdf, PRE_COOKIE".username", s);
if (s) lses->mname = strdup(s);
/*
* province
*/
HDF_FETCH_STR(cgi->hdf, PRE_COOKIE".province", s);
hdf_init(&lses->province);
if (s) {
neos_unescape((UINT8*)s, strlen(s), '%');
hdf_set_value(lses->province, NULL, s);
mjson_export_to_hdf(lses->province, NULL, MJSON_EXPORT_NONE, false);
}
/*
* city
*/
HDF_FETCH_STR(cgi->hdf, PRE_COOKIE".city", s);
hdf_init(&lses->city);
if (s) {
neos_unescape((UINT8*)s, strlen(s), '%');
hdf_set_value(lses->city, NULL, s);
mjson_export_to_hdf(lses->city, NULL, MJSON_EXPORT_NONE, false);
}
/*
* browser
*/
HDF_FETCH_STR(cgi->hdf, PRE_HTTP".UserAgent", s);
if (s) {
mstr_repchr(s, ' ', '\0');
for (int i = 0; i < m_browsers_size; i++) {
if (!strncasecmp(s, m_browsers[i], strlen(m_browsers[i]))) {
lses->browser = i;
break;
}
}
s = strchr(s, '/');
if (s) lses->bversion = strtof(s+1, NULL);
}
/*
* reqtype
*/
lses->reqtype = CGI_REQ_HTML;
char *uri = hdf_get_value(cgi->hdf, PRE_REQ_URI_RW, NULL);
if (!uri) {
uri = "terminal";
lses->reqtype = CGI_REQ_TERMINAL;
}
mstr_repchr(uri, '/', '_');
uri = mstr_strip(uri, '_');
if (!strncmp(uri, "json_", 5)) {
uri = uri+5;
lses->reqtype = CGI_REQ_AJAX;
} else if (!strncmp(uri, "image_", 6)) {
uri = uri+6;
lses->reqtype = CGI_REQ_IMAGE;
}
/*
* dataer, render
*/
switch (http_req_method(cgi)) {
case CGI_REQ_POST:
snprintf(tok, sizeof(tok), "%s_data_mod", uri);
break;
case CGI_REQ_PUT:
snprintf(tok, sizeof(tok), "%s_data_add", uri);
break;
case CGI_REQ_DEL:
snprintf(tok, sizeof(tok), "%s_data_del", uri);
break;
default:
case CGI_REQ_GET:
snprintf(tok, sizeof(tok), "%s_data_get", uri);
break;
}
lses->dataer = strdup(tok);
lses->render = strdup(uri);
/*
* tm_cache_browser
*/
node = hdf_get_obj(g_cfg, PRE_CFG_FILECACHE".0");
while (node != NULL) {
if (reg_search(hdf_get_value(node, "uri", "NULL"), uri)) {
lses->tm_cache_browser = hdf_get_int_value(node, "tm_cache", 0);
break;
}
node = hdf_obj_next(node);
}
/*
* DONE
*/
*ses = lses;
return STATUS_OK;
}
NEOERR *ne_listdir_fmatch(const char *path, ULIST **files, MATCH_FUNC fmatch,
void *rock)
{
NEOERR *err = STATUS_OK;
ULIST *myfiles = NULL;
if (files == NULL)
return nerr_raise(NERR_ASSERT, "Invalid call to ne_listdir_fmatch");
if (*files == NULL)
{
err = uListInit(&myfiles, 10, 0);
if (err) return nerr_pass(err);
}
else
{
myfiles = *files;
}
#ifdef _MSC_VER
HANDLE hFind = INVALID_HANDLE_VALUE;
WIN32_FIND_DATA ffd;
CHAR rootDir[MAX_PATH];
StringCchCopy(rootDir, MAX_PATH, path);
StringCchCat(rootDir, MAX_PATH, TEXT("\\*"));
hFind = FindFirstFile(rootDir, &ffd);
if (hFind == INVALID_HANDLE_VALUE)
return nerr_raise_errno(NERR_IO, "Unable to opendir %s", path);
do {
if (!strcmp(ffd.cFileName, ".") || !strcmp(ffd.cFileName, ".."))
continue;
if (fmatch != NULL && !fmatch(rock, ffd.cFileName))
continue;
err = uListAppend(myfiles, strdup(ffd.cFileName));
if (err) break;
} while (FindNextFile(hFind, &ffd) != 0);
FindClose(hFind);
#else
DIR *dp;
struct dirent *de;
if ((dp = opendir (path)) == NULL)
{
return nerr_raise_errno(NERR_IO, "Unable to opendir %s", path);
}
while ((de = readdir (dp)) != NULL)
{
if (!strcmp(de->d_name, ".") || !strcmp(de->d_name, ".."))
continue;
if (fmatch != NULL && !fmatch(rock, de->d_name))
continue;
err = uListAppend(myfiles, strdup(de->d_name));
if (err) break;
}
closedir(dp);
#endif
if (err && *files == NULL)
{
uListDestroy(&myfiles, ULIST_FREE);
}
else if (*files == NULL)
{
*files = myfiles;
}
return nerr_pass(err);
}
NEOERR* ltpl_parse_file(HASH *dbh, HASH *evth,
void *lib, char *dir, char *name, HASH *outhash)
{
char *tp = NULL, *tpl = NULL, *val = NULL;
HDF *node = NULL, *dhdf = NULL, *child = NULL, *thdf = NULL;
CSPARSE *cs = NULL;
STRING str;
char fname[_POSIX_PATH_MAX], tok[64], *outfile;
NEOERR* (*data_handler)(HDF *hdf, HASH *dbh, HASH *evth);
NEOERR *err;
memset(fname, 0x0, sizeof(fname));
snprintf(fname, sizeof(fname), "%s/%s", dir, name);
err = hdf_init(&node);
if (err != STATUS_OK) return nerr_pass(err);
err = hdf_read_file(node, fname);
if (err != STATUS_OK) return nerr_pass(err);
child = hdf_obj_child(node);
while (child != NULL) {
mtc_dbg("parse node %s", hdf_obj_name(child));
string_init(&str);
val = mcs_obj_attr(child, "merge");
if (val) {
ULIST *list;
string_array_split(&list, val, ",", 10);
ITERATE_MLIST(list) {
snprintf(fname, sizeof(fname), "%s/%s",
dir, neos_strip((char*)list->items[t_rsv_i]));
err = hdf_init(&dhdf);
JUMP_NOK(err, wnext);
err = hdf_read_file(dhdf, fname);
JUMP_NOK(err, wnext);
err = hdf_copy(child, NULL, dhdf);
JUMP_NOK(err, wnext);
}
uListDestroy(&list, ULIST_FREE);
}
/*
* can't use dataset directly, because we'll destroy the whole node
*/
err = hdf_init(&dhdf);
JUMP_NOK(err, wnext);
err = hdf_get_node(child, PRE_CFG_DATASET, &thdf);
JUMP_NOK(err, wnext);
err = hdf_copy(dhdf, NULL, thdf);
JUMP_NOK(err, wnext);
err = cs_init(&cs, dhdf);
JUMP_NOK(err, wnext);
hdf_set_value(cs->hdf, "hdf.loadpaths.tpl", PATH_TPL);
hdf_set_value(cs->hdf, "hdf.loadpaths.local", dir);
err = cgi_register_strfuncs(cs);
JUMP_NOK(err, wnext);
err = mcs_register_bitop_functions(cs);
JUMP_NOK(err, wnext);
err = mcs_register_mkd_functions(cs);
JUMP_NOK(err, wnext);
err = mcs_register_string_uslice(cs);
JUMP_NOK(err, wnext);
tpl = hdf_get_value(child, PRE_CFG_LAYOUT, "null.html");
snprintf(fname, sizeof(fname), "%s/%s", PATH_TPL, tpl);
err = cs_parse_file(cs, fname);
JUMP_NOK(err, wnext);
if (outhash != NULL) {
/*
* store template for rend stage use
*/
hdf_set_value(cs->hdf, PRE_RESERVE"."PRE_CFG_LAYOUT, tpl);
/*
* strdup the key, baby, because we'll free the hdf later
*/
err = hash_insert(outhash, (void*)strdup(hdf_obj_name(child)), (void*)cs);
JUMP_NOK(err, wnext);
snprintf(tok, sizeof(tok), "%s_hdf", hdf_obj_name(child));
err = hash_insert(outhash, (void*)strdup(tok), (void*)cs->hdf);
JUMP_NOK(err, wnext);
}
if ((outfile = hdf_get_value(child, PRE_CFG_OUTPUT, NULL)) != NULL) {
ltpl_prepare_rend(cs->hdf, tpl);
/*
* get_data
*/
val = hdf_get_value(child, PRE_CFG_DATAER, NULL);
if (val != NULL && lib) {
data_handler = dlsym(lib, val);
if( (tp = dlerror()) != NULL) {
mtc_err("%s", tp);
//continue;
} else {
err = (*data_handler)(cs->hdf, dbh, evth);
TRACE_NOK(err);
}
}
err = cs_render(cs, &str, mcs_strcb);
JUMP_NOK(err, wnext);
/*
* produce output filename
*/
val = mcs_hdf_attr(child, PRE_CFG_OUTPUT, "ftime");
if (val) {
char tm[LEN_TM];
mutil_getdatetime(tm, sizeof(tm), val, 0);
outfile = mstr_repstr(1, outfile, "$ftime$", tm);
}
snprintf(fname, sizeof(fname), PATH_DOC"%s", outfile);
/*
* output file
*/
err = mfile_makesure_dir(fname);
JUMP_NOK(err, wnext);
err = mcs_str2file(str, fname);
JUMP_NOK(err, wnext);
#ifdef DEBUG_HDF
snprintf(fname, sizeof(fname), "%s/hdf.%s",
TC_ROOT, hdf_obj_name(child));
hdf_write_file(child, fname);
#endif
}
wnext:
if (cs != NULL && outhash == NULL)
cs_destroy(&cs);
string_clear(&str);
child = hdf_obj_next(child);
}
if (node != NULL) hdf_destroy(&node);
return STATUS_OK;
}