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; }
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")); }
/* * input : aname(STR) * return: NORMAL REP_ERR_NREGIST * reply : NULL */ static NEOERR* aic_cmd_appdel(struct queue_entry *q, struct cache *cd, mdb_conn *db) { char *aname; int aid, pid = 0; NEOERR *err; REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname); aid = hash_string(aname); err = aic_cmd_appinfo(q, cd, db); if (err != STATUS_OK) return nerr_pass(err); if (!hdf_get_obj(q->hdfsnd, "state")) return nerr_raise(REP_ERR_NREGIST, "%s not regist", aname); pid = hdf_get_int_value(q->hdfsnd, "pid", 0); MDB_EXEC(db, NULL, "DELETE FROM appinfo WHERE aid=%d;", NULL, aid); cache_delf(cd, PREFIX_APPINFO"%d", aid); if (pid > 0) { cache_delf(cd, PREFIX_APPOUSER"%d_0", pid); } return STATUS_OK; }
bool mtc_msg(const char *func, const char *file, long line, int level, const char *format, ...) { int dftlv = hdf_get_int_value(g_cfg, PRE_CONFIG".trace_level", TC_DEFAULT_LEVEL); if (level > dftlv) return true; if (g_fp == NULL) return false; va_list ap; char tm[LEN_TM]; mutil_getdatetime(tm, sizeof(tm), "%Y-%m-%d %H:%M:%S", time(NULL)); fprintf(g_fp, "[%s]", tm); fprintf(g_fp, "[%s]", g_trace_level[level]); fprintf(g_fp, "[%s:%li %s] ", file, line, func); va_start(ap, (void*)format); vfprintf(g_fp, format, ap); va_end(ap); fprintf(g_fp, "\n"); trace_shift_file(); return true; }
NEOERR* inbox_multi_add(HDF *datanode, HASH *evth, char *inboxtype) { mevent_t *evt; int mid; HDF *child; NEOERR *err; MCS_NOT_NULLB(datanode, evth); evt = hash_lookup(evth, "aux"); MCS_NOT_NULLA(evt); child = hdf_obj_child(datanode); while (child) { mid = hdf_get_int_value(child, "mid", 0); if (mid > 0) { hdf_set_valuef(evt->hdfsnd, "mmid.%d=%d", mid, mid); } child = hdf_obj_next(child); } if (!hdf_get_obj(evt->hdfsnd, "mmid")) return nerr_raise(NERR_ASSERT, "请设置收信用户号码"); err = mtpl_InConfigRend_get(evt->hdfsnd, datanode, "inbox", inboxtype, g_datah); if (err != STATUS_OK) return nerr_pass(err); MEVENT_TRIGGER(evt, NULL, REQ_CMD_AUX_INBOX_ADD, FLAGS_NONE); return STATUS_OK; }
NEOERR* blog_data_mod(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; int bid; NEOERR *err; LPRE_DBOP(cgi->hdf, conn); HDF_GET_INT(cgi->hdf, PRE_QUERY".bid", bid); 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); STRING str; string_init(&str); err = mcs_build_upcol(hdf_get_obj(cgi->hdf, PRE_QUERY), hdf_get_obj(g_cfg, "Db.UpdateCol.blog"), &str); if (err != STATUS_OK) return nerr_pass(err); MDB_EXEC(conn, NULL, "UPDATE blog SET %s WHERE id=%d AND author=$1", "s", str.buf, bid, aname); string_clear(&str); char command[1024]; snprintf(command, sizeof(command), PATH_PAGER"blg -b %d", bid); mtc_dbg("%s", command); system(command); return STATUS_OK; }
NEOERR* blog_data_add(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, command[1024]; char *title, *content; int id = 0; 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); HDF_GET_STR(cgi->hdf, PRE_QUERY".title", title); HDF_GET_STR(cgi->hdf, PRE_QUERY".content", content); MDB_EXEC(conn, NULL, "INSERT INTO blog (title, content, author) " " VALUES ($1::varchar(256), $2, " " $3::varchar(256)) RETURNING id", "sss", title, content, aname); err = mdb_get(conn, "i", &id); if (err != STATUS_OK) return nerr_pass(err); snprintf(command, sizeof(command), PATH_PAGER"blg -i 0 -b %d", id); mtc_dbg("%s", command); system(command); return STATUS_OK; }
NEOERR* blog_data_del(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; int bid, state; NEOERR *err; LPRE_DBOP(cgi->hdf, conn); HDF_GET_INT(cgi->hdf, PRE_QUERY".bid", bid); HDF_GET_INT(cgi->hdf, PRE_QUERY".state", state); 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); MDB_EXEC(conn, NULL, "UPDATE blog SET state=%d WHERE id=%d AND " " author=$1", "s", state, bid, aname); char command[1024]; snprintf(command, sizeof(command), PATH_PAGER"blg -b %d", bid); mtc_dbg("%s", command); system(command); if (state == BLOG_ST_DEL) { snprintf(command, sizeof(command), "rm -f %s/%d/%d.html", PATH_BLOG, bid%BLOG_SUBDIR_NUM, bid); mtc_dbg("%s", command); system(command); } return STATUS_OK; }
NEOERR* blog_static_get(HDF *hdf, HASH *dbh) { mdb_conn *conn = (mdb_conn*)hash_lookup(dbh, "aux"); NEOERR *err; LPRE_DBOP(hdf, conn); int bid = hdf_get_int_value(hdf, PRE_QUERY".bid", 0); MDB_QUERY_RAW(conn, "blog", BLOG_COL, " id=%d AND state=%d ", NULL, bid, BLOG_ST_NORMAL); err = mdb_set_row(hdf, conn, BLOG_COL, PRE_OUTPUT".blog"); if (err != STATUS_OK) return nerr_pass(err); /* * previous * TODO id%32 ===> id%%d, BLOG_SUBDIR_NUM */ MDB_QUERY_RAW(conn, "blog", " id%32 ||'/'|| id as id, title ", " id < %d AND state=%d ORDER BY ID DESC LIMIT 1 ", NULL, bid, BLOG_ST_NORMAL); err = mdb_set_row(hdf, conn, " fnameprev, titleprev ", PRE_OUTPUT".blog"); if (err != STATUS_OK) return nerr_pass(err); /* * next */ MDB_QUERY_RAW(conn, "blog", " id%32 ||'/'|| id as id, title ", " id > %d AND state=%d ORDER BY ID LIMIT 1 ", NULL, bid, BLOG_ST_NORMAL); err = mdb_set_row(hdf, conn, " fnamenext, titlenext ", PRE_OUTPUT".blog"); return nerr_pass(err); }
static EventEntry* skeleton_init_driver(void) { struct skeleton_entry *e = calloc(1, sizeof(struct skeleton_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 = skeleton_process_driver; e->base.stop_driver = skeleton_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; } 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); free(e); return NULL; }
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; }
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* 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; }
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; }
int mmg_get_int_valuef(mmg_conn *db, char *dsn, char *key, int skip, int limit, char *qfmt, ...) { HDF *tmpnode; hdf_init(&tmpnode); char *querys, sels[256]; int val; va_list ap; HDF *node; NEOERR *err; va_start(ap, qfmt); querys = vsprintf_alloc(qfmt, ap); va_end(ap); if (!querys) { mtc_err("Unable to allocate mem for query string"); return 0; } snprintf(sels, sizeof(sels), "{'%s': 1}", key); err = mmg_prepare(db, MMG_FLAG_EMPTY, skip, limit, NULL, sels, querys); RETURN_V_NOK(err, 0); err = mmg_query(db, dsn, NULL, tmpnode); RETURN_V_NOK(err, 0); val = 0; if(hdf_get_valuef(tmpnode, "0.%s", key)) { node = hdf_obj_child(tmpnode); while (node) { val += hdf_get_int_value(node, key, 0); node = hdf_obj_next(node); } } else { val = hdf_get_int_value(tmpnode, key, 0); } hdf_destroy(&tmpnode); SAFE_FREE(querys); return val; }
/* * input : aname(STR) [asn(STR) masn(STR) email(STR) state(INT)] * return: NORMAL REP_ERR_ALREADYREGIST * reply : NULL */ static NEOERR* aic_cmd_appup(struct queue_entry *q, struct cache *cd, mdb_conn *db) { char *aname; int aid, pid = 0, tune = -1; STRING str; string_init(&str); NEOERR *err; REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname); REQ_FETCH_PARAM_INT(q->hdfrcv, "tune", tune); if (tune != -1) { if (hdf_get_int_value(q->hdfrcv, "tuneop", 0)) { /* set tune bit */ string_appendf(&str, " tune=tune | %d ", tune); } else { /* unset tune bit */ string_appendf(&str, " tune=tune & %d ", ~tune); } } aid = hash_string(aname); err = aic_cmd_appinfo(q, cd, db); if (err != STATUS_OK) return nerr_pass(err); if (!hdf_get_obj(q->hdfsnd, "state")) return nerr_raise(REP_ERR_NREGIST, "%s %d hasn't regist", aname, aid); pid = hdf_get_int_value(q->hdfsnd, "pid", 0); err = mcs_build_upcol(q->hdfrcv, hdf_get_obj(g_cfg, CONFIG_PATH".UpdateCol.appinfo"), &str); if (err != STATUS_OK) return nerr_pass(err); MDB_EXEC(db, NULL, "UPDATE appinfo SET %s WHERE aid=%d;", NULL, str.buf, aid); /* TODO memory leak, if exec() failure */ string_clear(&str); cache_delf(cd, PREFIX_APPINFO"%d", aid); if (pid > 0) { cache_delf(cd, PREFIX_APPOUSER"%d_0", pid); } return STATUS_OK; }
int mcs_get_int_valuef(HDF *hdf, int defval, char *fmt, ...) { char key[LEN_HDF_KEY]; va_list ap; va_start(ap, fmt); vsnprintf(key, sizeof(key), fmt, ap); va_end(ap); return hdf_get_int_value(hdf, key, defval); }
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; }
NEOERR* mhttp_upload_parse_cb(CGI *cgi, char *method, char *ctype, void *rock) { MCS_NOT_NULLC(cgi, method, ctype); if (!strcasecmp(method, "GET")) return nerr_raise(CGIParseNotHandled, "%s not handled", method); int len = hdf_get_int_value(cgi->hdf, "CGI.ContentLength", 0); if (len <= 0 || len > *(int*)rock) return nerr_raise(CGIUploadCancelled, "content length %d not support", len); return STATUS_OK; }
static PyObject * p_hdf_get_int_value (PyObject *self, PyObject *args) { HDFObject *ho = (HDFObject *)self; PyObject *rv; char *name; int r, d = 0; if (!PyArg_ParseTuple(args, "si:getIntValue(name, default)", &name, &d)) return NULL; r = hdf_get_int_value (ho->data, name, d); rv = Py_BuildValue ("i", r); return rv; }
NEOERR* comment_data_add(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses) { mevent_t *evt = (mevent_t*)hash_lookup(evth, "aux"); mevent_t *evt_place = (mevent_t*)hash_lookup(evth, "place"); LPRE_EVTOP(cgi->hdf, evt); /* * TODO other user can't comment on my improve... */ #if 0 HDF_GET_INT(cgi->hdf, PRE_QUERY".type", type); if (type == CMT_TYPE_IMPROVE) { APP_CHECK_LOGIN(); state = hdf_get_int_value(evt->hdfrcv, "state", LCS_ST_FREE); if (state < LCS_ST_ADMIN && ()) }
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 {
JNIEXPORT jint JNICALL Java_org_clearsilver_HDF__1getIntValue( JNIEnv *env, jclass objClass, jint hdf_obj_ptr, jstring j_hdfname, jint default_value) { HDF *hdf = (HDF *)hdf_obj_ptr; int r; const char *hdfname; if (!j_hdfname) { throwNullPointerException(env, "hdfname argument was null"); return 0; } hdfname = (*env)->GetStringUTFChars(env,j_hdfname, 0); r = hdf_get_int_value(hdf, hdfname, default_value); (*env)->ReleaseStringUTFChars(env,j_hdfname,hdfname); return r; }
int file_get_files(HDF *hdf, mdb_conn *conn, session_t *ses) { PRE_DBOP(hdf, conn); int ret, cnt = 0; char tok[LEN_MD]; int count, offset, uin, pid; ULIST *gnode; gnode_t *node; member_t *mb; file_t *fl; pid = hdf_get_int_value(hdf, PRE_QUERY".pid", 1); //sprintf(tok, "pid=%d", pid); //mmisc_set_count(hdf, conn, "fileinfo", tok); mmisc_get_offset(hdf, &count, &offset); if (member_has_login(hdf, conn, ses) != RET_RBTOP_OK) { return RET_RBTOP_NOTLOGIN; } if (!member_has_gmode(ses->member, GROUP_MODE_SENIOR, GROUP_STAT_OK)) { mtc_warn("%d attemped to list sys-file", ses->member->uin); return RET_RBTOP_LIMITE; } ret = member_get_group(ses->member, GROUP_MODE_SENIOR, GROUP_STAT_OK, &gnode); if (ret != RET_RBTOP_OK) { mtc_err("get %d %d failure", ses->member->uin, GROUP_MODE_SENIOR); return ret; } MLIST_ITERATE(gnode, node) { ret = file_get_info_by_id(conn, node->gid, NULL, -1, &fl); if (ret != RET_RBTOP_OK) { mtc_err("get %d info failure", node->gid); continue; } sprintf(tok, "%s.files.%d", PRE_OUTPUT, cnt++); file_item2hdf(fl, tok, hdf); file_del(fl); }
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* pos_data_mod(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses) { STRING str; string_init(&str); mdb_conn *db = hash_lookup(dbh, "city"); NEOERR *err; if (!cgi || !cgi->hdf || !db) return nerr_raise(NERR_ASSERT, "paramter null"); int id = hdf_get_int_value(cgi->hdf, PRE_QUERY".id", 0); err = mdb_build_upcol(hdf_get_obj(cgi->hdf, PRE_QUERY), hdf_get_obj(g_cfg, "Db.UpdateCol.city"), &str); if (err != STATUS_OK) return nerr_pass(err); MDB_EXEC(db, NULL, "UPDATE city SET %s WHERE id=%d;", NULL, str.buf, id); return STATUS_OK; }
NEOERR* oms_edit_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); err = oms_data_get(cgi, dbh, evth, ses); int tune = hdf_get_int_value(cgi->hdf, PRE_OUTPUT".appinfo.tune", 0); if (tune & LCS_TUNE_QUIET) hdf_set_value(cgi->hdf, PRE_OUTPUT".appinfo.quiet", "1"); if (tune & LCS_TUNE_SMS) hdf_set_value(cgi->hdf, PRE_OUTPUT".appinfo.sms", "1"); return nerr_pass(err); }
static EventEntry* aux_init_driver(void) { struct aux_entry *e = calloc(1, sizeof(struct aux_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 = aux_process_driver; e->base.stop_driver = aux_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; } err = mdb_exec(e->db, NULL, "SELECT id from memory ORDER BY id DESC LIMIT 1", NULL); JUMP_NOK(err, error); err = mdb_get(e->db, "i", &m_memory_maxid); if (nerr_handle(&err, NERR_NOT_FOUND)) { mtc_err("table memory empty"); wlog("table memory empty"); } JUMP_NOK(err, 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); free(e); return NULL; }
NEOERR* bore_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses) { mevent_t *evt_member = hash_lookup(evth, "member"); mevent_t *evt = hash_lookup(evth, "aux"); NEOERR *err; MCS_NOT_NULLB(cgi->hdf, evt); err = member_check_login_data_get(cgi, dbh, evth, ses); if (err == STATUS_OK) { if (hdf_get_int_value(evt_member->hdfrcv, "verify", -1) >= MEMBER_VF_ADMIN) SET_ADMIN_ACTION(cgi->hdf); } nerr_ignore(&err); hdf_copy(evt->hdfsnd, NULL, hdf_get_obj(cgi->hdf, PRE_QUERY)); MEVENT_TRIGGER(evt, NULL, REQ_CMD_MEMORY_GET, FLAGS_SYNC); hdf_copy(cgi->hdf, PRE_OUTPUT".memory", evt->hdfrcv); return STATUS_OK; }
/* * input : aname(STR) * return: NORMAL * reply : ["state": 0, ...] OR [] */ static NEOERR* aic_cmd_appinfo(struct queue_entry *q, struct cache *cd, mdb_conn *db) { unsigned char *val = NULL; size_t vsize = 0; int aid, pid; char *aname; NEOERR *err; REQ_GET_PARAM_STR(q->hdfrcv, "aname", aname); aid = hash_string(aname); if (cache_getf(cd, &val, &vsize, PREFIX_APPINFO"%d", aid)) { unpack_hdf(val, vsize, &q->hdfsnd); } else { hdf_set_value(q->hdfsnd, "pname", aname); MDB_QUERY_RAW(db, "appinfo", APPINFO_COL, "aid=%d", NULL, aid); err = mdb_set_row(q->hdfsnd, db, APPINFO_COL, NULL); if (nerr_handle(&err, NERR_NOT_FOUND)) return nerr_raise(REP_ERR_NREGIST, "%s %d hasn't regist", aname, aid); if (err != STATUS_OK) return nerr_pass(err); pid = hdf_get_int_value(q->hdfsnd, "pid", 0); if (pid != 0) { MDB_QUERY_RAW(db, "appinfo", "aname", "aid=%d", NULL, pid); err = mdb_set_row(q->hdfsnd, db, "pname", NULL); nerr_handle(&err, NERR_NOT_FOUND); if (err != STATUS_OK) return nerr_pass(err); } MDB_QUERY_RAW(db, "appinfo", "COUNT(*)+1 AS numuser", "pid=%d", NULL, aid); err = mdb_set_row(q->hdfsnd, db, "numuser", NULL); if (err != STATUS_OK) return nerr_pass(err); CACHE_HDF(q->hdfsnd, AIC_CC_SEC, PREFIX_APPINFO"%d", aid); } return STATUS_OK; }