/*
* 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);
}
}
