/*
* input : uname(STR) aname(STR)
* return: NORMAL
* reply : NULL
*/
static NEOERR* aic_cmd_appuserin(struct queue_entry *q, struct cache *cd, mdb_conn *db)
{
STRING str; string_init(&str);
char *aname, *uname;
int aid, uid;
NEOERR *err;
REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname);
REQ_GET_PARAM_STR(q->hdfrcv, "uname", uname);
aid = hash_string(aname);
uid = hash_string(uname);
hdf_set_int_value(q->hdfrcv, "uid", uid);
hdf_set_int_value(q->hdfrcv, "aid", aid);
err = aic_cmd_appusers(q, cd, db);
if (err != STATUS_OK) return nerr_pass(err);
if (hdf_get_valuef(q->hdfsnd, "userlist.%s.uname", uname))
return STATUS_OK;
err = mcs_build_incol(q->hdfrcv,
hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.userinfo"),
&str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "INSERT INTO userinfo %s", NULL, str.buf);
string_clear(&str);
cache_delf(cd, PREFIX_USERLIST"%d", aid);
return STATUS_OK;
}
NEOERR* blog_static_get(HDF *hdf, HASH *dbh)
{
mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "aux");
NEOERR *err;
LPRE_DBOP(hdf, conn);
int bid = hdf_get_int_value(hdf, PRE_QUERY".bid", 0);
MDB_QUERY_RAW(conn, "blog", BLOG_COL, " id=%d AND state=%d ",
NULL, bid, BLOG_ST_NORMAL);
err = mdb_set_row(hdf, conn, BLOG_COL, PRE_OUTPUT".blog");
if (err != STATUS_OK) return nerr_pass(err);
/*
* previous
* TODO id%32 ===> id%%d, BLOG_SUBDIR_NUM
*/
MDB_QUERY_RAW(conn, "blog", " id%32 ||'/'|| id as id, title ",
" id < %d AND state=%d ORDER BY ID DESC LIMIT 1 ",
NULL, bid, BLOG_ST_NORMAL);
err = mdb_set_row(hdf, conn, " fnameprev, titleprev ", PRE_OUTPUT".blog");
if (err != STATUS_OK) return nerr_pass(err);
/*
* next
*/
MDB_QUERY_RAW(conn, "blog", " id%32 ||'/'|| id as id, title ",
" id > %d AND state=%d ORDER BY ID LIMIT 1 ",
NULL, bid, BLOG_ST_NORMAL);
err = mdb_set_row(hdf, conn, " fnamenext, titlenext ", PRE_OUTPUT".blog");
return nerr_pass(err);
}
NEOERR* lutil_fetch_count(HDF *hdf, mdb_conn *conn, char *table, char *cond)
{
if (!table || !cond) return nerr_raise(NERR_ASSERT, "paramter null");
char *buf;
size_t datalen;
int count = 0;
NEOERR *err;
buf = mmc_getf(&datalen, 0, PRE_MMC_COUNT".%s.%s", table, cond);
if (buf == NULL) {
err = mdb_exec(conn, NULL, "SELECT count(*) FROM %s WHERE %s;",
NULL, table, cond);
if (err != STATUS_OK) return nerr_pass(err);
err = mdb_get(conn, "s", &buf);
if (err != STATUS_OK) return nerr_pass(err);
count = atoi(buf);
mmc_storef(MMC_OP_SET, (void*)buf, 0, ONE_HOUR, 0,
PRE_MMC_COUNT".%s.%s", table, cond);
} else {
count = atoi(buf);
}
hdf_set_int_value(hdf, PRE_OUTPUT".ttnum", count);
return STATUS_OK;
}
NEOERR* ltpl_parse_dir(char *dir, HASH *outhash)
{
struct dirent **eps = NULL;
int n;
NEOERR *err;
if (!dir) return nerr_raise(NERR_ASSERT, "can't read null directory");
HASH *dbh, *evth;
void *lib = dlopen(NULL, RTLD_NOW|RTLD_GLOBAL);
if (!lib) return nerr_raise(NERR_SYSTEM, "dlopen %s", dlerror());
err = ldb_init(&dbh);
if (err != STATUS_OK) return nerr_pass(err);
err = levt_init(&evth);
if (err != STATUS_OK) return nerr_pass(err);
n = scandir(dir, &eps, ltpl_config, alphasort);
for (int i = 0; i < n; i++) {
mtc_dbg("parse file %s", eps[i]->d_name);
err = ltpl_parse_file(dbh, evth, lib, dir, eps[i]->d_name, outhash);
TRACE_NOK(err);
free(eps[i]);
}
ldb_destroy(dbh);
levt_destroy(evth);
dlclose(lib);
if (n > 0) free(eps);
else mtc_warn("no .hdf file found in %s", dir);
return STATUS_OK;
}
NEOERR* mimg_accept_and_zoomout(CGI *cgi, char* form_name, char *imgroot,
char result[LEN_MD5], int *ftype,
int width, int height)
{
NEOERR *err;
FILE *fp, *fpout;
char tok[3] = {0};
err = mimg_accept(cgi, form_name, imgroot, result, ftype);
if (err != STATUS_OK) return nerr_pass(err);
strncpy(tok, result, 2);
err = mfile_openf(&fp, "r", "%s/%s/%s.%s",
imgroot, tok, result, mimg_type_int2str(*ftype));
if (err != STATUS_OK) return nerr_pass(err);
err = mfile_openf(&fpout, "w+", "%s/%dx%d/%s/%s.%s",
imgroot, width, height, tok, result,
mimg_type_int2str(*ftype));
if (err != STATUS_OK) return nerr_pass(err);
err = mimg_zoomout(*ftype, fpout, fp, width, height);
if (err != STATUS_OK) return nerr_pass(err);
fclose(fpout);
return STATUS_OK;
}
static NEOERR * _copy_nodes (HDF *dest, HDF *src)
{
NEOERR *err = STATUS_OK;
HDF *dt, *st;
HDF_ATTR *attr_copy;
st = src->child;
while (st != NULL)
{
err = _copy_attr(&attr_copy, st->attr);
if (err) return nerr_pass(err);
err = _set_value(dest, st->name, st->value, 1, 1, st->link, attr_copy, &dt);
if (err) {
_dealloc_hdf_attr(&attr_copy);
return nerr_pass(err);
}
if (src->child)
{
err = _copy_nodes (dt, st);
if (err) return nerr_pass(err);
}
st = st->next;
}
return STATUS_OK;
}
NEOERR *wdb_column_update (WDB *wdb, const char *oldkey, const char *newkey)
{
WDBColumn *ocol, *col;
WDBColumn *vcol;
NEOERR *err = STATUS_OK;
int x, len, r;
ocol = (WDBColumn *) dictSearch (wdb->cols, oldkey, NULL);
if (ocol == NULL)
return nerr_raise (NERR_NOT_FOUND,
"Unable to find column for key %s", oldkey);
col = (WDBColumn *) calloc (1, sizeof (WDBColumn));
if (col == NULL)
{
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for column update %s", newkey);
}
*col = *ocol;
col->name = strdup(newkey);
if (col->name == NULL)
{
free(col);
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for column update %s", oldkey);
}
len = uListLength(wdb->cols_l);
for (x = 0; x < len; x++)
{
err = uListGet (wdb->cols_l, x, (void *)&vcol);
if (err) return nerr_pass(err);
if (!strcmp(vcol->name, oldkey))
{
err = uListSet (wdb->cols_l, x, (void *)col);
if (err) return nerr_pass(err);
break;
}
}
if (x>len)
{
return nerr_raise (NERR_ASSERT, "Unable to find cols_l for key %s", oldkey);
}
r = dictRemove (wdb->cols, oldkey); /* Only failure is key not found */
err = dictSetValue(wdb->cols, newkey, col);
if (err)
{
free (col->name);
free (col);
return nerr_pass_ctx (err,
"Unable to insert for update of col %s->%s", oldkey, newkey);
}
wdb->defn_dirty = 1;
wdb->table_version = rand();
return STATUS_OK;
}
/* Copy the characters in the file (up to the next newline) into line
* and advance s to the next line */
static NEOERR *_copy_line_advance(const char **s, STRING *line)
{
NEOERR *err;
int x = 0;
const char *st = *s;
const char *nl;
nl = strchr(st, '\n');
if (nl == NULL)
{
x = strlen(st);
err = string_appendn(line, st, x);
if (err) return nerr_pass(err);
*s = st + x;
}
else
{
x = nl - st;
err = string_appendn(line, st, x);
if (err) return nerr_pass(err);
*s = nl + 1;
}
return STATUS_OK;
}
/* load a specified version of the file, version -1 is latest */
NEOERR * rcfs_load (const char *path, int version, char **data)
{
NEOERR *err;
char fpath[_POSIX_PATH_MAX];
if (version == -1)
{
HDF *meta, *vers;
int x;
err = rcfs_meta_load (path, &meta);
if (err) return nerr_pass (err);
for (vers = hdf_get_child (meta, "Versions");
vers;
vers = hdf_obj_next (vers))
{
x = atoi (hdf_obj_name (vers));
if (x > version) version = x;
}
hdf_destroy (&meta);
}
snprintf (fpath, sizeof (fpath), "%s,%d", path, version);
err = ne_load_file (fpath, data);
return nerr_pass (err);
}
NEOERR* system_who_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
STRING str; string_init(&str);
mdb_conn *db = hash_lookup(dbh, "trace");
char *mname;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, db);
MEMBER_CHECK_ADMIN();
SET_DASHBOARD_ACTION(cgi->hdf);
hdf_set_int_value(cgi->hdf, PRE_QUERY".type", TRACE_TYPE_PAGEVIEW);
err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),
hdf_get_obj(g_cfg, "Db.QueryCond.system.who"),
&str, NULL);
if (err != STATUS_OK) return nerr_pass(err);
MDB_QUERY_RAW(db, "emap", _COL_EMAP_WHO,
" %s GROUP BY sender ORDER BY min(intime) DESC LIMIT 100",
NULL, str.buf);
err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_WHO, PRE_OUTPUT".who",
NULL, MDB_FLAG_EMPTY_OK);
if (err != STATUS_OK) return nerr_pass(err);
string_clear(&str);
hdf_set_attr(cgi->hdf, PRE_OUTPUT".who", "type", "array");
return STATUS_OK;
}
/* 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);
}
NEOERR* system_plan_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mdb_conn *db = hash_lookup(dbh, "plan");
STRING str; string_init(&str);
int count, offset;
char *mname;
HDF *node;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, db);
MEMBER_CHECK_ADMIN();
SET_DASHBOARD_ACTION(cgi->hdf);
hdf_get_node(cgi->hdf, PRE_OUTPUT, &node);
mdb_pagediv(hdf_get_obj(cgi->hdf, PRE_QUERY),
NULL, &count, &offset, NULL, node);
err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),
hdf_get_obj(g_cfg, "Db.QueryCond.system.plan"),
&str, "intime > current_date - 1");
if (err != STATUS_OK) return nerr_pass(err);
MDB_PAGEDIV_SET_N(node, db, "plan", "%s", NULL, str.buf);
MDB_QUERY_RAW(db, "plan", _COL_PLAN_ADMIN,
"%s ORDER BY id DESC LIMIT %d OFFSET %d",
NULL, str.buf, count, offset);
err = mdb_set_rows(cgi->hdf, db, _COL_PLAN_ADMIN, PRE_OUTPUT".rows",
NULL, MDB_FLAG_EMPTY_OK);
if (err != STATUS_OK) return nerr_pass(err);
return STATUS_OK;
}
NEOERR* system_comment_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mdb_conn *db = hash_lookup(dbh, "aux");
STRING str; string_init(&str);
char *mname;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, db);
MEMBER_CHECK_ADMIN();
SET_DASHBOARD_ACTION(cgi->hdf);
if (!hdf_get_value(cgi->hdf, PRE_QUERY".times", NULL))
hdf_set_value(cgi->hdf, PRE_QUERY".timed", "current_date - 7");
err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),
hdf_get_obj(g_cfg, "Db.QueryCond.system.comment"),
&str, NULL);
if (err != STATUS_OK) return nerr_pass(err);
MDB_QUERY_RAW(db, "comment", _COL_CMT, "%s ORDER BY id DESC", NULL, str.buf);
err = mdb_set_rows(cgi->hdf, db, _COL_CMT, PRE_OUTPUT".rows",
NULL, MDB_FLAG_EMPTY_OK);
if (err != STATUS_OK) return nerr_pass(err);
return STATUS_OK;
}
NEOERR* system_view_detail_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
STRING str; string_init(&str);
mdb_conn *db = hash_lookup(dbh, "trace");
char *mname;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, db);
MEMBER_CHECK_ADMIN();
SET_DASHBOARD_ACTION(cgi->hdf);
err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),
hdf_get_obj(g_cfg, "Db.QueryCond.system.viewdetail"),
&str, NULL);
if (err != STATUS_OK) return nerr_pass(err);
MDB_QUERY_RAW(db, "emap", _COL_EMAP_VIEW_DETAIL,
" %s ORDER BY intime LIMIT 100", NULL, str.buf);
err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_VIEW_DETAIL, PRE_OUTPUT".details",
NULL, MDB_FLAG_EMPTY_OK);
if (err != STATUS_OK) return nerr_pass(err);
string_clear(&str);
hdf_set_attr(cgi->hdf, PRE_OUTPUT".details", "type", "array");
return STATUS_OK;
}
NEOERR *wdbr_find (WDB *wdb, WDBCursor *cursor, const char *key, WDBRow **row)
{
DBT dkey, data;
WDBRow *my_row;
NEOERR *err = STATUS_OK;
int r;
*row = NULL;
if (wdb->table_version != cursor->table_version)
{
return nerr_raise (NERR_ASSERT, "Cursor doesn't match database");
}
memset(&dkey, 0, sizeof(dkey));
memset(&data, 0, sizeof(data));
dkey.flags = DB_DBT_USERMEM;
data.flags = DB_DBT_MALLOC;
dkey.data = (void *)key;
dkey.size = strlen(key);
r = cursor->db_cursor->c_get (cursor->db_cursor, &dkey, &data, DB_SET_RANGE);
if (r == DB_NOTFOUND)
return STATUS_OK;
else if (r)
return nerr_raise (r, "Unable to get find item for key %s", key);
/* allocate row */
err = alloc_row (wdb, &my_row);
if (err)
{
free (data.data);
return nerr_pass(err);
}
my_row->key_value = (char *) malloc (dkey.size + 1);
if (my_row->key_value == NULL)
{
free (data.data);
free (my_row);
return nerr_raise (NERR_NOMEM, "No memory for new row");
}
memcpy (my_row->key_value, dkey.data, dkey.size);
my_row->key_value[dkey.size] = '\0';
/* unpack row */
err = unpack_row (wdb, data.data, data.size, my_row);
free (data.data);
if (err)
{
free (my_row);
return nerr_pass(err);
}
*row = my_row;
return STATUS_OK;
}
NEOERR *wdb_column_delete (WDB *wdb, const char *name)
{
WDBColumn *col;
NEOERR *err = STATUS_OK;
int len, x, r;
len = uListLength(wdb->cols_l);
for (x = 0; x < len; x++)
{
err = uListGet (wdb->cols_l, x, (void *)&col);
if (err) return nerr_pass(err);
if (!strcmp(col->name, name))
{
err = uListDelete (wdb->cols_l, x, NULL);
if (err) return nerr_pass(err);
break;
}
}
r = dictRemove (wdb->cols, name); /* Only failure is key not found */
if (!r)
{
return nerr_raise (NERR_NOT_FOUND,
"Unable to find column for key %s", name);
}
wdb->defn_dirty = 1;
wdb->table_version = rand();
return STATUS_OK;
}
NEOERR* mcs_set_float_value_with_type(HDF *hdf, char *name, float value, CnodeType type)
{
NEOERR *err;
err = mcs_set_float_value(hdf, name, value);
if (err != STATUS_OK) return nerr_pass(err);
return nerr_pass(mcs_set_int_attr(hdf, name, "type", type));
}
NEOERR *ne_net_write_line(NSOCK *sock, const char *s)
{
NEOERR *err;
err = ne_net_write(sock, s, strlen(s));
if (err) return nerr_pass(err);
err = ne_net_write(sock, "\n", 1);
if (err) return nerr_pass(err);
return STATUS_OK;
}
NEOERR* lerr_init()
{
NEOERR *err;
if (lerrInited == 0) {
err = nerr_init();
if (err != STATUS_OK) return nerr_pass(err);
err = merr_init((MeventLog)mtc_msg);
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register(&LERR_NOTLOGIN, "请登录后操作");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register(&LERR_LOGINPSW, "密码错误");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register(&LERR_LIMIT, "用户无权限");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register(&LERR_MISS_DATA, "请求的资源不存在");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register(&LERR_MISS_TPL, "找不到渲染模板(忘记了/json ?)");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register(&LERR_ATTACK, "太过频繁，请稍后请求！");
if (err != STATUS_OK) return nerr_pass(err);
err = nerr_register(&LERR_REDIRECT, "页面重定向！");
if (err != STATUS_OK) return nerr_pass(err);
lerrInited = 1;
}
return STATUS_OK;
}
NEOERR *wdbr_lookup (WDB *wdb, const char *key, WDBRow **row)
{
DBT dkey, data;
NEOERR *err = STATUS_OK;
WDBRow *my_row;
int r;
*row = NULL;
memset(&dkey, 0, sizeof(dkey));
memset(&data, 0, sizeof(data));
dkey.flags = DB_DBT_USERMEM;
data.flags = DB_DBT_MALLOC;
dkey.data = (void *)key;
dkey.size = strlen(key);
r = wdb->db->get (wdb->db, NULL, &dkey, &data, 0);
if (r == DB_NOTFOUND)
return nerr_raise (NERR_NOT_FOUND, "Unable to find key %s", key);
else if (r)
return nerr_raise (NERR_DB, "Error retrieving key %s: %d", key, r);
/* allocate row */
err = alloc_row (wdb, &my_row);
if (err != STATUS_OK)
{
free (data.data);
return nerr_pass(err);
}
my_row->key_value = strdup(key);
if (my_row->key_value == NULL)
{
free (data.data);
free (my_row);
return nerr_raise (NERR_NOMEM, "No memory for new row");
}
/* unpack row */
err = unpack_row (wdb, data.data, data.size, my_row);
free (data.data);
if (err)
{
free (my_row);
return nerr_pass(err);
}
*row = my_row;
return STATUS_OK;
}
NEOERR* hdf_copy (HDF *dest, const char *name, HDF *src)
{
NEOERR *err;
HDF *node;
if (_walk_hdf(dest, name, &node) == -1)
{
err = _set_value (dest, name, NULL, 0, 0, 0, NULL, &node);
if (err) return nerr_pass (err);
}
return nerr_pass (_copy_nodes (node, src));
}
static NEOERR* rend_blog(HASH *dbh, HASH *tplh, int bid)
{
CSPARSE *cs = NULL;
HDF *hdf, *dhdf;
STRING str;
NEOERR *err;
char fname[_POSIX_PATH_MAX];
if (!dbh || !tplh || bid < 0) return nerr_raise(NERR_ASSERT, "paramter null");
cs = (CSPARSE*)hash_lookup(tplh, "blog");
dhdf = (HDF*)hash_lookup(tplh, "blog_hdf");
if (!cs || !dhdf) return nerr_raise(LERR_MISS_TPL, "blog_index not found");
err = hdf_init(&hdf);
if (err != STATUS_OK) return nerr_pass(err);
hdf_copy(hdf, NULL, dhdf);
ltpl_prepare_rend(hdf, "layout.html");
hdf_set_int_value(hdf, PRE_QUERY".bid", bid);
err = blog_static_get(hdf, dbh);
if (err != STATUS_OK) goto done;
hdf_set_copy(hdf, PRE_LAYOUT".title", PRE_OUTPUT".blog.title");
cs->hdf = hdf;
string_init(&str);
err = cs_render(cs, &str, mcs_strcb);
if (err != STATUS_OK) goto done;
snprintf(fname, sizeof(fname), "%s%d/%d.html",
PATH_BLOG, bid%BLOG_SUBDIR_NUM, bid);
err = mutil_makesure_dir(fname);
if (err != STATUS_OK) goto done;
err = mcs_str2file(str, fname);
if (err != STATUS_OK) goto done;
#ifdef DEBUG_HDF
hdf_write_file(hdf, TC_ROOT"hdf.blg");
#endif
done:
hdf_destroy(&hdf);
cs->hdf = NULL;
string_clear(&str);
return nerr_pass(err);
}
NEOERR* mcs_register_bitop_functions(CSPARSE *cs)
{
NEOERR *err;
err = cs_register_function(cs, "bitop.and", 2, _builtin_bitop_and);
if (err != STATUS_OK) return nerr_pass(err);
cs_register_function(cs, "bitop.or", 2, _builtin_bitop_or);
if (err != STATUS_OK) return nerr_pass(err);
cs_register_function(cs, "bitop.xor", 2, _builtin_bitop_xor);
if (err != STATUS_OK) return nerr_pass(err);
return STATUS_OK;
}
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;
}
NEOERR* mimg_accept(CGI *cgi, char *form_name, char *imgroot,
char result[LEN_MD5], int *ftype)
{
unsigned char data[IMAGE_MD5_SIZE];
unsigned int bytes;
char tok[3] = {0};
NEOERR *err;
FILE *fp, *fpout;
char *s;
MCS_NOT_NULLC(cgi->hdf, imgroot, ftype);
/* TODO memory leak */
fp = mfile_get_safe_from_std(cgi_filehandle(cgi, form_name));
MCS_NOT_NULLA(fp);
s = mfile_get_type(cgi, form_name);
if (!s || strncmp(s, "image/", 6)) {
return nerr_raise(NERR_ASSERT, "file %s not image type", s);
}
s = s + 6;
*ftype = mimg_type_str2int(s);
memset(data, 0x0, sizeof(data));
fseek(fp, 0, SEEK_SET);
bytes = fread(data, 1, sizeof(data), fp);
if (bytes <= 0) return nerr_raise(NERR_IO, "read image file error %d ", bytes);
mstr_md5_buf(data, bytes, result);
strncpy(tok, result, 2);
err = mfile_openf(&fpout, "w+", "%s/%s/%s.%s",
imgroot, tok, result, mimg_type_int2str(*ftype));
if (err != STATUS_OK) return nerr_pass(err);
s = hdf_get_value(cgi->hdf, PRE_QUERY"._upfile_data_type", NULL);
if (s && !strcmp(s, "dataurl")) {
err = mb64_decode(fp, fpout);
if (err != STATUS_OK) return nerr_pass(err);
} else {
if (bytes < IMAGE_MD5_SIZE-10) {
fwrite(data, 1, bytes, fpout);
} else {
mfile_copy(fpout, fp);
}
}
fclose(fpout);
return STATUS_OK;
}
NEOERR *ne_net_read_binary(NSOCK *sock, UINT8 **b, int *blen)
{
NEOERR *err;
UINT8 *data;
UINT8 buf[5];
int l;
err = _ne_net_read_int(sock, &l, ':');
if (err) return nerr_pass(err);
/* Special case to read a NULL */
if (l < 0)
{
*b = NULL;
if (blen != NULL) *blen = l;
return STATUS_OK;
}
data = (UINT8 *) malloc(l + 1);
if (data == NULL)
{
/* We might want to clear the incoming data here... */
return nerr_raise(NERR_NOMEM,
"Unable to allocate memory for binary data %d" , l);
}
err = ne_net_read(sock, data, l);
if (err)
{
free(data);
return nerr_pass(err);
}
/* check for comma separator */
err = ne_net_read(sock, buf, 1);
if (err)
{
free(data);
return nerr_pass(err);
}
if (buf[0] != ',')
{
free(data);
return nerr_raise(NERR_PARSE, "Format error on stream, expected ','");
}
*b = data;
if (blen != NULL) *blen = l;
return STATUS_OK;
}
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* mcs_register_upload_parse_cb(CGI *cgi, void *rock)
{
NEOERR *err;
err = cgi_register_parse_cb(cgi, "POST", "application/x-www-form-urlencoded",
rock, mhttp_upload_parse_cb);
if (err != STATUS_OK) return nerr_pass(err);
err = cgi_register_parse_cb(cgi, "POST", "multipart/form-data",
rock, mhttp_upload_parse_cb);
if (err != STATUS_OK) return nerr_pass(err);
err = cgi_register_parse_cb(cgi, "PUT", "*", rock, mhttp_upload_parse_cb);
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_net_write_int(NSOCK *sock, int i)
{
char buf[32];
snprintf(buf, sizeof(buf), "%d,", i);
return nerr_pass(ne_net_write(sock, buf, strlen(buf)));
}
