/* * 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; }
static NEOERR* dyn_cmd_addtrack(struct queue_entry *q, struct cache *cd, mdb_conn *db) { STRING str; string_init(&str); char *aname, *uname, *oname; int aid, uid, oid = 0; NEOERR *err; REQ_GET_PARAM_STR(q->hdfrcv, "uname", uname); REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname); REQ_FETCH_PARAM_STR(q->hdfrcv, "oname", oname); uid = hash_string(uname); aid = hash_string(aname); if (oname) oid = hash_string(oname); hdf_set_int_value(q->hdfrcv, "aid", aid); hdf_set_int_value(q->hdfrcv, "uid", uid); hdf_set_int_value(q->hdfrcv, "oid", oid); err = mcs_build_incol(q->hdfrcv, hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.track"), &str); if (err != STATUS_OK) return nerr_pass(err); MDB_EXEC(db, NULL, "INSERT INTO track %s", NULL, str.buf); string_clear(&str); 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; } }
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* member_home_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses) { mevent_t *evt = hash_lookup(evth, "member"); char *mname = NULL; int mid; NEOERR *err; MCS_NOT_NULLB(cgi->hdf, evt); HDF_FETCH_INT(cgi->hdf, PRE_QUERY".mid", mid); if (mid == 0) { MEMBER_CHECK_LOGIN(); } else { hdf_set_int_value(evt->hdfsnd, "mid", mid); MEVENT_TRIGGER(evt, NULL, REQ_CMD_MEMBER_GET, FLAGS_SYNC); hdf_copy(cgi->hdf, PRE_OUTPUT".member", evt->hdfrcv); } evt = hash_lookup(evth, "plan"); MCS_NOT_NULLA(evt); if (mname) hdf_set_value(evt->hdfsnd, "mname", mname); hdf_copy(evt->hdfsnd, NULL, hdf_get_obj(cgi->hdf, PRE_QUERY)); hdf_set_value(evt->hdfsnd, "_npp", "5"); hdf_set_value(evt->hdfsnd, "_guest", "1"); MEVENT_TRIGGER(evt, NULL, REQ_CMD_PLAN_MINE, FLAGS_SYNC); hdf_copy(cgi->hdf, PRE_OUTPUT, evt->hdfrcv); return STATUS_OK; }
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; }
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); }
NEOERR* blog_index_static_get(HDF *hdf, HASH *dbh) { mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "aux"); NEOERR *err; LPRE_DBOP(hdf, conn); /* set pgtt for caller use */ MMISC_PAGEDIV_SET(hdf, PRE_OUTPUT, conn, "blog", " state=%d ", NULL, BLOG_ST_NORMAL); int ntt = hdf_get_int_value(hdf, PRE_OUTPUT".ntt", 0); int pgtt = (ntt+BLOG_NUM_PERPAGE-1) / BLOG_NUM_PERPAGE; hdf_set_int_value(hdf, PRE_OUTPUT".pgtt", pgtt); int offset = 0; int pageid = hdf_get_int_value(hdf, PRE_QUERY".pageid", 0); if (pageid == 0) offset = (pgtt - 1) * BLOG_NUM_PERPAGE; else offset = (pageid-1) * BLOG_NUM_PERPAGE; MDB_QUERY_RAW(conn, "blog", BLOG_COL, " state=%d ORDER BY ID " " LIMIT %d OFFSET %d", NULL, BLOG_ST_NORMAL, BLOG_NUM_PERPAGE, offset); return nerr_pass(mdb_set_rows(hdf, conn, BLOG_COL, PRE_OUTPUT".blogs", "0")); }
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* mcs_set_int_value_with_type(HDF *hdf, char *name, int value, CnodeType type) { NEOERR *err; err = hdf_set_int_value(hdf, name, value); if (err != STATUS_OK) return nerr_pass(err); return nerr_pass(mcs_set_int_attr(hdf, name, "type", type)); }
int mcs_add_int_value(HDF *node, char *key, int val) { if (!node || !key) return 0; int ov = hdf_get_int_value(node, key, 0); hdf_set_int_value(node, key, ov+val); return ov+val; }
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); }
static void city_process_driver(EventEntry *entry, QueueEntry *q) { struct city_entry *e = (struct city_entry*)entry; NEOERR *err; int ret; struct city_stats *st = &(e->st); st->msg_total++; mtc_dbg("process cmd %u", q->operation); switch (q->operation) { CASE_SYS_CMD(q->operation, q, e->cd, err); case REQ_CMD_CITY_BY_IP: err = city_cmd_ip(e, q); break; case REQ_CMD_CITY_BY_ID: err = city_cmd_id(e, q); break; case REQ_CMD_CITY_BY_S: err = city_cmd_s(e, q); break; case REQ_CMD_PLACE_GET: err = place_cmd_get(e, q); break; case REQ_CMD_STATS: st->msg_stats++; err = STATUS_OK; hdf_set_int_value(q->hdfsnd, "msg_total", st->msg_total); hdf_set_int_value(q->hdfsnd, "msg_unrec", st->msg_unrec); hdf_set_int_value(q->hdfsnd, "msg_badparam", st->msg_badparam); hdf_set_int_value(q->hdfsnd, "msg_stats", st->msg_stats); hdf_set_int_value(q->hdfsnd, "proc_suc", st->proc_suc); hdf_set_int_value(q->hdfsnd, "proc_fai", st->proc_fai); break; default: st->msg_unrec++; err = nerr_raise(REP_ERR_UNKREQ, "unknown command %u", q->operation); break; } NEOERR *neede = mcs_err_valid(err); ret = neede ? neede->error : REP_OK; if (PROCESS_OK(ret)) { st->proc_suc++; } else { st->proc_fai++; if (ret == REP_ERR_BADPARAM) { st->msg_badparam++; } TRACE_ERR(q, ret, err); } if (q->req->flags & FLAGS_SYNC) { reply_trigger(q, ret); } }
static void dyn_process_driver(struct event_entry *entry, struct queue_entry *q) { struct dyn_entry *e = (struct dyn_entry*)entry; NEOERR *err; int ret; mdb_conn *db = e->db; struct cache *cd = e->cd; struct dyn_stats *st = &(e->st); st->msg_total++; mtc_dbg("process cmd %u", q->operation); switch (q->operation) { CASE_SYS_CMD(q->operation, q, e->cd, err); case REQ_CMD_ADDTRACK: err = dyn_cmd_addtrack(q, cd, db); break; case REQ_CMD_GETADMIN: err = dyn_cmd_getadmin(q, cd, db); break; case REQ_CMD_STATS: st->msg_stats++; err = STATUS_OK; hdf_set_int_value(q->hdfsnd, "msg_total", st->msg_total); hdf_set_int_value(q->hdfsnd, "msg_unrec", st->msg_unrec); hdf_set_int_value(q->hdfsnd, "msg_badparam", st->msg_badparam); hdf_set_int_value(q->hdfsnd, "msg_stats", st->msg_stats); hdf_set_int_value(q->hdfsnd, "proc_suc", st->proc_suc); hdf_set_int_value(q->hdfsnd, "proc_fai", st->proc_fai); break; default: st->msg_unrec++; err = nerr_raise(REP_ERR_UNKREQ, "unknown command %u", q->operation); break; } NEOERR *neede = mcs_err_valid(err); ret = neede ? neede->error : REP_OK; if (PROCESS_OK(ret)) { st->proc_suc++; } else { st->proc_fai++; if (ret == REP_ERR_BADPARAM) { st->msg_badparam++; } TRACE_ERR(q, ret, err); } if (q->req->flags & FLAGS_SYNC) { reply_trigger(q, ret); } }
static NEOERR* aux_cmd_impadd(struct queue_entry *q, struct cache *cd, mdb_conn *db) { STRING str; string_init(&str); NEOERR *err; char *aname; int aid; REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname); aid = hash_string(aname); hdf_set_int_value(q->hdfrcv, "aid", aid); err = mcs_build_incol(q->hdfrcv, hdf_get_obj(g_cfg, CONFIG_PATH".InsertCol.improve"), &str); if (err != STATUS_OK) return nerr_pass(err); MDB_EXEC(db, NULL, "INSERT INTO improve %s", NULL, str.buf); string_clear(&str); cache_delf(cd, PREFIX_IMP"%d_0", aid); return STATUS_OK; }
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); NEOERR *neede = mcs_err_valid(err); /* set PRE_ERRXXX with the most recently err */ hdf_set_int_value(hdf, PRE_ERRCODE, neede->error); 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); }
NEOERR* oms_users_data_add(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses) { mevent_t *evt = (mevent_t*)hash_lookup(evth, "aic"); char *aname, *pname, *email; int cost; NEOERR *err; APP_CHECK_ADMIN(); HDF_GET_STR_IDENT(cgi->hdf, PRE_COOKIE".aname", pname); HDF_GET_STR(cgi->hdf, PRE_QUERY".aname", aname); HDF_GET_STR(cgi->hdf, PRE_QUERY".email", email); LEGAL_CK_ANAME(pname); LEGAL_CK_ANAME(aname); LEGAL_CK_EMAIL(email); /* * check */ int state = hdf_get_int_value(evt->hdfrcv, "state", LCS_ST_FREE); if (state <= LCS_ST_FREE) return nerr_raise(LERR_NEEDUP, "%s want to add users %s", pname, aname); else if (state >= LCS_ST_VIP) goto add; /* * chargeback */ cost = hdf_get_int_value(g_cfg, "Cost.account", 0); evt = (mevent_t*)hash_lookup(evth, "bank"); hdf_set_value(evt->hdfsnd, "aname", pname); hdf_set_int_value(evt->hdfsnd, "btype", BANK_OP_ADDACCOUNT); hdf_set_int_value(evt->hdfsnd, "fee", cost); hdf_set_value(evt->hdfsnd, "account", aname); MEVENT_TRIGGER(evt, pname, REQ_CMD_BANK_ADDBILL, FLAGS_SYNC); add: /* * add */ evt = (mevent_t*)hash_lookup(evth, "aic"); hdf_copy(evt->hdfsnd, NULL, hdf_get_obj(cgi->hdf, PRE_QUERY)); hdf_set_value(evt->hdfsnd, "pname", pname); hdf_set_value(evt->hdfsnd, "aname", aname); hdf_set_int_value(evt->hdfsnd, "state", hdf_get_int_value(evt->hdfrcv, "state", LCS_ST_FREE)); hdf_set_value(evt->hdfsnd, "masn", aname); if (PROCESS_NOK(mevent_trigger(evt, aname, REQ_CMD_APPNEW, FLAGS_SYNC))) { char *zpa = NULL; hdf_write_string(evt->hdfrcv, &zpa); mtc_foo("add %s failure %d %s", aname, evt->errcode, zpa); SAFE_FREE(zpa); if (state < LCS_ST_VIP) { /* * roll back */ evt = (mevent_t*)hash_lookup(evth, "bank"); hdf_set_value(evt->hdfsnd, "aname", pname); hdf_set_int_value(evt->hdfsnd, "btype", BANK_OP_ROLLBACK); hdf_set_int_value(evt->hdfsnd, "fee", -cost); hdf_set_valuef(evt->hdfsnd, "remark = 客服帐号 %s 创建失败", aname); if (PROCESS_NOK(mevent_trigger(evt, pname, REQ_CMD_BANK_ADDBILL, FLAGS_SYNC))) { /* * ATTENTION we need pay back to customer manually */ hdf_write_string(evt->hdfrcv, &zpa); mtc_foo("rollback %s failure %d %s", aname, evt->errcode, zpa); SAFE_FREE(zpa); } } return nerr_raise(evt->errcode, "add %s failure %d", aname, evt->errcode); } return STATUS_OK; }
int main(int argc, char **argv, char **envp) { CGI *cgi = NULL; NEOERR *err; mdb_conn *conn = NULL; /* skey, user, pass, return jsoncallback*/ char *s, *u, *r, *jcbk; //sleep(20); mtc_init("logout"); mconfig_parse_file(SITE_CONFIG, &g_cfg); mutil_wrap_fcgi(argc, argv, envp); 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; } #ifndef DROP_FCGI while (FCGI_Accept() >= 0) { #endif /* * cgi init */ 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("{errcode: %d}", SAM_ERR_INIT); goto opfinish; } err = cgi_parse(cgi); if (err != STATUS_OK) { mtc_err("parse cgi error"); hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_PARSE); goto opfinish; } 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)) { user_logout(conn, u); cgi_cookie_clear(cgi, "samuser", SITE_DOMAIN, NULL); cgi_cookie_clear(cgi, "samkey", SITE_DOMAIN, NULL); hdf_set_value(cgi->hdf, PRE_OUTPUT".success", "1"); goto opfinish; } } hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_NOTLOGIN); opfinish: if (cgi) { r = hdf_get_value(cgi->hdf, PRE_QUERY".r", NULL); if (r) { cgi_redirect(cgi, r); } else { jcbk = hdf_get_value(cgi->hdf, PRE_QUERY".jsoncallback", NULL); if (jcbk != NULL) { mjson_execute_hdf(cgi->hdf, jcbk, 0); } else { mjson_output_hdf(cgi->hdf, 0); } } #ifdef DEBUG_HDF hdf_write_file(cgi->hdf, HF_LOG_PATH"hdf.logout"); #endif cgi_destroy(&cgi); } #ifndef DROP_FCGI } /* FCGI_Accept() */ #endif mdb_destroy(conn); return 0; }
int main(int argc, char **argv, char **envp) { CGI *cgi = NULL; NEOERR *err; mdb_conn *conn = NULL; /* skey, user, pass, return jsoncallback*/ char *s, *u, *p, *r, *jcbk; /* keeptime(hours) */ int t; char tm[LEN_TM_GMT]; //sleep(20); mtc_init("login"); mconfig_parse_file(SITE_CONFIG, &g_cfg); mutil_wrap_fcgi(argc, argv, envp); 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; } #ifndef DROP_FCGI while (FCGI_Accept() >= 0) { #endif /* * cgi init */ 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("{errcode: %d}", SAM_ERR_INIT); goto opfinish; } err = cgi_parse(cgi); if (err != STATUS_OK) { mtc_err("parse cgi error"); hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_PARSE); goto opfinish; } #if 0 if (mutil_client_attack_cookie(cgi->hdf, "login", 30, 60)) { mtc_err("client attack"); hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_NEEDREST); goto opfinish; } #endif 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"); goto done; } } u = hdf_get_value(cgi->hdf, PRE_QUERY".u", NULL); p = hdf_get_value(cgi->hdf, PRE_QUERY".p", NULL); if (!u || !p) { mtc_err("parameter miss %s %s", u, p); hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_NEEDINPUT); goto opfinish; } s = user_login_auth(conn, u, p); if (!s) { mtc_err("login error %s %s", u, p); hdf_set_int_value(cgi->hdf, PRE_OUTPUT".errcode", SAM_ERR_PASSW); goto opfinish; } cgiwrap_write(P3P_HEADER, strlen(P3P_HEADER)); cgi_cookie_set(cgi, "samuser", u, NULL, SITE_DOMAIN, NULL, 1, 0); cgi_cookie_set(cgi, "samkey", s, NULL, SITE_DOMAIN, NULL, 1, 0); #if 0 t = hdf_get_int_value(cgi->hdf, PRE_QUERY".t", 0); mmisc_getdatetime_gmt(tm, sizeof(tm), "%A, %d-%b-%Y %T GMT", 60*60*t); cgi_cookie_set(cgi, "samkey", s, NULL, SITE_DOMAIN, tm, 1, 0); #endif hdf_set_value(cgi->hdf, PRE_OUTPUT".samuser", u); hdf_set_value(cgi->hdf, PRE_OUTPUT".samkey", s); free(s); done: /* * TODO set samkey, samuser to app's domain * DONE this is done by jsonp */ hdf_set_value(cgi->hdf, PRE_OUTPUT".success", "1"); opfinish: if (cgi) { r = hdf_get_value(cgi->hdf, PRE_QUERY".r", NULL); if (r) { cgi_redirect(cgi, r); } else { jcbk = hdf_get_value(cgi->hdf, PRE_QUERY".jsoncallback", NULL); if (jcbk != NULL) { mjson_execute_hdf(cgi->hdf, jcbk, 0); } else { mjson_output_hdf(cgi->hdf, 0); } } #ifdef DEBUG_HDF hdf_write_file(cgi->hdf, HF_LOG_PATH"hdf.login"); #endif cgi_destroy(&cgi); } #ifndef DROP_FCGI } /* FCGI_Accept() */ #endif mdb_destroy(conn); return 0; }
NEOERR * rcfs_save (const char *path, const char *data, const char *user, const char *log) { NEOERR *err; HDF *meta = NULL, *vers; char fpath[_POSIX_PATH_MAX]; char buf[256]; int version = 0; int fd; int lock; int x, l, w; err = rcfs_lock (path, &lock); if (err) return nerr_pass (err); do { err = rcfs_meta_load (path, &meta); if (err && nerr_handle (&err, NERR_NOT_FOUND)) { /* new file! */ err = hdf_init (&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; } /* new version */ version++; snprintf (fpath, sizeof (fpath), "%s,%d", path, version); fd = open (fpath, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); if (fd == -1) { err = nerr_raise_errno (NERR_IO, "Unable to create file %s", fpath); break; } l = strlen(data); w = write (fd, data, l); if (w != l) { err = nerr_raise_errno (NERR_IO, "Unable to write file %s", fpath); close (fd); break; } close (fd); snprintf (buf, sizeof(buf), "Versions.%d.Log", version); err = hdf_set_value (meta, buf, log); if (err) break; snprintf (buf, sizeof(buf), "Versions.%d.User", version); err = hdf_set_value (meta, buf, user); if (err) break; snprintf (buf, sizeof(buf), "Versions.%d.Date", version); err = hdf_set_int_value (meta, buf, ne_timef()); if (err) break; err = _meta_save (path, meta); } while (0); rcfs_unlock (lock); hdf_destroy (&meta); return nerr_pass (err); }
static NEOERR* rend_blog_index(HASH *dbh, HASH *tplh, int pageid, int *pgttr) { CSPARSE *cs = NULL; HDF *hdf, *dhdf; STRING str; NEOERR *err = STATUS_OK; char fname[_POSIX_PATH_MAX]; if (!dbh || !tplh) return nerr_raise(NERR_ASSERT, "paramter null"); cs = (CSPARSE*)hash_lookup(tplh, "blog_index"); dhdf = (HDF*)hash_lookup(tplh, "blog_index_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".pageid", pageid); err = blog_index_static_get(hdf, dbh); if (err != STATUS_OK) goto done; int ntt = hdf_get_int_value(hdf, PRE_OUTPUT".ntt", 0); int pgtt = hdf_get_int_value(hdf, PRE_OUTPUT".pgtt", 1); if (pgttr) *pgttr = pgtt; if (pageid == 0) { if (pgtt > 1) { err = hdf_set_int_value(hdf, PRE_OUTPUT".pgprev", pgtt-1); TRACE_NOK(err); if (ntt % BLOG_NUM_PERPAGE == 1) { err = rend_blog_index(dbh, tplh, pgtt-1, NULL); TRACE_NOK(err); if (pgtt > 2) { /* origin 1.html's nex is index.html, change them into 2.html */ err = rend_blog_index(dbh, tplh, pgtt-2, NULL); TRACE_NOK(err); } } } } else { if (pageid > 1 && pgtt > 1) hdf_set_int_value(hdf, PRE_OUTPUT".pgprev", pageid-1); if (pgtt == pageid+1) hdf_set_value(hdf, PRE_OUTPUT".pgnext", "index"); else if (pgtt > pageid) hdf_set_int_value(hdf, PRE_OUTPUT".pgnext", pageid+1); } cs->hdf = hdf; string_init(&str); err = cs_render(cs, &str, mcs_strcb); if (err != STATUS_OK) goto done; if (pageid == 0) snprintf(fname, sizeof(fname), "%sindex.html", PATH_BLOG); else snprintf(fname, sizeof(fname), "%s%d.html", PATH_BLOG, pageid); 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.index"); #endif done: hdf_destroy(&hdf); cs->hdf = NULL; string_clear(&str); return nerr_pass(err); }
NEOERR* system_view_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses) { mdb_conn *db = hash_lookup(dbh, "trace"); STRING str; string_init(&str); char *mname, *s; NEOERR *err; MCS_NOT_NULLB(cgi->hdf, db); MEMBER_CHECK_ADMIN(); SET_DASHBOARD_ACTION(cgi->hdf); /* * prepare query condition */ hdf_set_int_value(cgi->hdf, PRE_QUERY".type", TRACE_TYPE_PAGEVIEW); HDF_FETCH_STR(cgi->hdf, PRE_QUERY".times", s); if (!s) hdf_set_value(cgi->hdf, PRE_QUERY".timed", "current_date - 2"); err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY), hdf_get_obj(g_cfg, "Db.QueryCond.system.view"), &str, NULL); if (err != STATUS_OK) return nerr_pass(err); /* * pageview */ MDB_QUERY_RAW(db, "emap", _COL_EMAP_PAGEVIEW, " %s GROUP BY date_trunc('hour', intime) " " ORDER BY date_trunc('hour', intime)", NULL, str.buf); err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_PAGEVIEW, PRE_OUTPUT".pageviews", NULL, MDB_FLAG_EMPTY_OK); if (err != STATUS_OK) return nerr_pass(err); /* * userview */ MDB_QUERY_RAW(db, "emap", _COL_EMAP_USERVIEW, " %s GROUP BY date_trunc('hour', intime) " " ORDER BY date_trunc('hour', intime)", NULL, str.buf); err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_USERVIEW, PRE_OUTPUT".userviews", NULL, MDB_FLAG_EMPTY_OK); if (err != STATUS_OK) return nerr_pass(err); /* * day count */ MDB_QUERY_RAW(db, "emap", _COL_EMAP_DATEVIEW, " %s GROUP BY date_trunc('day', intime) " " ORDER BY date_trunc('day', intime)", NULL, str.buf); err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_DATEVIEW, PRE_OUTPUT".dateviews", NULL, MDB_FLAG_EMPTY_OK); if (err != STATUS_OK) return nerr_pass(err); MDB_QUERY_RAW(db, "emap", _COL_EMAP_DATEUSER, " %s GROUP BY date_trunc('day', intime) " " ORDER BY date_trunc('day', intime)", NULL, str.buf); err = mdb_set_rows(cgi->hdf, db, _COL_EMAP_DATEUSER, PRE_OUTPUT".dateusers", NULL, MDB_FLAG_EMPTY_OK); if (err != STATUS_OK) return nerr_pass(err); string_clear(&str); hdf_set_attr(cgi->hdf, PRE_OUTPUT".pageviews", "type", "array"); hdf_set_attr(cgi->hdf, PRE_OUTPUT".userviews", "type", "array"); return STATUS_OK; }
static int diary_handle_entry(request_rec *r, diary_conf *conf, const char *filename) { FILE *fp; CSPARSE *cs; NEOERR *cs_err; HDF *hdf; MMIOT *doc; char *title; char *author; char *date; int size; char *p; int flag = 0; int github_flavoured = conf->github_flavoured; calendar_info cal; char *theme_path; char *theme_file; theme_path = apr_pstrcat(r->pool, conf->path, "/themes/", conf->theme, NULL); theme_file = apr_pstrcat(r->pool, theme_path, "/index.cst", NULL); fp = fopen(filename, "r"); if(fp == NULL){ switch (errno) { case ENOENT: return HTTP_NOT_FOUND; case EACCES: return HTTP_FORBIDDEN; default: ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "diary_parse_entry error: errno=%d\n", errno); return HTTP_INTERNAL_SERVER_ERROR; } } doc = github_flavoured ? gfm_in(fp, 0) : mkd_in(fp, 0); fclose(fp); if (doc == NULL) { return HTTP_INTERNAL_SERVER_ERROR; } title = mkd_doc_title(doc); if(title == NULL){ title = "notitle"; } date = mkd_doc_date(doc); author = mkd_doc_author(doc); if(conf->autolink){ flag = MKD_AUTOLINK; } mkd_compile(doc, flag); if ((size = mkd_document(doc, &p)) == EOF) { return HTTP_INTERNAL_SERVER_ERROR; } hdf_init(&hdf); hdf_set_value(hdf, "hdf.loadpaths.1", conf->path); hdf_set_value(hdf, "hdf.loadpaths.2", theme_path); cs_err = hdf_read_file(hdf, INDEX_HDF); if(cs_err){ ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "cannot read index.hdf."); // TODO: no need to free cs_err and cs_err_str? hdf_destroy(&hdf); return HTTP_INTERNAL_SERVER_ERROR; } hdf_set_value(hdf, "diary.title", conf->title); hdf_set_value(hdf, "diary.uri", conf->uri); hdf_set_value(hdf, "diary.theme", conf->theme); hdf_set_value(hdf, "entry.uri", r->uri); hdf_set_value(hdf, "entry.title", title); hdf_set_value(hdf, "entry.author", author); hdf_set_value(hdf, "entry.date", date); hdf_set_value(hdf, "entry.desc", p); //hdf_dump(hdf, NULL); if (conf->calendar) { diary_set_calendar_info(&cal, r->args); hdf_set_int_value(hdf, "cal.year", cal.year); hdf_set_value(hdf, "cal.month", cal.month); hdf_set_value(hdf, "cal.day", cal.day); hdf_set_value(hdf, "cal.today", cal.today); hdf_set_int_value(hdf, "cal.lastdayofmonth", cal.lastdayofmonth); hdf_set_int_value(hdf, "cal.dayofweek_1stdayofmonth", cal.dayofweek_1stdayofmonth); } cs_err = cs_init(&cs, hdf); if(cs_err){ return HTTP_INTERNAL_SERVER_ERROR; } cgi_register_strfuncs(cs); mkd_cleanup(doc); cs_parse_file(cs, theme_file); r->content_type = "text/html"; cs_render(cs, r, diary_cs_render_cb); hdf_destroy(&hdf); cs_destroy(&cs); return 0; }
static int diary_handle_index(request_rec *r, diary_conf *conf) { HDF *hdf; CSPARSE *cs; NEOERR *cs_err; STRING cs_err_str; calendar_info cal; char *theme_path; char *theme_file; theme_path = apr_pstrcat(r->pool, conf->path, "/themes/", conf->theme, NULL); theme_file = apr_pstrcat(r->pool, theme_path, "/index.cst", NULL); hdf_init(&hdf); hdf_set_int_value(hdf, "index", 1); hdf_set_value(hdf, "hdf.loadpaths.1", conf->path); hdf_set_value(hdf, "hdf.loadpaths.2", theme_path); hdf_set_value(hdf, "diary.title", conf->title); hdf_set_value(hdf, "diary.uri", conf->uri); hdf_set_value(hdf, "diary.theme", conf->theme); if (conf->calendar) { diary_set_calendar_info(&cal, r->args); hdf_set_int_value(hdf, "cal.year", cal.year); hdf_set_value(hdf, "cal.month", cal.month); hdf_set_value(hdf, "cal.day", cal.day); hdf_set_value(hdf, "cal.today", cal.today); hdf_set_int_value(hdf, "cal.lastdayofmonth", cal.lastdayofmonth); hdf_set_int_value(hdf, "cal.dayofweek_1stdayofmonth", cal.dayofweek_1stdayofmonth); } cs_err = hdf_read_file(hdf, INDEX_HDF); if(cs_err){ ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "cannot read index.hdf."); // TODO: no need to free cs_err and cs_err_str? 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); // TODO: no need to free cs_err and cs_err_str? cs_destroy(&cs); hdf_destroy(&hdf); return HTTP_INTERNAL_SERVER_ERROR; } cgi_register_strfuncs(cs); cs_err = cs_parse_file(cs, theme_file); 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, "hoge error in cs_parse_file(): %s", cs_err_str.buf); // TODO: no need to free cs_err and cs_err_str? cs_destroy(&cs); hdf_destroy(&hdf); return HTTP_INTERNAL_SERVER_ERROR; } r->content_type = "text/html"; cs_render(cs, r, diary_cs_render_cb); cs_destroy(&cs); hdf_destroy(&hdf); return OK; }
static void aic_process_driver(struct event_entry *entry, struct queue_entry *q) { struct aic_entry *e = (struct aic_entry*)entry; NEOERR *err; int ret; mdb_conn *db = e->db; struct cache *cd = e->cd; struct aic_stats *st = &(e->st); st->msg_total++; mtc_dbg("process cmd %u", q->operation); switch (q->operation) { CASE_SYS_CMD(q->operation, q, e->cd, err); case REQ_CMD_APPINFO: err = aic_cmd_appinfo(q, cd, db); break; case REQ_CMD_APPNEW: err = aic_cmd_appnew(q, cd, db); break; case REQ_CMD_APPUP: err = aic_cmd_appup(q, cd, db); break; case REQ_CMD_APPDEL: err = aic_cmd_appdel(q, cd, db); break; case REQ_CMD_APP_GETSECY: err = aic_cmd_app_getsecy(q, cd, db); break; case REQ_CMD_APP_SETSECY: err = aic_cmd_app_setsecy(q, cd, db); break; case REQ_CMD_APPUSERS: err = aic_cmd_appusers(q, cd, db); break; case REQ_CMD_APPUSERIN: err = aic_cmd_appuserin(q, cd, db); break; case REQ_CMD_APPUSEROUT: err = aic_cmd_appuserout(q, cd, db); break; case REQ_CMD_APPUSERUP: err = aic_cmd_appuserup(q, cd, db); break; case REQ_CMD_APP_O_USERS: err = aic_cmd_appousers(q, cd, db); break; case REQ_CMD_APP_GETRLINK: err = aic_cmd_app_getrlink(q, cd, db); break; case REQ_CMD_APP_SETRLINK: err = aic_cmd_app_setrlink(q, cd, db); break; case REQ_CMD_STATS: st->msg_stats++; err = STATUS_OK; hdf_set_int_value(q->hdfsnd, "msg_total", st->msg_total); hdf_set_int_value(q->hdfsnd, "msg_unrec", st->msg_unrec); hdf_set_int_value(q->hdfsnd, "msg_badparam", st->msg_badparam); hdf_set_int_value(q->hdfsnd, "msg_stats", st->msg_stats); hdf_set_int_value(q->hdfsnd, "proc_suc", st->proc_suc); hdf_set_int_value(q->hdfsnd, "proc_fai", st->proc_fai); break; default: st->msg_unrec++; err = nerr_raise(REP_ERR_UNKREQ, "unknown command %u", q->operation); break; } NEOERR *neede = mcs_err_valid(err); ret = neede ? neede->error : REP_OK; if (PROCESS_OK(ret)) { st->proc_suc++; } else { st->proc_fai++; if (ret == REP_ERR_BADPARAM) { st->msg_badparam++; } TRACE_ERR(q, ret, err); } if (q->req->flags & FLAGS_SYNC) { reply_trigger(q, ret); } }
static void aux_process_driver(EventEntry *entry, QueueEntry *q) { struct aux_entry *e = (struct aux_entry*)entry; NEOERR *err; int ret; struct aux_stats *st = &(e->st); st->msg_total++; mtc_dbg("process cmd %u", q->operation); switch (q->operation) { CASE_SYS_CMD(q->operation, q, e->cd, err); case REQ_CMD_CMT_GET: err = aux_cmd_cmtget(e, q); break; case REQ_CMD_CMT_ADD: err = aux_cmd_cmtadd(e, q); break; case REQ_CMD_CMT_DEL: err = aux_cmd_cmtdel(e, q); break; case REQ_CMD_MEMORY_GET: err = aux_cmd_memoryget(e, q); break; case REQ_CMD_MEMORY_ADD: err = aux_cmd_memoryadd(e, q); break; case REQ_CMD_MEMORY_MOD: err = aux_cmd_memorymod(e, q); break; case REQ_CMD_AUX_EMAIL_ADD: err = aux_cmd_emailadd(e, q); break; case REQ_CMD_AUX_INBOX_ADD: err = aux_cmd_inboxadd(e, q); break; case REQ_CMD_STATS: st->msg_stats++; err = STATUS_OK; hdf_set_int_value(q->hdfsnd, "msg_total", st->msg_total); hdf_set_int_value(q->hdfsnd, "msg_unrec", st->msg_unrec); hdf_set_int_value(q->hdfsnd, "msg_badparam", st->msg_badparam); hdf_set_int_value(q->hdfsnd, "msg_stats", st->msg_stats); hdf_set_int_value(q->hdfsnd, "proc_suc", st->proc_suc); hdf_set_int_value(q->hdfsnd, "proc_fai", st->proc_fai); break; default: st->msg_unrec++; err = nerr_raise(REP_ERR_UNKREQ, "unknown command %u", q->operation); break; } NEOERR *neede = mcs_err_valid(err); ret = neede ? neede->error : REP_OK; if (PROCESS_OK(ret)) { st->proc_suc++; } else { st->proc_fai++; if (ret == REP_ERR_BADPARAM) { st->msg_badparam++; } TRACE_ERR(q, ret, err); } if (q->req->flags & FLAGS_SYNC) { reply_trigger(q, ret); } }