NEOERR* oms_camer_data_del(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");
char *aname, *uname;
NEOERR *err;
APP_CHECK_LOGIN();
HDF_GET_STR(cgi->hdf, PRE_QUERY".uname", uname);
LEGAL_CK_ANAME(uname);
hdf_set_value(evt->hdfsnd, "aname", aname);
hdf_set_value(evt->hdfsnd, "uname", uname);
MEVENT_TRIGGER(evt, aname, REQ_CMD_APPUSEROUT, FLAGS_NONE);
evt = (mevent_t*)hash_lookup(evth, "msg");
if (evt) {
hdf_set_value(evt->hdfsnd, "name", uname);
hdf_set_value(evt->hdfsnd, "name2", aname);
MEVENT_TRIGGER(evt, uname, REQ_CMD_DEL_BOTH, FLAGS_NONE);
}
return STATUS_OK;
}
static NEOERR* member_after_login(CGI *cgi, HASH *dbh, char *mname)
{
char tm[LEN_TM_GMT], *p, mmsn[LEN_CK];
mdb_conn *db = hash_lookup(dbh, "main");
NEOERR *err;
memset(mmsn, 0x0, sizeof(mmsn));
mstr_rand_string(mmsn, sizeof(mmsn));
mutil_getdatetime_gmt(tm, sizeof(tm), "%A, %d-%b-%Y %T GMT", ONE_WEEK);
/*
* set cookie
*/
neos_url_escape(mname, &p, NULL);
cgi_cookie_set(cgi, "mname", mname, NULL, SITE_DOMAIN, tm, 1, 0);
cgi_cookie_set(cgi, "mname_esc", p, NULL, SITE_DOMAIN, tm, 1, 0);
cgi_cookie_set(cgi, "mmsn", mmsn, NULL, SITE_DOMAIN, tm, 1, 0);
free(p);
hdf_set_value(cgi->hdf, PRE_OUTPUT".mname", mname);
hdf_set_value(cgi->hdf, PRE_OUTPUT".mmsn", mmsn);
MDB_EXEC(db, NULL, "UPDATE member SET mmsn=$1 WHERE mname=$2",
"ss", mmsn, mname);
return STATUS_OK;
}
int main(int argc, char *argv[])
{
NEOERR *err;
HDF *hdf, *h2;
err = hdf_init(&hdf);
if (err != STATUS_OK)
{
nerr_log_error(err);
return -1;
}
err = hdf_set_value(hdf, "CGI.Foo", "Bar");
if (err)
{
nerr_log_error(err);
return -1;
}
err = hdf_set_value(hdf, "CGI.Foo", "Baz");
if (err)
{
nerr_log_error(err);
return -1;
}
h2 = hdf_get_obj(hdf, "CGI");
err = hdf_set_value(h2, "Foo", "Bang");
hdf_dump(hdf, NULL);
hdf_destroy(&hdf);
return 0;
}
NEOERR* oms_bill_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");
char *aname;
NEOERR *err;
APP_CHECK_ADMIN();
SET_ADMIN_ACTION(evt->hdfrcv, cgi->hdf);
hdf_copy(cgi->hdf, PRE_OUTPUT".appinfo", evt->hdfrcv);
int state = hdf_get_int_value(evt->hdfrcv, "state", LCS_ST_FREE);
if (state <= LCS_ST_FREE) return STATUS_OK;
evt = hash_lookup(evth, "bank");
hdf_set_value(evt->hdfsnd, "aname", aname);
MEVENT_TRIGGER(evt, aname, REQ_CMD_BANK_INFO, FLAGS_SYNC);
hdf_copy(cgi->hdf, PRE_OUTPUT".bankinfo", evt->hdfrcv);
hdf_set_value(evt->hdfsnd, "aname", aname);
hdf_copy(evt->hdfsnd, NULL, hdf_get_obj(cgi->hdf, PRE_QUERY));
MEVENT_TRIGGER(evt, aname, REQ_CMD_BANK_GETBILL, FLAGS_SYNC);
hdf_copy(cgi->hdf, PRE_OUTPUT, evt->hdfrcv);
return STATUS_OK;
}
void lerr_opfinish_json(NEOERR *err, HDF *hdf)
{
if (err == STATUS_OK) {
hdf_set_value(hdf, PRE_SUCCESS, "1");
mcs_set_int_attr(hdf, PRE_SUCCESS, "type", CNODE_TYPE_INT);
return;
}
hdf_remove_tree(hdf, PRE_SUCCESS);
NEOERR *neede = mcs_err_valid(err);
/* set PRE_ERRXXX with the most recently err */
mcs_set_int_value_with_type(hdf, PRE_ERRCODE, neede->error, CNODE_TYPE_INT);
if (!hdf_get_obj(hdf, PRE_ERRMSG)) {
hdf_set_valuef(hdf, "%s=%s:%d %s",
PRE_ERRMSG, neede->file, neede->lineno, neede->desc);
}
STRING str; string_init(&str);
nerr_error_traceback(err, &str);
mtc_err("%s", str.buf);
hdf_set_value(hdf, PRE_ERRTRACE, str.buf);
nerr_ignore(&err);
string_clear(&str);
}
void lerr_opfinish_json(NEOERR *err, HDF *hdf)
{
if (err == STATUS_OK) {
hdf_set_value(hdf, PRE_SUCCESS, "1");
return;
}
hdf_remove_tree(hdf, PRE_SUCCESS);
char buf[1024], errname[128];
NEOERR *neede = mcs_err_valid(err);
if (!neede) neede = err;
snprintf(buf, sizeof(buf), "%s:%d %s",
neede->file, neede->lineno,
_lookup_errname(neede, errname, sizeof(errname)));
/* set PRE_ERRXXX with the most recently err */
if (!hdf_get_obj(hdf, PRE_ERRMSG)) {
hdf_set_value(hdf, PRE_ERRMSG, buf);
}
hdf_set_int_value(hdf, PRE_ERRCODE, neede->error);
STRING str; string_init(&str);
nerr_error_traceback(err, &str);
mtc_err("%s", str.buf);
hdf_set_value(hdf, PRE_ERRTRACE, str.buf);
nerr_ignore(&err);
string_clear(&str);
}
static NEOERR* aux_cmd_emailadd(struct aux_entry *e, QueueEntry *q)
{
STRING str; string_init(&str);
char sum[LEN_MD5], *content;
NEOERR *err;
mdb_conn *db = e->db;
REQ_GET_PARAM_STR(q->hdfrcv, "content", content);
mstr_md5_str(content, sum);
hdf_set_value(q->hdfrcv, "checksum", sum);
HDF *node = hdf_get_child(q->hdfrcv, "mto");
insert:
if (node) hdf_set_value(q->hdfrcv, "to", hdf_obj_value(node));
err = mdb_build_incol(q->hdfrcv,
hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.email"),
&str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "INSERT INTO email %s", NULL, str.buf);
string_clear(&str);
if (node) {
node = hdf_obj_next(node);
if (node) goto insert;
}
return STATUS_OK;
}
NEOERR* member_exist_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = hash_lookup(evth, "member");
char *mname;
MCS_NOT_NULLB(cgi->hdf, evt);
HDF_GET_STR(cgi->hdf, PRE_QUERY".mname", mname);
hdf_set_value(evt->hdfsnd, "mname", mname);
mevent_trigger(evt, mname, REQ_CMD_MEMBER_GET, FLAGS_SYNC);
if (PROCESS_OK(evt->errcode)) {
hdf_set_value(cgi->hdf, PRE_OUTPUT".exist", "1");
hdf_set_value(cgi->hdf, PRE_OUTPUT".msg", "用户已被注册");
} else if (evt->errcode == LERR_MEMBER_NEXIST) {
hdf_set_value(cgi->hdf, PRE_OUTPUT".exist", "0");
hdf_set_value(cgi->hdf, PRE_OUTPUT".msg", "用户还未注册");
} else {
return nerr_raise(evt->errcode, "get member %s info failure %d",
evt->ename, evt->errcode);
}
return STATUS_OK;
}
void mjson_str2hdf(HDF *node, struct json_object *o)
{
if (!node) return;
char *s = hdf_obj_value(node);
struct json_object *obj;
struct array_list *list;
enum json_type type;
HDF *cnode;
char tok[64];
int i;
char *key; struct json_object *val; struct lh_entry *entry;
obj = o;
if (!obj && s && *s) {
obj = json_tokener_parse(s);
}
if (!obj || obj < 0) return;
type = json_object_get_type(obj);
switch (type) {
case json_type_boolean:
hdf_set_int_value(node, NULL, json_object_get_boolean(obj));
return;
case json_type_int:
hdf_set_int_value(node, NULL, json_object_get_int(obj));
return;
case json_type_double:
sprintf(tok, "%f", json_object_get_double(obj));
hdf_set_value(node, NULL, tok);
return;
case json_type_string:
hdf_set_value(node, NULL, json_object_get_string(obj));
return;
case json_type_array:
list = json_object_get_array(obj);
for (i = 0; i < list->length; i++) {
sprintf(tok, "%d", i);
hdf_get_node(node, tok, &cnode);
mjson_str2hdf(cnode, (struct json_object*)list->array[i]);
}
return;
case json_type_object:
for(entry = json_object_get_object(obj)->head;
(entry ? (key = (char*)entry->k,
val = (struct json_object*)entry->v, entry) : 0);
entry = entry->next) {
hdf_get_node(node, key, &cnode);
mjson_str2hdf(cnode, val);
}
return;
default:
return;
}
}
static int diary_handle_feed_rss(request_rec *r, diary_conf *conf)
{
HDF *hdf;
CSPARSE *cs;
NEOERR *cs_err;
STRING cs_err_str;
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, "diary_handle_feed_rss()");
hdf_init(&hdf);
hdf_set_value(hdf, "hdf.loadpaths.1", conf->path);
hdf_set_value(hdf, "diary.title", conf->title);
hdf_set_value(hdf, "diary.uri", conf->uri);
cs_err = hdf_read_file(hdf, INDEX_HDF);
if(cs_err){
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "cannot read index.hdf.");
hdf_destroy(&hdf);
return HTTP_INTERNAL_SERVER_ERROR;
}
//hdf_dump(hdf, NULL);
cs_err = cs_init(&cs, hdf);
if(cs_err){
string_init(&cs_err_str);
nerr_error_string(cs_err, &cs_err_str);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"error at cs_init(): %s", cs_err_str.buf);
cs_destroy(&cs);
hdf_destroy(&hdf);
return HTTP_INTERNAL_SERVER_ERROR;
}
cgi_register_strfuncs(cs);
cs_err = cs_parse_string(cs, strdup(RSS_TMPL), RSS_TMPL_LEN);
if(cs_err){
string_init(&cs_err_str);
nerr_error_string(cs_err, &cs_err_str);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
"error in cs_parse_string(): %s", cs_err_str.buf);
cs_destroy(&cs);
hdf_destroy(&hdf);
return HTTP_INTERNAL_SERVER_ERROR;
}
r->content_type = "application/rss+xml";
cs_render(cs, r, diary_cs_render_cb);
cs_destroy(&cs);
hdf_destroy(&hdf);
return OK;
}
int main(int argc, char **argv, char **envp)
{
CGI *cgi = NULL;
NEOERR *err;
mdb_conn *conn = NULL;
char *s, *u, *p, *r, *jcbk;
mtc_init("test");
mconfig_parse_file(SITE_CONFIG, &g_cfg);
if (mdb_init(&conn, DB_DSN) != MDB_ERR_NONE) {
mtc_err("init db error %s", mdb_get_errmsg(conn));
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("{errcode: %d}", SAM_ERR_INIT);
return 1;
}
err = cgi_init(&cgi, NULL);
if (err != STATUS_OK) {
mtc_err("init cgi error");
printf("Content-Type: text/html; charset=UTF-8\r\n\r\n");
printf("初始化错误");
return 1;
}
err = cgi_parse(cgi);
if (err != STATUS_OK) {
mtc_err("parse cgi error");
hdf_set_value(cgi->hdf, PRE_OUTPUT".errmsg", "初始化出错");
goto finish;
}
u = hdf_get_value(cgi->hdf, PRE_COOKIE".samuser", NULL);
s = hdf_get_value(cgi->hdf, PRE_COOKIE".samkey", NULL);
if (s && u) {
if (user_has_login(conn, u, s)) {
hdf_set_copy(cgi->hdf, PRE_OUTPUT".samuser", PRE_COOKIE".samuser");
hdf_set_copy(cgi->hdf, PRE_OUTPUT".samkey", PRE_COOKIE".samkey");
hdf_set_value(cgi->hdf, PRE_OUTPUT".rcode", "1");
goto finish;
}
}
hdf_set_value(cgi->hdf, PRE_OUTPUT".rcode", "2");
finish:
cgi_display(cgi, F_TPL_TEST);
cgi_destroy(&cgi);
mdb_destroy(conn);
return 0;
}
static NEOERR* aux_cmd_inboxadd(struct aux_entry *e, QueueEntry *q)
{
STRING str; string_init(&str);
NEOERR *err;
mdb_conn *db = e->db;
HDF *node = hdf_get_child(q->hdfrcv, "mmid");
insert:
if (node) hdf_set_value(q->hdfrcv, "mid", hdf_obj_value(node));
err = mdb_build_incol(q->hdfrcv,
hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.inbox"),
&str);
if (err != STATUS_OK) return nerr_pass(err);
MDB_EXEC(db, NULL, "INSERT INTO inbox %s", NULL, str.buf);
string_clear(&str);
if (node) {
node = hdf_obj_next(node);
if (node) goto insert;
}
return STATUS_OK;
}
NEOERR* oms_users_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");
char *aname;
NEOERR *err;
APP_CHECK_ADMIN();
SET_ADMIN_ACTION(evt->hdfrcv, cgi->hdf);
hdf_copy(cgi->hdf, PRE_OUTPUT".appinfo", evt->hdfrcv);
/*
* prepare data
*/
hdf_set_value(evt->hdfsnd, "pname", aname);
hdf_copy(evt->hdfsnd, NULL, hdf_get_obj(cgi->hdf, PRE_QUERY));
/*
* trigger
*/
MEVENT_TRIGGER(evt, aname, REQ_CMD_APP_O_USERS, FLAGS_SYNC);
hdf_copy(cgi->hdf, PRE_OUTPUT, evt->hdfrcv);
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* mcs_set_uint_value(HDF *hdf, char *name, unsigned int value)
{
char buf[256];
snprintf(buf, sizeof(buf), "%u", value);
return nerr_pass(hdf_set_value(hdf, name, buf));
}
NEOERR* mcs_set_int64_value(HDF *hdf, char *name, int64_t val)
{
char buf[256];
snprintf(buf, sizeof(buf), "%ld", val);
return nerr_pass(hdf_set_value(hdf, name, buf));
}
NEOERR* mcs_set_float_value(HDF *hdf, char *name, float value)
{
char buf[256];
snprintf(buf, sizeof(buf), "%f", value);
return nerr_pass(hdf_set_value(hdf, name, buf));
}
JNIEXPORT void JNICALL Java_org_clearsilver_HDF__1setValue(
JNIEnv *env, jclass objClass,
jint hdf_obj_ptr, jstring j_hdfname, jstring j_value) {
HDF *hdf = (HDF *)hdf_obj_ptr;
NEOERR *err;
const char *hdfname;
const char *value;
if (!j_hdfname) {
throwNullPointerException(env, "hdfname argument was null");
return;
}
hdfname = (*env)->GetStringUTFChars(env, j_hdfname, 0);
if (j_value) {
value = (*env)->GetStringUTFChars(env, j_value, 0);
} else {
value = NULL;
}
err = hdf_set_value(hdf, hdfname, value);
(*env)->ReleaseStringUTFChars(env, j_hdfname, hdfname);
if (value) {
(*env)->ReleaseStringUTFChars(env, j_value, value);
}
if (err != STATUS_OK) {
// Throw an exception
jNeoErr(env, err);
}
}
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);
}
}
NEOERR* member_check_login_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mdb_conn *db = hash_lookup(dbh, "main");
char *mname, *mmsn;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, db);
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".mname", mname);
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".mmsn", mmsn);
if (!mname || !mmsn) {
HDF_GET_STR_IDENT(cgi->hdf, PRE_COOKIE".mname", mname);
HDF_GET_STR_IDENT(cgi->hdf, PRE_COOKIE".mmsn", mmsn);
}
hdf_set_value(cgi->hdf, PRE_RESERVE".mname", mname);
MDB_QUERY_RAW(db, "member", _COL_MEMBER, "mname=$1", "s", mname);
err = mdb_set_row(cgi->hdf, db, _COL_MEMBER, PRE_OUTPUT".member", MDB_FLAG_Z);
if (err != STATUS_OK) return nerr_pass(err);
char *mmsndb = hdf_get_value(cgi->hdf, PRE_OUTPUT".member.mmsn", NULL);
if (!mmsndb || strcmp(mmsndb, mmsn)) {
hdf_remove_tree(cgi->hdf, PRE_OUTPUT".member");
return nerr_raise(LERR_NOTLOGIN, "msn don't match");
}
return STATUS_OK;
}
NEOERR* oms_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");
char *aname;
NEOERR *err;
APP_CHECK_LOGIN();
SET_ADMIN_ACTION(evt->hdfrcv, cgi->hdf);
hdf_copy(cgi->hdf, PRE_OUTPUT".appinfo", evt->hdfrcv);
/*
* prepare data
*/
hdf_set_value(evt->hdfsnd, "aname", aname);
hdf_set_int_value(evt->hdfsnd, "limit", MAX_USERS_PERADMIN);
/*
* trigger
*/
MEVENT_TRIGGER(evt, aname, REQ_CMD_APPUSERS, FLAGS_SYNC);
hdf_copy(cgi->hdf, PRE_OUTPUT, evt->hdfrcv);
/*
* TODO: remove ips2places() when userinfo's addr all filled
*/
ips2places(hdf_get_obj(cgi->hdf, PRE_OUTPUT".userlist"), evth);
return STATUS_OK;
}
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;
}
bool Tree::SerializeToHdfInternal(struct _hdf *hdf,
bool only_nodes_with_value) const
{
for (std::map<std::string, Tree *>::const_iterator p = _children.begin();
p != _children.end(); ++p) {
if (!p->second->SerializeToHdfInternal(hdf, only_nodes_with_value)) {
return false;
}
}
// Any intermediate nodes with empty value are filtered out.
// Leaf nodes are controlled by only_nodes_with_value.
if (_value.empty()) {
if (!_children.empty() || only_nodes_with_value) {
return true;
}
}
NEOERR *err = hdf_set_value(hdf, _full_path.c_str(), _value.c_str());
if (err != STATUS_OK) {
nerr_ignore(&err);
return false;
}
return true;
}
int lutil_fill_layout_by_file(mdb_conn *conn, file_t *file, HDF *hdf)
{
ULIST *files = NULL;
file_t *fl;
int ret, errsn;
PRE_DBOP(hdf, conn);
if (file == NULL)
return RET_RBTOP_INPUTE;
hdf_set_value(hdf, PRE_LAYOUT".title", file->remark);
ret = file_get_infos_by_uri(conn, file->uri, &files, &errsn);
if (ret != RET_RBTOP_OK) {
mtc_err("get files's infos by uri %s failure %d",
file->uri, errsn);
return ret;
}
MLIST_ITERATE(files, fl) {
hdf_set_valuef(hdf, "%s.crumbs.%d.name=%s",
PRE_LAYOUT, t_rsv_i, fl->remark);
if (fl->reqtype == CGI_REQ_AJAX) {
hdf_set_valuef(hdf, "%s.crumbs.%d.href=%s.html",
PRE_LAYOUT, t_rsv_i, fl->uri);
} else {
hdf_set_valuef(hdf, "%s.crumbs.%d.href=%s",
PRE_LAYOUT, t_rsv_i, fl->uri);
}
}
NEOERR* oms_secy_data_mod(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");
char *aname, *uname;
NEOERR *err;
HDF_GET_STR(cgi->hdf, PRE_QUERY".aname", uname);
APP_CHECK_ADMIN_OTHER(uname);
hdf_set_value(evt->hdfsnd, "pname", aname);
hdf_set_value(evt->hdfsnd, "aname", uname);
MEVENT_TRIGGER(evt, aname, REQ_CMD_APP_SETSECY, FLAGS_NONE);
return STATUS_OK;
}
NEOERR* member_logout_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = hash_lookup(evth, "member");
char *mname;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, evt);
MEMBER_CHECK_LOGIN();
hdf_set_value(evt->hdfsnd, "mname", mname);
hdf_set_value(evt->hdfsnd, "mmsn", "0");
MEVENT_TRIGGER(evt, mname, REQ_CMD_MEMBER_UP, FLAGS_NONE);
return STATUS_OK;
}
static int AmbaPMPage_get_params_fb () {
MESSAGE* msg = (MESSAGE*)receive_buffer->data;
char name[NAME_LEN] = {0};
uint32_t *camtype = (uint32_t*)(msg->data);
uint32_t* pmid;
if((msg->cmd_id == GET_CAM_TYPE) && (msg->status == STATUS_SUCCESS)) {
sprintf(name, "%d", *camtype);
hdf_set_value(cgi->hdf, "camtype", name);
}
msg = (MESSAGE*)(receive_buffer->data + sizeof(ENC_COMMAND_ID) + sizeof(uint32_t) + sizeof(uint32_t));
if((msg->cmd_id == GET_PRVACY_MASK) && (msg->status == STATUS_SUCCESS)) {
pmid = (uint32_t *)(msg->data);
sprintf(name, "%d", *pmid);
hdf_set_value(cgi->hdf, "pm_id", name);
}
return 0;
}
int main(void)
{
GC_INIT();
TF_Buffer *buffer = TF_GetAllOpList();
Tensorflow__OpList *op_list = tensorflow__op_list__unpack(NULL, buffer->length, buffer->data);
HDF *hdf;
hdf_init(&hdf);
for (int i=0; i<op_list->n_op; i++) {
struct _Tensorflow__OpDef *op = op_list->op[i];
char variable[256];
char value[256];
snprintf(variable, 256, "Op.%s.name", op->name);
snprintf(value, 256, "tf-%s", kebab_case(op->name));
hdf_set_value(hdf, variable, value);
for (int j=0; j<op->n_input_arg; j++) {
Tensorflow__OpDef__ArgDef *arg = op->input_arg[j];
snprintf(variable, 256, "Op.%s.input_arg.%s", op->name, arg->name);
const char *multiple = arg->number_attr && *arg->number_attr ? "list" : "single";
hdf_set_value(hdf, variable, multiple);
};
for (int j=0; j<op->n_attr; j++) {
Tensorflow__OpDef__AttrDef *attr = op->attr[j];
snprintf(variable, 256, "Op.%s.attr.%s", op->name, attr->name);
snprintf(value, 256, "%s", attr->type);
hdf_set_value(hdf, variable, value);
};
snprintf(variable, 256, "Op.%s.n_output", op->name);
snprintf(value, 256, "%d", op->n_output_arg);
hdf_set_value(hdf, variable, value);
};
CSPARSE *parse;
cs_init(&parse, hdf);
cs_parse_file(parse, "tensorflow.scm.in");
cs_render(parse, stdout, output);
cs_destroy(&parse);
hdf_destroy(&hdf);
tensorflow__op_list__free_unpacked(op_list, NULL);
TF_DeleteBuffer(buffer);
}
static void wiki_output(MMIOT *doc, request_rec *r)
{
char *title;
int ret;
int size;
char *p;
wiki_conf *conf;
list_t *css;
HDF *hdf;
CSPARSE *cs;
int i;
conf =
(wiki_conf *) ap_get_module_config(r->per_dir_config,
&wiki_module);
ret = mkd_compile(doc, MKD_TOC | MKD_AUTOLINK);
hdf_init(&hdf);
if(conf->name){
hdf_set_value(hdf, "wikiname", conf->name);
}
title = mkd_doc_title(doc);
if(title == NULL){
title = "notitle";
}
hdf_set_value(hdf, "title", title);
for(i=0, css = conf->css; css; i++, css = (list_t *) css->next){
hdf_set_valuef(hdf, "css.%d=%s", i, (char *)css->data);
}
if ((size = mkd_document(doc, &p)) != EOF) {
hdf_set_value(hdf, "document", p);
}
cs_init(&cs, hdf);
cs_parse_string(cs, strdup(DEFAULT_TEMPLATE), strlen(DEFAULT_TEMPLATE));
cs_render(cs, r, cs_output);
hdf_destroy(&hdf);
cs_destroy(&cs);
}
NEOERR* mcs_set_value_with_type(HDF *hdf, char *name, char *value,
CnodeType type)
{
NEOERR *err;
err = hdf_set_value(hdf, name, value);
if (err != STATUS_OK) return nerr_pass(err);
return nerr_pass(mcs_set_int_attr(hdf, name, "type", type));
}
