void mcs_hdf_rep(HDF *data, HDF *dst)
{
char *srcstr, *repstr;
if (!data || !dst) return;
HDF *datarow = hdf_obj_child(data);
while (datarow) {
HDF *child = hdf_obj_child(dst);
while (child) {
if (hdf_obj_child(child)) {
return mcs_hdf_rep(data, child);
}
srcstr = hdf_obj_value(child);
repstr = mstr_repstr(1, srcstr,
hdf_obj_name(datarow),
hdf_obj_value(datarow));
hdf_set_value(child, NULL, repstr);
free(repstr);
child = hdf_obj_next(child);
}
datarow = hdf_obj_next(datarow);
}
}
void mjson_asm_objs(HDF *hdf, struct json_object **out)
{
if (hdf == NULL)
return;
struct json_object *jret, *jso;
char *val, *type;
bool array = false;
type = mcs_obj_attr(hdf, "type");
if (type && !strcmp(type, "array")) {
array = true;
jret = json_object_new_array();
} else {
jret = json_object_new_object();
}
hdf = hdf_obj_child(hdf);
while (hdf) {
jso = NULL;
if ((val = hdf_obj_value(hdf)) != NULL) {
type = mcs_obj_attr(hdf, "type");
if (type != NULL && !strcmp(type, "int")) {
jso = json_object_new_int(atoi(val));
} else {
jso = json_object_new_string(val);
}
if (array)
json_object_array_add(jret, jso);
else
json_object_object_add(jret, hdf_obj_name(hdf), jso);
}
if (hdf_obj_child(hdf) != NULL) {
mjson_asm_objs(hdf, &jso);
if (array)
json_object_array_add(jret, jso);
else
json_object_object_add(jret, hdf_obj_name(hdf), jso);
}
hdf = hdf_obj_next(hdf);
}
*out = jret;
}
NEOERR* inbox_multi_add(HDF *datanode, HASH *evth, char *inboxtype)
{
mevent_t *evt;
int mid;
HDF *child;
NEOERR *err;
MCS_NOT_NULLB(datanode, evth);
evt = hash_lookup(evth, "aux");
MCS_NOT_NULLA(evt);
child = hdf_obj_child(datanode);
while (child) {
mid = hdf_get_int_value(child, "mid", 0);
if (mid > 0) {
hdf_set_valuef(evt->hdfsnd, "mmid.%d=%d", mid, mid);
}
child = hdf_obj_next(child);
}
if (!hdf_get_obj(evt->hdfsnd, "mmid"))
return nerr_raise(NERR_ASSERT, "请设置收信用户号码");
err = mtpl_InConfigRend_get(evt->hdfsnd, datanode, "inbox", inboxtype, g_datah);
if (err != STATUS_OK) return nerr_pass(err);
MEVENT_TRIGGER(evt, NULL, REQ_CMD_AUX_INBOX_ADD, FLAGS_NONE);
return STATUS_OK;
}
bool Tree::ParseFromHdfFile(const std::string &filename)
{
Clear();
HDF *hdf;
NEOERR *err = hdf_init(&hdf);
if (err != STATUS_OK) {
nerr_ignore(&err);
return false;
}
err = hdf_read_file(hdf, filename.c_str());
if (err != STATUS_OK) {
nerr_ignore(&err);
hdf_destroy(&hdf);
return false;
}
HDF *child = hdf_obj_child(hdf);
if (!child) {
hdf_destroy(&hdf);
return false;
}
if (!ParseFromHdfInternal(child)) {
hdf_destroy(&hdf);
return false;
}
hdf_destroy(&hdf);
return true;
}
bool Tree::ParseFromHdfString(const std::string &serialized)
{
Clear();
if (serialized.empty()) {
return true;
}
HDF *hdf;
NEOERR *err = hdf_init(&hdf);
if (err != STATUS_OK) {
nerr_ignore(&err);
return false;
}
err = hdf_read_string(hdf, serialized.c_str());
if (err != STATUS_OK) {
nerr_ignore(&err);
hdf_destroy(&hdf);
return false;
}
HDF *child = hdf_obj_child(hdf);
if (!child) {
hdf_destroy(&hdf);
return false;
}
if (!ParseFromHdfInternal(child)) {
hdf_destroy(&hdf);
return false;
}
hdf_destroy(&hdf);
return true;
}
NEOERR* levt_init(HASH **evth)
{
mevent_t *evt;
char *ename;
HDF *node;
HASH *levth;
NEOERR *err;
node = hdf_get_obj(g_cfg, "Mevent");
if (!node) return nerr_raise(NERR_ASSERT, "Mevent config not found");
err = hash_init(&levth, hash_str_hash, hash_str_comp, hash_str_free);
if (err != STATUS_OK) return nerr_pass(err);
node = hdf_obj_child(node);
while (node != NULL) {
ename = hdf_obj_value(node);
evt = mevent_init_plugin(ename);
if (evt) {
mtc_dbg("event %s init ok", ename);
hash_insert(levth, (void*)strdup(ename), (void*)evt);
} else {
mtc_err("event %s init failure", ename);
}
node = hdf_obj_next(node);
}
*evth = levth;
return STATUS_OK;
}
void CGI::TranslatePost(void *cgi, Tree *posts,
std::map<std::string, File> *files)
{
::CGI *c = reinterpret_cast< ::CGI *>(cgi);
HDF *parent = hdf_get_obj(c->hdf, "Query");
if (!parent) {
return;
}
HDF *next = hdf_obj_child(parent);
while (next) {
HDF *child = next;
next = hdf_obj_next(next);
const char *k = hdf_obj_name(child);
const char *v = hdf_obj_value(child);
if (!k || !v) {
continue;
}
if (!TranslateFile(c, k, files)) {
posts->Set(k, v);
}
}
}
NEOERR* fill_trackarea(HASH *evth, HASH *dbh)
{
mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "dyn");
mevent_t *evt = (mevent_t*)hash_lookup(evth, "place");
HDF *node; hdf_init(&node);
char *ip, *aid, *uid, *city, *area;
NEOERR *err;
LPRE_ALLOP(node, conn, evt);
MDB_QUERY_RAW(conn, "track", COL_TRACK, "intime > current_date AND "
" area='' GROUP BY aid, uid", NULL);
err = mdb_set_rows(node, conn, COL_TRACK, NULL, NULL);
if (err != STATUS_OK) return nerr_pass(err);
node = hdf_obj_child(node);
while (node) {
ip = hdf_get_value(node, "ip", NULL);
aid = hdf_get_value(node, "aid", "0");
uid = hdf_get_value(node, "uid", "0");
if (ip) {
hdf_set_value(evt->hdfsnd, "ip", ip);
MEVENT_TRIGGER_NRET(evt, ip, REQ_CMD_PLACEGET, FLAGS_SYNC);
city = hdf_get_value(evt->hdfrcv, "0.c", "Mars");
area = city2area(city);
MDB_EXEC(conn, NULL, "UPDATE track SET area=$1 WHERE aid=$2 AND uid=$3",
"sss", area, aid, uid);
}
node = hdf_obj_next(node);
}
return STATUS_OK;
}
JNIEXPORT jint JNICALL Java_org_clearsilver_HDF__1objChild(
JNIEnv *env, jclass objClass, jint hdf_obj_ptr) {
HDF *hdf = (HDF *)hdf_obj_ptr;
HDF *child_hdf = NULL;
child_hdf = hdf_obj_child(hdf);
return (jint)child_hdf;
}
Hdf Hdf::firstChild(bool markVisited /* = true */) const {
HDF *hdf = getRaw();
if (markVisited) hdf_set_visited(hdf, 1);
Hdf ret(hdf_obj_child(hdf));
ret.m_path = getFullPath();
ret.m_name = ret.getName(markVisited);
return ret;
}
int wkm_cfg_to_opts(struct wkman *wkman, struct cfg *cfg) {
HDF *base_hdf = (HDF*)cfg;
HDF *hdf;
int rval = 0;
dbg1("%s %s()", wkman->dev->serial, __func__);
for(hdf = hdf_obj_child(base_hdf); hdf; hdf = hdf_obj_next(hdf)) {
const char *key = hdf_obj_name(hdf);
const char *val_str = hdf_obj_value(hdf);
int val = atoi(val_str);
rval += wkm_set_value(wkman, key, val);
}
return rval;
}
HDF* mcs_obj_nth_child(HDF *hdf, int n)
{
HDF *node;
if (!hdf || n < 0) return NULL;
node = hdf_obj_child(hdf);
while (node && --n > 0) {
node = hdf_obj_next(node);
}
return node;
}
int main(int argc, char **argv, char **envp)
{
char key[10];
HDF *bignode;
mtc_init("cshdf", 7);
hdf_init(&bignode);
for (int i = 0; i < 5003929; i++) {
mstr_rand_string_with_len(key, 10);
hdf_set_valuef(bignode, "%s.today=10", key);
hdf_set_valuef(bignode, "%s.toweek=11", key);
hdf_set_valuef(bignode, "%s.tomonth=12", key);
hdf_set_valuef(bignode, "%s.total=234", key);
if (i % 10000 == 0) printf("%d\n", i);
}
//hdf_dump(bignode, NULL);
printf("child num %d\n", mcs_get_child_num(bignode, NULL));
int count = 0;
mtimer_start();
HDF *cnode = hdf_obj_child(bignode);
while (cnode) {
char *name = hdf_obj_name(cnode);
if (mcs_get_int_valuef(bignode, 0, "%s.today", name) != 10) printf("error\n");
if (mcs_get_int_valuef(bignode, 0, "%s.toweek", name) != 11) printf("error\n");
if (mcs_get_int_valuef(bignode, 0, "%s.tomonth", name) != 12) printf("error\n");
if (mcs_get_int_valuef(bignode, 0, "%s.total", name) != 234) printf("error\n");
count++;
cnode = hdf_obj_next(cnode);
}
mtimer_stop("get time");
printf("get child count %d\n", count);
hdf_destroy(&bignode);
return 0;
}
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;
}
static PyObject * p_hdf_obj_child (PyObject *self, PyObject *args)
{
HDFObject *ho = (HDFObject *)self;
PyObject *rv;
HDF *r;
r = hdf_obj_child (ho->data);
if (r == NULL)
{
rv = Py_None;
Py_INCREF(rv);
return rv;
}
rv = p_hdf_to_object (r, 0);
return rv;
}
int mmg_get_int_valuef(mmg_conn *db, char *dsn, char *key, int skip, int limit,
char *qfmt, ...)
{
HDF *tmpnode; hdf_init(&tmpnode);
char *querys, sels[256];
int val;
va_list ap;
HDF *node;
NEOERR *err;
va_start(ap, qfmt);
querys = vsprintf_alloc(qfmt, ap);
va_end(ap);
if (!querys) {
mtc_err("Unable to allocate mem for query string");
return 0;
}
snprintf(sels, sizeof(sels), "{'%s': 1}", key);
err = mmg_prepare(db, MMG_FLAG_EMPTY, skip, limit, NULL, sels, querys);
RETURN_V_NOK(err, 0);
err = mmg_query(db, dsn, NULL, tmpnode);
RETURN_V_NOK(err, 0);
val = 0;
if(hdf_get_valuef(tmpnode, "0.%s", key)) {
node = hdf_obj_child(tmpnode);
while (node) {
val += hdf_get_int_value(node, key, 0);
node = hdf_obj_next(node);
}
} else {
val = hdf_get_int_value(tmpnode, key, 0);
}
hdf_destroy(&tmpnode);
SAFE_FREE(querys);
return val;
}
void CGI::TranslateHDF(void *cgi, const std::string &node, Tree *maps)
{
::CGI *c = reinterpret_cast< ::CGI *>(cgi);
HDF *parent = hdf_get_obj(c->hdf, node.c_str());
if (!parent) {
return;
}
HDF *child = hdf_obj_child(parent);
while (child) {
const char *k = hdf_obj_name(child);
const char *v = hdf_obj_value(child);
if (k && v) {
maps->Set(k, v);
}
child = hdf_obj_next(child);
}
}
bool Tree::ParseFromHdfInternal(struct _hdf *hdf)
{
while (hdf) {
const char *key = hdf_obj_name(hdf);
const char *value = hdf_obj_value(hdf);
if (!value) {
value = "";
}
std::string full_path = GetFullPath(key);
Tree *child = new Tree(full_path, key, value);
_children.insert(std::make_pair(key, child));
HDF *hc = hdf_obj_child(hdf);
if (!child->ParseFromHdfInternal(hc)) {
return false;
}
hdf = hdf_obj_next(hdf);
}
return true;
}
void smsalarm_msg(char *msg)
{
mdb_conn *db;
//char content[100];
NEOERR *err;
err = mdb_init(&db, SMSA_DB_SN);
RETURN_NOK(err);
HDF *node = hdf_get_obj(g_cfg, SMSA_CFG_PATH".leader");
if (node != NULL) node = hdf_obj_child(node);
while (node != NULL) {
//memset(content, 0x0, sizeof(content));
err = mdb_exec(db, NULL,
"INSERT INTO monitor_smssend (smsSendTo, smsContent) VALUES ('%s', '%s')",
NULL, hdf_obj_value(node), msg);
TRACE_NOK(err);
node = hdf_obj_next(node);
}
mdb_destroy(db);
}
NEOERR* email_multi_add(HDF *datanode, HASH *evth, char *emailtype)
{
mevent_t *evt;
char *mname;
HDF *child;
int cnt = 0;
NEOERR *err;
MCS_NOT_NULLB(datanode, evth);
evt = hash_lookup(evth, "aux");
MCS_NOT_NULLA(evt);
child = hdf_obj_child(datanode);
while (child) {
mname = hdf_get_value(child, "mname", NULL);
if (mname) {
/*
* use cnt instead of mname as hdf key because mname contain '.'
*/
hdf_set_valuef(evt->hdfsnd, "mto.%d=%s", cnt++, mname);
}
child = hdf_obj_next(child);
}
if (!hdf_get_obj(evt->hdfsnd, "mto"))
return nerr_raise(NERR_ASSERT, "请设置收信用户名");
err = mtpl_InConfigRend_get(evt->hdfsnd, datanode, "email", emailtype, g_datah);
if (err != STATUS_OK) return nerr_pass(err);
MEVENT_TRIGGER(evt, NULL, REQ_CMD_AUX_EMAIL_ADD, FLAGS_NONE);
return STATUS_OK;
}
static NEOERR* _hdf_read_string (HDF *hdf, const char **str, STRING *line,
const char *path, int *lineno,
int include_handle, int expect_end_brace) {
NEOERR *err;
HDF *lower;
char *s;
char *name, *value;
HDF_ATTR *attr = NULL;
while (**str != '\0')
{
/* Reset string length, but don't free the reserved buffer */
line->len = 0;
err = _copy_line_advance(str, line);
if (err) return nerr_pass(err);
attr = NULL;
(*lineno)++;
s = line->buf;
SKIPWS(s);
if ((!strncmp(s, "#include ", 9) || !strncmp(s, "-include ", 9)) && include_handle != INCLUDE_IGNORE)
{
int required = !strncmp(s, "#include ", 9);
if (include_handle == INCLUDE_ERROR)
{
return nerr_raise (NERR_PARSE,
"[%d]: #include not supported in string parse",
*lineno);
}
else if (include_handle < INCLUDE_MAX_DEPTH)
{
int l;
s += 9;
name = neos_strip(s);
l = strlen(name);
if (name[0] == '"' && name[l-1] == '"')
{
name[l-1] = '\0';
name++;
}
char fullpath[PATH_MAX];
if (name[0] != '/') {
memset(fullpath, 0, PATH_MAX);
char *p = strrchr(path, '/');
if (p == NULL) {
char pwd[PATH_MAX];
memset(pwd, 0, PATH_MAX);
getcwd(pwd, PATH_MAX);
snprintf(fullpath, PATH_MAX, "%s/%s", pwd, name);
} else {
int dir_len = p - path + 1;
snprintf(fullpath, PATH_MAX, "%s", path);
snprintf(fullpath + dir_len, PATH_MAX - dir_len, "%s", name);
}
name = fullpath;
}
err = hdf_read_file_internal(hdf, name, include_handle + 1);
if (err != STATUS_OK && required)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else {
return nerr_raise (NERR_MAX_RECURSION,
"[%d]: Too many recursion levels.",
*lineno
);
}
}
else if (s[0] == '#')
{
/* comment: pass */
}
else if (s[0] == '}') /* up */
{
s = neos_strip(s);
if (strcmp(s, "}"))
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Trailing garbage on line following }: %s", path, *lineno,
line->buf);
return err;
}
return STATUS_OK;
}
else if (s[0])
{
/* Valid hdf name is [0-9a-zA-Z_.]+ */
int splice = *s == '@';
if (splice) s++;
name = s;
while (*s && (isalnum(*s) || *s == '_' || *s == '.' || *s == '*')) s++;
SKIPWS(s);
char num[16];
static int counter = 0;
if (*name == '*') {
snprintf(num, sizeof(num), "%d", counter++);
name = num;
}
if (s[0] == '[') /* attributes */
{
*s = '\0';
name = neos_strip(name);
s++;
err = parse_attr(&s, &attr);
if (err)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
SKIPWS(s);
}
if (splice) {
name = neos_strip(name);
HDF *h = hdf_get_obj(hdf->top, name);
if (h) {
HDF *c = hdf_obj_child(h);
while (c) {
err = hdf_copy (hdf, hdf_obj_name(c), c);
if (err != STATUS_OK) break;
c = hdf_obj_next(c);
}
}
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
} else if (s[0] == '=') /* assignment */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':' && s[1] == '=') /* copy */
{
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
HDF *h = hdf_get_obj(hdf->top, value);
if (!h)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Failed to copy a node that is not loaded "
"yet: %s", path, *lineno, value);
return err;
}
err = hdf_copy(hdf, name, h);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '!' && s[1] == '=') /* exec */
{
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
FILE *f = popen(value, "r");
if (f == NULL)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] Failed to exec specified command: %s",
path, *lineno, line->buf);
return err;
}
char *content = _read_file(f);
fclose(f);
int len = strlen(content);
if (len > 0 && content[len - 1] == '\n') {
content[len - 1] = '\0'; // remove \n artifact
}
err = _set_value (hdf, name, content, 1, 1, 0, attr, NULL);
free(content);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == ':') /* link */
{
*s = '\0';
name = neos_strip(name);
s++;
value = neos_strip(s);
err = _set_value (hdf, name, value, 1, 1, 1, attr, NULL);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '{') /* deeper */
{
*s = '\0';
name = neos_strip(name);
lower = hdf_get_obj (hdf, name);
if (lower == NULL)
{
err = _set_value (hdf, name, NULL, 1, 1, 0, attr, &lower);
}
else
{
err = _set_value (lower, NULL, lower->value, 1, 1, 0, attr, NULL);
}
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
err = _hdf_read_string (lower, str, line, path, lineno, include_handle,
1);
if (err != STATUS_OK)
{
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else if (s[0] == '<' && s[1] == '<') /* multi-line assignment */
{
char *m;
int msize = 0;
int mmax = 128;
int l;
*s = '\0';
name = neos_strip(name);
s+=2;
value = neos_strip(s);
l = strlen(value);
if (l == 0)
{
err = nerr_raise(NERR_PARSE,
"[%s:%d] No multi-assignment terminator given: %s", path, *lineno,
line->buf);
return err;
}
m = (char *) malloc (mmax * sizeof(char));
if (m == NULL)
{
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s",
path, *lineno, name);
}
while (_copy_line (str, m+msize, mmax-msize) != 0)
{
(*lineno)++;
if (!strncmp(value, m+msize, l) && isspace(m[msize+l]))
{
m[msize] = '\0';
break;
}
msize += strlen(m+msize);
if (msize + l + 10 > mmax)
{
void *new_ptr;
mmax += 128;
new_ptr = realloc (m, mmax * sizeof(char));
if (new_ptr == NULL)
{
free(m);
return nerr_raise(NERR_NOMEM,
"[%s:%d] Unable to allocate memory for multi-line assignment to %s: size=%d",
path, *lineno, name, mmax);
}
m = (char *) new_ptr;
}
}
err = _set_value (hdf, name, m, 0, 1, 0, attr, NULL);
if (err != STATUS_OK)
{
free (m);
return nerr_pass_ctx(err, "In file %s:%d", path, *lineno);
}
}
else
{
err = nerr_raise(NERR_PARSE, "[%s:%d] Unable to parse line %s", path,
*lineno, line->buf);
return err;
}
}
}
if (expect_end_brace) {
err = nerr_raise(NERR_PARSE, "[%s:%d] Missing matching }", path, *lineno);
return err;
}
return STATUS_OK;
}
static void ips2places(HDF *hdf, HASH *evth)
{
if (!hdf || !evth) return;
mevent_t *evt = (mevent_t*)hash_lookup(evth, "place");
mevent_t *evta = (mevent_t*)hash_lookup(evth, "aic");
if (!evt || !evta) {
mtc_err("can't find event");
return;
}
char *p, *q;
HDF *node, *rnode;
STRING ip;
string_init(&ip);
node = hdf_obj_child(hdf);
while (node) {
p = hdf_get_value(node, "ip", NULL);
q = hdf_get_value(node, "addr", NULL);
if (p && (!q || !*q)) string_appendf(&ip, "%s,", p);
node = hdf_obj_next(node);
}
if (ip.len <= 0) return;
hdf_set_value(evt->hdfsnd, "ip", ip.buf);
MEVENT_TRIGGER_VOID(evt, ip.buf, REQ_CMD_PLACEGET, FLAGS_SYNC);
if (evt->hdfrcv) {
node = hdf_obj_child(hdf);
while (node) {
rnode = hdf_obj_child(evt->hdfrcv);
p = hdf_get_value(node, "ip", NULL);
q = hdf_get_value(node, "addr", NULL);
if (p && (!q || !*q)) {
while (rnode) {
q = hdf_get_value(rnode, "ip", NULL);
if (q && !strcmp(p, q)) break;
else q = NULL;
rnode = hdf_obj_next(rnode);
}
if (q) {
hdf_set_value(node, "addr", hdf_get_value(rnode, "c", NULL));
hdf_set_value(node, "area", hdf_get_value(rnode, "a", NULL));
hdf_set_value(evta->hdfsnd, "uid", hdf_get_value(node, "uid", 0));
hdf_set_value(evta->hdfsnd, "aid", hdf_get_value(node, "aid", 0));
hdf_set_value(evta->hdfsnd, "addr", hdf_get_value(rnode, "c", "Mars"));
MEVENT_TRIGGER_NRET(evta, NULL, REQ_CMD_APPUSERUP, FLAGS_NONE);
} else {
mtc_warn("can't find addr for %s", p);
}
}
node = hdf_obj_next(node);
}
}
string_clear(&ip);
}
static int mevent_start_driver(struct mevent *evt, struct event_driver *d,
void *lib, int num_thread, HDF *matenode)
{
if (evt == NULL || evt->table == NULL || d == NULL) return 0;
struct event_entry *e = d->init_driver();
if (e == NULL) return 0;
num_thread = num_thread < 0 ? 1 : num_thread;
if (num_thread > MAX_THREAD_NUM) {
wlog("plugin %s thread number %d too large, set to default max number %d",
e->name, num_thread, MAX_THREAD_NUM);
mtc_warn("plugin %s thread number %d too large, set to default max number %d",
e->name, num_thread, MAX_THREAD_NUM);
num_thread = MAX_THREAD_NUM;
}
e->num_thread = num_thread;
e->cur_thread = 0;
for (int i = 0; i < num_thread; i++) {
e->op_queue[i] = queue_create();
e->op_thread[i] = malloc(sizeof(pthread_t));
pthread_create(e->op_thread[i], NULL, mevent_start_base_entry, (void*)e);
sleep(1);
e->cur_thread++;
}
e->cur_thread = 0;
HDF *cnode = hdf_obj_child(matenode);
char *dle;
for (int i = 0; cnode && i < MAX_THREAD_NUM; cnode = hdf_obj_next(cnode)) {
void* (*mate_func)(void *arg);
mate_func = dlsym(lib, hdf_obj_value(cnode));
if ((dle = dlerror()) != NULL) {
wlog("unable to find %s %s", hdf_obj_value(cnode), dle);
mtc_err("unable to find %s %s", hdf_obj_value(cnode), dle);
continue;
}
e->mt_thread[i] = malloc(sizeof(pthread_t));
pthread_create(e->mt_thread[i], NULL, mate_func, (void*)e);
i++;
}
uint32_t h;
struct event_chain *c;
h = hash(e->name, e->ksize) % evt->hashlen;
c = evt->table + h;
if (c->len == 0) {
c->first = e;
c->last = e;
c->len = 1;
} else if (c->len <= evt->chainlen) {
e->next = c->first;
c->first->prev = e;
c->first = e;
c->len += 1;
} else {
wlog("unbelieveable, you have more than %d plugins, stop it %s",
evt->chainlen, e->name);
mtc_warn("unbelieveable, you have more than %ld plugins, stop it %s",
evt->chainlen, e->name);
mevent_stop_driver(e);
return 0;
}
return 1;
}
NEOERR* ltpl_parse_file(HASH *dbh, void *lib, char *dir, char *name, HASH *outhash)
{
char *tp = NULL, *tpl = NULL, *val = NULL;
HDF *node = NULL, *dhdf = NULL, *child = NULL;
CSPARSE *cs = NULL;
STRING str;
char fname[_POSIX_PATH_MAX], tok[64];
NEOERR* (*data_handler)(HDF *hdf, HASH *dbh);
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 = mutil_obj_attr(child, "merge");
if (val) {
snprintf(fname, sizeof(fname), "%s/%s", dir, val);
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);
}
err = cs_init(&cs, hdf_get_obj(child, PRE_CFG_DATASET));
JUMP_NOK(err, wnext);
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);
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) {
/*
* 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);
if (hdf_get_obj(child, PRE_CFG_DATASET)) {
err = hdf_init(&dhdf);
JUMP_NOK(err, wnext);
err = hdf_copy(dhdf, NULL, hdf_get_obj(child, PRE_CFG_DATASET));
JUMP_NOK(err, wnext);
snprintf(tok, sizeof(tok), "%s_hdf", hdf_obj_name(child));
err = hash_insert(outhash, (void*)strdup(tok), (void*)dhdf);
JUMP_NOK(err, wnext);
}
}
if (hdf_get_value(child, PRE_CFG_OUTPUT, NULL) != NULL) {
ltpl_prepare_rend(hdf_get_obj(child, PRE_CFG_DATASET), 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)(hdf_get_obj(child, PRE_CFG_DATASET), dbh);
TRACE_NOK(err);
}
}
err = cs_render(cs, &str, mcs_strcb);
JUMP_NOK(err, wnext);
snprintf(fname, sizeof(fname), PATH_DOC"%s",
hdf_get_value(child, PRE_CFG_OUTPUT, "null.html"));
err = mutil_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;
}
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;
}
