void ltpl_prepare_rend(HDF *hdf, char *tpl)
{
char key[LEN_ST];
HDF *tmphdf, *ahdf;
if (hdf == NULL) return;
/*
* merge dataset from g_cfg
*/
snprintf(key, sizeof(key), PRE_CFG_DATASET".%s", tpl);
tmphdf = hdf_get_obj(g_cfg, key);
if (tmphdf != NULL) hdf_copy(hdf, PRE_CFG_LAYOUT, tmphdf);
/*
* special actions
*/
tmphdf = hdf_get_child(hdf, PRE_WALK_SACTION);
while (tmphdf) {
snprintf(key, sizeof(key), PRE_LAYOUT".%s", hdf_obj_value(tmphdf));
ahdf = hdf_get_obj(hdf, key);
if (ahdf) hdf_copy(hdf, PRE_LAYOUT".actions", ahdf);
tmphdf = hdf_obj_next(tmphdf);
}
/*
* set classes
*/
char *pos = hdf_get_value(hdf, "Layout.tabpart", NULL);
if (pos) hdf_set_valuef(hdf, "Layout.tabs.%s.class=selected", pos);
pos = hdf_get_value(hdf, "Layout.actionpart", NULL);
if (pos) hdf_set_valuef(hdf, "Layout.actions.%s.class=selected", pos);
}
int tjt_add_atom(HDF *hdf, mdb_conn *conn, session_t *ses)
{
PRE_DBOP(hdf, conn);
int aid, fid, uid;
char *img, *exp, tbl[LEN_TB];
int ret;
uid = ses->member->uin;
aid = ses->file->aid;
fid = ses->file->id;
img = hdf_get_value(hdf, PRE_QUERY".img", "");
exp = hdf_get_value(hdf, PRE_QUERY".exp", "");
snprintf(tbl, sizeof(tbl), "tjt_%d", aid);
ret = MDATA_SET(conn, EVT_PLUGIN_TJT, NULL, FLAGS_NONE,
"INSERT INTO %s (fid, uid, img, exp) "
" VALUES (%d, %d, $1, $2)", "ss",
tbl, fid, uid, img, exp);
if (ret != MDB_ERR_NONE) {
mtc_err("add file err %s", mdb_get_errmsg(conn));
return RET_RBTOP_INSERTE;
}
tjt_refresh_info(aid, fid);
return RET_RBTOP_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;
}
NEOERR* session_init(CGI *cgi, HASH *dbh, session_t **ses)
{
session_t *lses;
char tok[_POSIX_PATH_MAX];
*ses = NULL;
lses = calloc(1, sizeof(session_t));
if (!lses) return nerr_raise(NERR_NOMEM, "calloc memory for session_t failure");
lses->reqtype = CGI_REQ_HTML;
hdf_get_copy(cgi->hdf, PRE_COOKIE".uname", &lses->uname, NULL);
char *uri = hdf_get_value(cgi->hdf, PRE_REQ_URI_RW, NULL);
if (!uri) {
uri = "terminal";
lses->reqtype = CGI_REQ_TERMINAL;
}
/* TODO uniq req uri */
//uri = mmisc_str_uniq(uri, '/');
mmisc_str_repchr(uri, '/', '_');
uri = mmisc_str_strip(uri, '_');
if (!strncmp(uri, "json_", 5)) {
uri = uri+5;
lses->reqtype = CGI_REQ_AJAX;
}
switch (CGI_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);
/* process cache */
HDF *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);
}
*ses = lses;
return STATUS_OK;
}
char* mcs_prepend_string_value(HDF *node, char *key, char *str)
{
if (!node || !key) return NULL;
char *ov = hdf_get_value(node, key, "");
hdf_set_valuef(node, "%s=%s%s", key, str, ov);
return hdf_get_value(node, key, NULL);
}
NEOERR* member_pic_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = hash_lookup(evth, "member");
HDF *node;
char *s = NULL, *defs = NULL, *path, *size;
MCS_NOT_NULLB(cgi->hdf, evt);
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".defs", defs);
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".fpath", path);
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".fsize", size);
node = hdf_get_child(cgi->hdf, PRE_QUERY".type");
if (!node) HDF_GET_STR(cgi->hdf, PRE_QUERY".type", s);
hdf_copy(evt->hdfsnd, NULL, hdf_get_obj(cgi->hdf, PRE_QUERY));
MEVENT_TRIGGER(evt, NULL, REQ_CMD_MEMBER_PRIV_GET, FLAGS_SYNC);
if (s) goto getval;
while (node) {
s = hdf_obj_value(node);
getval:
/*
* turn & into & in url format
*/
mstr_html_unescape(evt->hdfrcv, s);
s = hdf_get_value(evt->hdfrcv, s, NULL);
if (s && *s) {
if (!strncmp(s, "http:", 5)) {
hdf_set_value(cgi->hdf, PRE_OUTPUT".302", s);
return STATUS_OK;
}
break;
}
if (node) node = hdf_obj_next(node);
}
if (!s || !*s) {
if (!defs) s = SITE_DOMAIN;
else if (!strcmp(defs, "segv")) return STATUS_OK;
else s = defs;
}
if (!path) path = hdf_get_value(g_cfg,
"Config.font.member.path",
"/usr/share/ttf/Times.ttf");
if (!size) size = hdf_get_value(g_cfg, "Config.font.member.size", "14.");
return nerr_pass(mimg_create_from_string(s, path, atof(size), &ses->data));
}
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;
}
void
cmd_del(CGI *cgi)
{
struct ipc_torrent t;
char *torrent;
torrent = hdf_get_value(cgi->hdf, "Query.torrent", "None");
btpd_connect();
if (torrent_spec(torrent, &t))
handle_ipc_res(btpd_del(ipc, &t), "del", torrent);
cgi_redirect(cgi, "%s", hdf_get_value(cgi->hdf, "CGI.ScriptName", ""));
}
int TestCompare(const void* pa, const void* pb)
{
HDF **a = (HDF **)pa;
HDF **b = (HDF **)pb;
float aVal,bVal;
aVal = atof(hdf_get_value(*a,"val","0"));
bVal = atof(hdf_get_value(*b,"val","0"));
printf("TestCompare aVal=%f [%s] bVal=%f [%s]\n",aVal,hdf_get_value(*a,"name","?"),bVal,hdf_get_value(*b,"name","?"));
if (aVal<bVal) return -1;
if (aVal==bVal) return 0;
return 1;
}
NEOERR* member_new_data_add(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = hash_lookup(evth, "member");
char *mnick, *mname, *mid;
MCS_NOT_NULLB(cgi->hdf, evt);
HDF_GET_STR(cgi->hdf, PRE_QUERY".mnick", mnick);
HDF_GET_STR(cgi->hdf, PRE_QUERY".mname", mname);
LEGAL_CHECK_NICK(mnick);
LEGAL_CHECK_NAME(mname);
hdf_copy(evt->hdfsnd, NULL, hdf_get_obj(cgi->hdf, PRE_QUERY));
MEVENT_TRIGGER(evt, mname, REQ_CMD_MEMBER_ADD, FLAGS_SYNC);
mid = hdf_get_value(evt->hdfrcv, "mid", NULL);
member_after_login(cgi, evth, mname, mnick, mid);
char *s;
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".mnick", s);
hdf_set_value(cgi->hdf, PRE_RESERVE".event.es_one", s);
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".mname", s);
hdf_set_value(cgi->hdf, PRE_RESERVE".event.es_two", s);
HDF *node = hdf_get_obj(cgi->hdf, PRE_RESERVE".event");
return nerr_pass(trace_event(node, evth, ses, TRACE_TYPE_MEMBER_REG));
}
NEOERR* blog_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "aux");
mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic");
char *aname, *author;
NEOERR *err;
LPRE_DBOP(cgi->hdf, conn);
APP_CHECK_LOGIN();
if (hdf_get_int_value(evt->hdfrcv, "state", 0) < LCS_ST_ADMIN)
return nerr_raise(LERR_LIMIT, "%s wan't be admin", aname);
int bid = hdf_get_int_value(cgi->hdf, PRE_QUERY".bid", 0);
/* just rend tpl */
if (bid == 0) return STATUS_OK;
MDB_QUERY_RAW(conn, "blog", BLOG_COL, " id=%d ",
NULL, bid, BLOG_ST_NORMAL);
err = mdb_set_row(cgi->hdf, conn, BLOG_COL, PRE_OUTPUT".blog");
if (err != STATUS_OK) return nerr_pass(err);
author = hdf_get_value(cgi->hdf, PRE_OUTPUT".blog.author", NULL);
if (!author) return nerr_raise(LERR_MISS_DATA, "%s not exist", aname);
if (strcmp(aname, author))
return nerr_raise(LERR_LIMIT, "%s not %s", aname, author);
return STATUS_OK;
}
JNIEXPORT jstring JNICALL Java_org_clearsilver_HDF__1getValue(
JNIEnv *env, jclass objClass, jint hdf_obj_ptr, jstring j_hdfname,
jstring j_default_value) {
HDF *hdf = (HDF *)hdf_obj_ptr;
const char *r;
const char *hdfname;
const char *default_value;
jstring retval;
if (!j_hdfname) {
throwNullPointerException(env, "hdfname argument was null");
return 0;
}
hdfname = (*env)->GetStringUTFChars(env,j_hdfname,0);
if (!j_default_value) {
default_value = NULL;
} else {
default_value = (*env)->GetStringUTFChars(env, j_default_value, 0);
}
r = hdf_get_value(hdf, hdfname, default_value);
(*env)->ReleaseStringUTFChars(env, j_hdfname, hdfname);
retval = (r ? (*env)->NewStringUTF(env, r) : 0);
if (default_value) {
(*env)->ReleaseStringUTFChars(env, j_default_value, default_value);
}
return retval;
}
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;
}
static struct event_entry* aic_init_driver(void)
{
struct aic_entry *e = calloc(1, sizeof(struct aic_entry));
if (e == NULL) return NULL;
NEOERR *err;
e->base.name = (unsigned char*)strdup(PLUGIN_NAME);
e->base.ksize = strlen(PLUGIN_NAME);
e->base.process_driver = aic_process_driver;
e->base.stop_driver = aic_stop_driver;
char *dbsn = hdf_get_value(g_cfg, CONFIG_PATH".dbsn", NULL);
err = mdb_init(&e->db, dbsn);
JUMP_NOK(err, error);
e->cd = cache_create(hdf_get_int_value(g_cfg, CONFIG_PATH".numobjs", 1024), 0);
if (e->cd == NULL) {
wlog("init cache failure");
goto error;
}
return (struct event_entry*)e;
error:
if (e->base.name) free(e->base.name);
if (e->db) mdb_destroy(e->db);
if (e->cd) cache_free(e->cd);
free(e);
return NULL;
}
NEOERR* member_reset_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt;
char *mnick, *mname, *mname_esc = NULL;
char rlink[LEN_CK];
NEOERR *err;
HDF_GET_STR(cgi->hdf, PRE_QUERY".mname", mname);
mstr_rand_string(rlink, sizeof(rlink));
evt = (mevent_t*)hash_lookup(evth, "member");
MCS_NOT_NULLB(cgi->hdf, evt);
hdf_set_value(evt->hdfsnd, "mname", mname);
hdf_set_value(evt->hdfsnd, "rlink", rlink);
MEVENT_TRIGGER(evt, mname, REQ_CMD_MEMBER_SETRLINK, FLAGS_SYNC);
mnick = hdf_get_value(evt->hdfrcv, "mnick", NULL);
neos_url_escape(mname, &mname_esc, NULL);
hdf_set_value(cgi->hdf, PRE_DATASET".Layout.mnick", mnick);
hdf_set_value(cgi->hdf, PRE_DATASET".Layout.mname_esc", mname_esc);
hdf_set_value(cgi->hdf, PRE_DATASET".Layout.rlink", rlink);
err = email_add(cgi->hdf, evth, "MemberReset", mname);
if (err != STATUS_OK) return nerr_pass(err);
SAFE_FREE(mname_esc);
return STATUS_OK;
}
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;
}
bool CGI::TranslateFile(void *cgi, const char *key, std::map<std::string, File> *files)
{
::CGI *c = reinterpret_cast< ::CGI *>(cgi);
FILE *fp = cgi_filehandle(c, key);
if (!fp) {
return false;
}
std::string path;
if (key) {
path = std::string("Query.") + key;
} else {
path = "PUT";
}
long size = -1;
if (fseek(fp, 0, SEEK_END) == 0) {
size = ftell(fp);
}
rewind(fp);
File file;
file._fp = fp;
file._size = static_cast<size_t>(size);
const char *name = hdf_get_value(c->hdf, path.c_str(), NULL);
if (name) {
file._name = name;
}
std::string stype = path + ".Type";
const char *type = hdf_get_value(c->hdf, stype.c_str(), NULL);
if (type) {
file._type = type;
}
std::string sname = path + ".FileName";
const char *tmp_name = hdf_get_value(c->hdf, sname.c_str(), NULL);
if (tmp_name) {
file._tmp_name = tmp_name;
}
files->insert(std::make_pair(key ? key : "", file));
return true;
}
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 {
NEOERR* city_ip_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = hash_lookup(evth, "city");
char *ip;
if (!cgi || !cgi->hdf || !evt) return nerr_raise(NERR_ASSERT, "paramter null");
ip = hdf_get_value(cgi->hdf, PRE_QUERY".ip", NULL);
if (!ip) ip = hdf_get_value(cgi->hdf, PRE_REQ_IP, "0.0.0.0");
hdf_set_value(evt->hdfsnd, "ip", ip);
MEVENT_TRIGGER(evt, NULL, REQ_CMD_CITY_BY_IP, FLAGS_SYNC);
hdf_copy(cgi->hdf, PRE_OUTPUT, evt->hdfrcv);
return STATUS_OK;
}
int http_req_method(CGI *cgi)
{
char *op = hdf_get_value(cgi->hdf, PRE_QUERY"._op", "get");
if (!strcasecmp(op, "get")) return CGI_REQ_GET;
else if (!strcasecmp(op, "mod")) return CGI_REQ_POST;
else if (!strcasecmp(op, "add")) return CGI_REQ_PUT;
else if (!strcasecmp(op, "del")) return CGI_REQ_DEL;
return CGI_REQ_UNKNOWN;
}
static EventEntry* city_init_driver(void)
{
struct city_entry *e = calloc(1, sizeof(struct city_entry));
if (e == NULL) return NULL;
NEOERR *err;
e->base.name = (unsigned char*)strdup(PLUGIN_NAME);
e->base.ksize = strlen(PLUGIN_NAME);
e->base.process_driver = city_process_driver;
e->base.stop_driver = city_stop_driver;
//mevent_add_timer(&e->base.timers, 60, true, hint_timer_up_term);
char *s = hdf_get_value(g_cfg, CONFIG_PATH".dbsn", NULL);
err = mdb_init(&e->db, s);
JUMP_NOK(err, error);
e->cd = cache_create(hdf_get_int_value(g_cfg, CONFIG_PATH".numobjs", 1024), 0);
if (e->cd == NULL) {
wlog("init cache failure");
goto error;
}
s = hdf_get_value(g_cfg, CONFIG_PATH".ipfile", "QQWry.Dat");
err = ne_load_file(s, (char**)&ips);
JUMP_NOK(err, error);
ipbgn = b2int(ips, 4);
ipend = b2int(ips+4, 4);
if (ipbgn < 0 || ipend < 0) {
wlog("%s format error", s);
goto error;
}
return (EventEntry*)e;
error:
if (e->base.name) free(e->base.name);
if (e->db) mdb_destroy(e->db);
if (e->cd) cache_free(e->cd);
if (ips) free(ips);
free(e);
return NULL;
}
NEOERR* mcs_set_int_attrr(HDF *hdf, char *name, char *key, int val)
{
char tok[64] = {0};
snprintf(tok, sizeof(tok), "%d", val);
/* can't set node's attr if node have no value */
if (!hdf_get_value(hdf, name, NULL)) hdf_set_value(hdf, name, "foo");
return nerr_pass(hdf_set_attr(hdf, name, key, tok));
}
NEOERR* member_login_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = hash_lookup(evth, "member");
char *mname, *msn;
MCS_NOT_NULLB(cgi->hdf, evt);
HDF_GET_STR(cgi->hdf, PRE_QUERY".mname", mname);
HDF_GET_STR(cgi->hdf, PRE_QUERY".msn", msn);
hdf_set_value(evt->hdfsnd, "mname", mname);
hdf_set_value(evt->hdfsnd, "msn", msn);
MEVENT_TRIGGER(evt, mname, REQ_CMD_MEMBER_CHECK_MSN, FLAGS_SYNC);
char *mnick = hdf_get_value(evt->hdfrcv, "mnick", "嘀嗒");
char *mid = hdf_get_value(evt->hdfrcv, "mid", NULL);
member_after_login(cgi, evth, mname, mnick, mid);
return STATUS_OK;
}
struct mevent* mevent_start(void)
{
int ret;
struct mevent *evt = calloc(1, sizeof(struct mevent));
if (evt == NULL) return NULL;
evt->numevts = 0;
evt->chainlen = 1000000;
//evt->hashlen = evt->numevts / evt->chainlen;
evt->hashlen = 16;
evt->table = calloc(evt->hashlen, sizeof(struct event_chain));
void *lib;
char tbuf[1024], *tp;
char *name;
int num_thread;
struct event_driver *driver;
HDF *res = hdf_get_child(g_cfg, PRE_SERVER".plugins");
char *plugin_path = settings.plugin_path ? settings.plugin_path : PLUGIN_PATH;
while (res != NULL) {
lib = NULL; driver = NULL; memset(tbuf, 0x0, sizeof(tbuf));
name = hdf_get_value(res, "name", "_unexist");
num_thread = hdf_get_int_value(res, "numberofthreads", 1);
HDF *mates = hdf_get_obj(res, "mates");
snprintf(tbuf, sizeof(tbuf), "%s/mevent_%s.so", plugin_path, name);
//lib = dlopen(tbuf, RTLD_NOW|RTLD_GLOBAL);
lib = dlopen(tbuf, RTLD_LAZY|RTLD_GLOBAL);
if (lib == NULL) {
wlog("open driver %s failure %s\n", tbuf, dlerror());
res = hdf_obj_next(res);
continue;
}
snprintf(tbuf, sizeof(tbuf), "%s_driver", name);
driver = (struct event_driver*)dlsym(lib, tbuf);
if ((tp = dlerror()) != NULL) {
wlog("find symbol %s failure %s\n", tbuf, tp);
res = hdf_obj_next(res);
continue;
}
ret = mevent_start_driver(evt, driver, lib, num_thread, mates);
if (ret != 1) wlog("init driver %s failure\n", name);
else evt->numevts++;
res = hdf_obj_next(res);
}
return evt;
}
unsigned int mcs_get_uint_value(HDF *hdf, char *name, unsigned int defval)
{
char *val, *n;
unsigned int v;
val = hdf_get_value(hdf, name, NULL);
if (val) {
v = strtoul(val, &n, 10);
if (val == n) v = defval;
return v;
}
return defval;
}
float mcs_get_float_value(HDF *hdf, char *name, float defval)
{
char *val, *n;
float v;
val = hdf_get_value(hdf, name, NULL);
if (val) {
v = strtof(val, &n);
if (val == n) v = defval;
return v;
}
return defval;
}
int64_t mcs_get_int64_value(HDF *hdf, char *name, int64_t defval)
{
char *val, *n;
int64_t v;
val = hdf_get_value(hdf, name, NULL);
if (val) {
v = strtoll(val, &n, 10);
if (val == n) v = defval;
return v;
}
return defval;
}
static PyObject * p_hdf_get_value (PyObject *self, PyObject *args)
{
HDFObject *ho = (HDFObject *)self;
PyObject *rv;
char *name;
char *r, *d = NULL;
if (!PyArg_ParseTuple(args, "ss:getValue(name, default)", &name, &d))
return NULL;
r = hdf_get_value (ho->data, name, d);
rv = Py_BuildValue ("s", r);
return rv;
}
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* member_account_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mevent_t *evt = (mevent_t*)hash_lookup(evth, "member");
char *mnick, *mname, *mid, *rlink;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, evt);
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".mname", mname);
HDF_FETCH_STR(cgi->hdf, PRE_QUERY".rlink", rlink);
if (mname && rlink) {
hdf_set_value(evt->hdfsnd, "mname", mname);
MEVENT_TRIGGER(evt, mname, REQ_CMD_MEMBER_GETRLINK, FLAGS_SYNC);
mnick = hdf_get_value(evt->hdfrcv, "mnick", NULL);
char *s = hdf_get_value(evt->hdfrcv, "rlink", NULL);
if (!s || strcmp(s, rlink))
return nerr_raise(LERR_USERINPUT, "验证码错误");
hdf_set_value(evt->hdfsnd, "mname", mname);
MEVENT_TRIGGER(evt, mname, REQ_CMD_MEMBER_GET, FLAGS_SYNC);
hdf_copy(cgi->hdf, PRE_OUTPUT".member", evt->hdfrcv);
mid = hdf_get_value(evt->hdfrcv, "mid", NULL);
member_after_login(cgi, evth, mname, mnick, mid);
hdf_set_value(cgi->hdf, PRE_OUTPUT".rlink", rlink);
} else {
MEMBER_CHECK_LOGIN();
}
SET_DASHBOARD_ACTION(cgi->hdf);
return STATUS_OK;
}
