int main(int argc, char *argv[]) { NEOERR *err = STATUS_OK; HASH *dbh, *evth; mtc_init(TC_ROOT"prestat"); err = lerr_init(); DIE_NOK_MTL(err); err = mconfig_parse_file(SITE_CONFIG, &g_cfg); DIE_NOK_MTL(err); err = ldb_init(&dbh); DIE_NOK_MTL(err); err = levt_init(&evth); DIE_NOK_MTL(err); err = fill_trackarea(evth, dbh); TRACE_NOK(err); levt_destroy(evth); ldb_destroy(dbh); mconfig_cleanup(&g_cfg); return 0; }
int main() { MHASH *table; MERR *err; char str[101], *pstr[NODE_NUM]; mtc_init("load.log", MTC_DEBUG); for (int i = 0; i < NODE_NUM; i++) { //mstr_rand_string(str, 100); //mstr_rand_string_fixlen(str, 100); snprintf(str, sizeof(str), "%d", i); pstr[i] = strdup(str); } err = mhash_init(&table, mhash_str_hash, mhash_str_comp, mhash_str_free); TRACE_NOK(err); mtimer_start(); for (int i = 0; i < NODE_NUM; i++) { mhash_insert(table, pstr[i], NULL); } mtimer_stop("hash insert"); mtimer_start(); for (int i = 0; i < NODE_NUM; i++) { mhash_lookup(table, pstr[i]); } mtimer_stop("hash lookup"); mhash_destroy(&table); return 0; }
NEOERR* ltpl_parse_dir(char *dir, HASH *outhash) { struct dirent **eps = NULL; int n; NEOERR *err; if (!dir) return nerr_raise(NERR_ASSERT, "can't read null directory"); HASH *dbh, *evth; void *lib = dlopen(NULL, RTLD_NOW|RTLD_GLOBAL); if (!lib) return nerr_raise(NERR_SYSTEM, "dlopen %s", dlerror()); err = ldb_init(&dbh); if (err != STATUS_OK) return nerr_pass(err); err = levt_init(&evth); if (err != STATUS_OK) return nerr_pass(err); n = scandir(dir, &eps, ltpl_config, alphasort); for (int i = 0; i < n; i++) { mtc_dbg("parse file %s", eps[i]->d_name); err = ltpl_parse_file(dbh, evth, lib, dir, eps[i]->d_name, outhash); TRACE_NOK(err); free(eps[i]); } ldb_destroy(dbh); levt_destroy(evth); dlclose(lib); if (n > 0) free(eps); else mtc_warn("no .hdf file found in %s", dir); return STATUS_OK; }
static NEOERR* city_cmd_id(struct city_entry *e, QueueEntry *q) { unsigned char *val = NULL; size_t vsize = 0; int id; NEOERR *err; mdb_conn *db = e->db; struct cache *cd = e->cd; REQ_GET_PARAM_INT(q->hdfrcv, "id", id); if (cache_getf(cd, &val, &vsize, PREFIX_CITY"%d", id)) { unpack_hdf(val, vsize, &q->hdfsnd); } else { MDB_QUERY_RAW(db, "city", _COL_CITY, "id=%d", NULL, id); err = mdb_set_rows(q->hdfsnd, db, _COL_CITY, "citys", NULL, MDB_FLAG_Z); if (err != STATUS_OK) return nerr_pass(err); /* * get city's parents */ int cnt = 0; char *pid = hdf_get_valuef(q->hdfsnd, "citys.0.pid"); while (pid && atoi(pid) > 0) { MDB_QUERY_RAW(db, "city", _COL_CITY, "id=%d", NULL, atoi(pid)); err = mdb_set_rows(q->hdfsnd, db, _COL_CITY, "citys", NULL, MDB_FLAG_Z); TRACE_NOK(err); pid = hdf_get_valuef(q->hdfsnd, "citys.%d.pid", ++cnt); } CACHE_HDF(q->hdfsnd, CITY_CC_SEC, PREFIX_CITY"%d", id); } return STATUS_OK; }
void mjson_execute_hdf(HDF *hdf, char *cb, time_t second) { if (second > 0) { mhttp_cache_headers(second); } NEOERR *err = cgiwrap_writef("Content-Type: text/html; charset=UTF-8\r\n\r\n"); TRACE_NOK(err); HDF *ohdf = hdf_get_obj(hdf, PRE_OUTPUT); if (!ohdf) return; struct json_object *out = NULL; mjson_asm_objs(ohdf, &out); cgiwrap_writef("%s(%s);\n", cb, json_object_to_json_string(out)); TRACE_NOK(err); json_object_put(out); }
NEOERR* ldml_parse_dir(char *dir, HASH *outhash) { struct dirent **eps = NULL; int n; NEOERR *err; if (!dir) return nerr_raise(NERR_ASSERT, "can't read null directory"); n = scandir(dir, &eps, ldml_config, alphasort); for (int i = 0; i < n; i++) { mtc_dbg("parse file %s", eps[i]->d_name); err = ldml_parse_file(dir, eps[i]->d_name, outhash); TRACE_NOK(err); free(eps[i]); } if (n > 0) free(eps); else mtc_warn("no .hdf file found in %s", dir); return STATUS_OK; }
void smsalarm_msg(char *msg) { mdb_conn *db; //char content[100]; NEOERR *err; err = mdb_init(&db, SMSA_DB_SN); RETURN_NOK(err); HDF *node = hdf_get_obj(g_cfg, SMSA_CFG_PATH".leader"); if (node != NULL) node = hdf_obj_child(node); while (node != NULL) { //memset(content, 0x0, sizeof(content)); err = mdb_exec(db, NULL, "INSERT INTO monitor_smssend (smsSendTo, smsContent) VALUES ('%s', '%s')", NULL, hdf_obj_value(node), msg); TRACE_NOK(err); node = hdf_obj_next(node); } mdb_destroy(db); }
NEOERR* session_init(CGI *cgi, HASH *dbh, session_t **ses) { session_t *lses; HDF *node, *onode; char tok[LEN_HDF_KEY], *s; NEOERR *err; /* * follow cgi_parse(), to process _type_object */ s = hdf_get_value(cgi->hdf, PRE_QUERY"._type_object", NULL); if (s) { ULIST *list; string_array_split(&list, s, ",", 50); ITERATE_MLIST(list) { snprintf(tok, sizeof(tok), "%s.%s", PRE_QUERY, neos_strip((char*)list->items[t_rsv_i])); onode = hdf_get_obj(cgi->hdf, tok); if (onode) { err = mjson_string_to_hdf(onode, NULL, MJSON_EXPORT_NONE); TRACE_NOK(err); } } uListDestroy(&list, ULIST_FREE); } *ses = NULL; lses = calloc(1, sizeof(session_t)); if (!lses) return nerr_raise(NERR_NOMEM, "calloc memory for session_t failure"); /* * mname */ HDF_FETCH_STR(cgi->hdf, PRE_COOKIE".mname", s); if (!s) HDF_FETCH_STR(cgi->hdf, PRE_COOKIE".username", s); if (s) lses->mname = strdup(s); /* * province */ HDF_FETCH_STR(cgi->hdf, PRE_COOKIE".province", s); hdf_init(&lses->province); if (s) { neos_unescape((UINT8*)s, strlen(s), '%'); hdf_set_value(lses->province, NULL, s); mjson_export_to_hdf(lses->province, NULL, MJSON_EXPORT_NONE, false); } /* * city */ HDF_FETCH_STR(cgi->hdf, PRE_COOKIE".city", s); hdf_init(&lses->city); if (s) { neos_unescape((UINT8*)s, strlen(s), '%'); hdf_set_value(lses->city, NULL, s); mjson_export_to_hdf(lses->city, NULL, MJSON_EXPORT_NONE, false); } /* * browser */ HDF_FETCH_STR(cgi->hdf, PRE_HTTP".UserAgent", s); if (s) { mstr_repchr(s, ' ', '\0'); for (int i = 0; i < m_browsers_size; i++) { if (!strncasecmp(s, m_browsers[i], strlen(m_browsers[i]))) { lses->browser = i; break; } } s = strchr(s, '/'); if (s) lses->bversion = strtof(s+1, NULL); } /* * reqtype */ lses->reqtype = CGI_REQ_HTML; char *uri = hdf_get_value(cgi->hdf, PRE_REQ_URI_RW, NULL); if (!uri) { uri = "terminal"; lses->reqtype = CGI_REQ_TERMINAL; } mstr_repchr(uri, '/', '_'); uri = mstr_strip(uri, '_'); if (!strncmp(uri, "json_", 5)) { uri = uri+5; lses->reqtype = CGI_REQ_AJAX; } else if (!strncmp(uri, "image_", 6)) { uri = uri+6; lses->reqtype = CGI_REQ_IMAGE; } /* * dataer, render */ switch (http_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); /* * tm_cache_browser */ 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); } /* * DONE */ *ses = lses; return STATUS_OK; }
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); }
int main(int argc, char *argv[]) { HASH *tplh = NULL, *dbh = NULL; NEOERR *err; int c, bid = 0, indexid = -1, pgtt; bool dorecurse = false; mtc_init(TC_ROOT"blg"); err = mconfig_parse_file(SITE_CONFIG, &g_cfg); DIE_NOK_MTL(err); while ( (c=getopt(argc, argv, "b:i:r")) != -1 ) { switch(c) { case 'b': bid = atoi(optarg); break; case 'i': indexid = atoi(optarg); break; case 'r': dorecurse = true; break; default: useage(argv[0]); } } err = ldb_init(&dbh); DIE_NOK_MTL(err); err = hash_init(&tplh, hash_str_hash, hash_str_comp); DIE_NOK_MTL(err); err = ltpl_parse_file(dbh, NULL, PATH_PAGER, "blog.hdf", tplh); DIE_NOK_MTL(err); if (indexid >= 0) { err = rend_blog_index(dbh, tplh, indexid, &pgtt); TRACE_NOK(err); if (indexid > 0 && pgtt > indexid) pgtt = indexid; if (dorecurse) { while (pgtt-- > 0) { err = rend_blog_index(dbh, tplh, pgtt, NULL); TRACE_NOK(err); } } } if (bid > 0) { if (bid > 1) rend_blog(dbh, tplh, bid-1); rend_blog(dbh, tplh, bid); rend_blog(dbh, tplh, bid+1); } ldb_destroy(dbh); ltpl_destroy(tplh); mconfig_cleanup(&g_cfg); return 0; }
int main(int argc, char **argv, char **envp) { CGI *cgi; NEOERR *err = STATUS_OK; HASH *dbh, *tplh, *evth; session_t *session = NULL; char *temps; int http_max_upload; NEOERR* (*data_handler)(CGI *cgi, HASH *dbh, HASH *evth, session_t *session); void *lib; //sleep(20); mutil_makesure_coredump(); mtc_init(TC_ROOT"viki"); err = lerr_init(); DIE_NOK_CGI(err); err = mcfg_parse_file(SITE_CONFIG, &g_cfg); DIE_NOK_CGI(err); err = mtpl_set_tplpath(PATH_TPL); DIE_NOK_CGI(err); err = mtpl_InConfigRend_init(PATH_TPL"/config/email", "email", &g_datah); DIE_NOK_CGI(err); err = mtpl_InConfigRend_init(PATH_TPL"/config/inbox", "inbox", &g_datah); DIE_NOK_CGI(err); err = ltpl_init(&tplh, NULL); DIE_NOK_CGI(err); err = hash_insert(g_datah, "runtime_templates", (void*)tplh); DIE_NOK_CGI(err); err = ldb_init(&dbh); DIE_NOK_CGI(err); err = levt_init(&evth); DIE_NOK_CGI(err); lib = dlopen(NULL, RTLD_NOW|RTLD_GLOBAL); if (!lib) { err = nerr_raise(NERR_SYSTEM, "dlopen %s", dlerror()); DIE_NOK_CGI(err); } #ifdef USE_FASTCGI cgiwrap_init_emu(NULL, &read_cb, &printf_cb, &write_cb, NULL, NULL, NULL); while (FCGI_Accept() >= 0) { #endif cgiwrap_init_std(argc, argv, environ); err = cgi_init(&cgi, NULL); if (err != STATUS_OK) goto response; http_max_upload = hdf_get_int_value(g_cfg, PRE_CONFIG".http_max_upload", 0); if (http_max_upload > 0) { err = mcs_register_upload_parse_cb(cgi, &http_max_upload); if (err != STATUS_OK) goto response; } err = cgi_parse(cgi); if (err != STATUS_OK) goto response; #ifdef NCGI_MODE hdf_set_value(cgi->hdf, PRE_REQ_URI_RW, "/image/member/pic"); hdf_set_value(cgi->hdf, PRE_COOKIE".uin", "1001"); hdf_set_value(cgi->hdf, PRE_COOKIE".uname", "bigml"); hdf_set_value(cgi->hdf, PRE_COOKIE".musn", "8Y]u0|v=*MS]U3J"); hdf_set_value(cgi->hdf, PRE_QUERY".ip", "222.247.56.14"); hdf_set_value(cgi->hdf, PRE_QUERY".to", "cj_BXTSJ"); hdf_set_value(cgi->hdf, PRE_QUERY".s", "koldddd"); hdf_set_value(cgi->hdf, PRE_QUERY".JsonCallback", "Ape.transport.read"); hdf_set_value(cgi->hdf, PRE_QUERY".type", "phone"); hdf_set_value(cgi->hdf, PRE_QUERY".mid", "485010473"); #endif err = session_init(cgi, dbh, &session); if (err != STATUS_OK) goto response; if (lutil_client_attack(cgi->hdf, session, "lcs_uname")) { err = nerr_raise(LERR_ATTACK, "%s need a rest, babey!", session->dataer); goto response; } if ((data_handler = lutil_get_data_handler(lib, cgi, session)) == NULL) { err = nerr_raise(LERR_MISS_DATA, "dataer %s not found", session->dataer); goto response; } err = (*data_handler)(cgi, dbh, evth, session); response: if (cgi != NULL && cgi->hdf != NULL) { lerr_opfinish_json(err, cgi->hdf); if (!session) session = session_default(); switch (session->reqtype) { case CGI_REQ_HTML: err = ltpl_render(cgi, tplh, session); if (err != STATUS_OK) { SAFE_FREE(session->render); if (nerr_match(err, LERR_MISS_TPL)) { session->render = strdup("404"); } else { session->render = strdup("503"); } TRACE_NOK(err); err = ltpl_render(cgi, tplh, session); TRACE_NOK(err); } break; case CGI_REQ_AJAX: resp_ajax: temps = hdf_get_value(cgi->hdf, PRE_REQ_AJAX_FN, NULL); if (temps != NULL) { mjson_execute_hdf(cgi->hdf, temps, session->tm_cache_browser); } else { mjson_output_hdf(cgi->hdf, session->tm_cache_browser); } break; case CGI_REQ_IMAGE: temps = hdf_get_value(cgi->hdf, PRE_OUTPUT".302", NULL); if (temps) { cgi_redirect_uri(cgi, temps); } else if (session->data) { mimg_output(session->data); session->data = NULL; } else goto resp_ajax; break; default: cgi_redirect(cgi, "/503.html"); break; } #ifdef DEBUG_HDF hdf_write_file(cgi->hdf, TC_ROOT"hdf.viki"); #endif cgi_destroy(&cgi); session_destroy(&session); cgi = NULL; session = NULL; } #ifdef USE_FASTCGI } #endif levt_destroy(evth); ldb_destroy(dbh); ltpl_destroy(tplh); mtpl_InConfigRend_destroy(g_datah); mcfg_cleanup(&g_cfg); return 0; }
NEOERR* mmg_query(mmg_conn *db, char *dsn, char *prefix, HDF *outnode) { int count; char key[LEN_HDF_KEY]; HDF *node, *cnode; bson *doc; NEOERR *err; MCS_NOT_NULLB(db, dsn); db->p = mongo_sync_cmd_query(db->con, dsn, db->flags & 0x3FF, db->skip, db->limit, db->docq, db->docs); if (!db->p) { if (errno == ENOENT) { mtc_noise("queried %s 0 result", dsn); if (db->flags & MMG_FLAG_EMPTY) { if (db->query_callback && !db->incallback) { /* * empty result, call callback */ db->incallback = true; err = db->query_callback(db, NULL, true); TRACE_NOK(err); db->incallback = false; db->query_callback = NULL; db->callbackdata = NULL; } return STATUS_OK; } return nerr_raise(NERR_NOT_FOUND, "无此记录"); } return nerr_raise(NERR_DB, "query: %s %d", strerror(errno), errno); } /* * process result */ if (outnode || (db->query_callback && !db->incallback)) { if (outnode) node = outnode; /* need store result */ else hdf_init(&node); db->c = mongo_sync_cursor_new(db->con, dsn, db->p); if (!db->c) return nerr_raise(NERR_DB, "cursor: %s", strerror(errno)); cnode = NULL; count = 0; while (mongo_sync_cursor_next(db->c) && count < db->limit) { memset(key, sizeof(key), 0x0); if (prefix) { if (!(db->flags & MMG_FLAG_MIXROWS) && db->limit > 1) snprintf(key, sizeof(key), "%s.%d", prefix, count); else snprintf(key, sizeof(key), "%s", prefix); } else { if (!(db->flags & MMG_FLAG_MIXROWS) && db->limit > 1) sprintf(key, "%d", count); else key[0] = '\0'; } doc = mongo_sync_cursor_get_data(db->c); err = mbson_export_to_hdf(node, doc, key, MBSON_EXPORT_TYPE, true); if (err != STATUS_OK) return nerr_pass(err); if (!cnode) cnode = hdf_get_obj(node, key); count++; } db->rescount = count; mongo_sync_cursor_free(db->c); db->c = NULL; db->p = NULL; mtc_noise("queried %s %d result", dsn, count); /* * call callback at last. because we don't want declare more mmg_conn* * it's safe to do new query in callback on result stored (db->c freeed) * we can call mmg_query() recursive, the callback won't. */ if (db->query_callback && !db->incallback) { db->incallback = true; count = 0; while (cnode) { count++; if (db->rescount == count) err = db->query_callback(db, cnode, true); else err = db->query_callback(db, cnode, false); TRACE_NOK(err); cnode = hdf_obj_next(cnode); } db->incallback = false; /* * query_callback can't be shared with multiply query * later query must set them again even if TheSameOne */ db->query_callback = NULL; db->callbackdata = NULL; } if (!outnode) hdf_destroy(&node); } else { /* don't need result */ mongo_wire_packet_free(db->p); db->c = NULL; db->p = NULL; } return STATUS_OK; }
NEOERR* ltpl_parse_file(HASH *dbh, HASH *evth, void *lib, char *dir, char *name, HASH *outhash) { char *tp = NULL, *tpl = NULL, *val = NULL; HDF *node = NULL, *dhdf = NULL, *child = NULL, *thdf = NULL; CSPARSE *cs = NULL; STRING str; char fname[_POSIX_PATH_MAX], tok[64], *outfile; NEOERR* (*data_handler)(HDF *hdf, HASH *dbh, HASH *evth); NEOERR *err; memset(fname, 0x0, sizeof(fname)); snprintf(fname, sizeof(fname), "%s/%s", dir, name); err = hdf_init(&node); if (err != STATUS_OK) return nerr_pass(err); err = hdf_read_file(node, fname); if (err != STATUS_OK) return nerr_pass(err); child = hdf_obj_child(node); while (child != NULL) { mtc_dbg("parse node %s", hdf_obj_name(child)); string_init(&str); val = mcs_obj_attr(child, "merge"); if (val) { ULIST *list; string_array_split(&list, val, ",", 10); ITERATE_MLIST(list) { snprintf(fname, sizeof(fname), "%s/%s", dir, neos_strip((char*)list->items[t_rsv_i])); err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_read_file(dhdf, fname); JUMP_NOK(err, wnext); err = hdf_copy(child, NULL, dhdf); JUMP_NOK(err, wnext); } uListDestroy(&list, ULIST_FREE); } /* * can't use dataset directly, because we'll destroy the whole node */ err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_get_node(child, PRE_CFG_DATASET, &thdf); JUMP_NOK(err, wnext); err = hdf_copy(dhdf, NULL, thdf); JUMP_NOK(err, wnext); err = cs_init(&cs, dhdf); JUMP_NOK(err, wnext); hdf_set_value(cs->hdf, "hdf.loadpaths.tpl", PATH_TPL); hdf_set_value(cs->hdf, "hdf.loadpaths.local", dir); err = cgi_register_strfuncs(cs); JUMP_NOK(err, wnext); err = mcs_register_bitop_functions(cs); JUMP_NOK(err, wnext); err = mcs_register_mkd_functions(cs); JUMP_NOK(err, wnext); err = mcs_register_string_uslice(cs); JUMP_NOK(err, wnext); tpl = hdf_get_value(child, PRE_CFG_LAYOUT, "null.html"); snprintf(fname, sizeof(fname), "%s/%s", PATH_TPL, tpl); err = cs_parse_file(cs, fname); JUMP_NOK(err, wnext); if (outhash != NULL) { /* * store template for rend stage use */ hdf_set_value(cs->hdf, PRE_RESERVE"."PRE_CFG_LAYOUT, tpl); /* * strdup the key, baby, because we'll free the hdf later */ err = hash_insert(outhash, (void*)strdup(hdf_obj_name(child)), (void*)cs); JUMP_NOK(err, wnext); snprintf(tok, sizeof(tok), "%s_hdf", hdf_obj_name(child)); err = hash_insert(outhash, (void*)strdup(tok), (void*)cs->hdf); JUMP_NOK(err, wnext); } if ((outfile = hdf_get_value(child, PRE_CFG_OUTPUT, NULL)) != NULL) { ltpl_prepare_rend(cs->hdf, tpl); /* * get_data */ val = hdf_get_value(child, PRE_CFG_DATAER, NULL); if (val != NULL && lib) { data_handler = dlsym(lib, val); if( (tp = dlerror()) != NULL) { mtc_err("%s", tp); //continue; } else { err = (*data_handler)(cs->hdf, dbh, evth); TRACE_NOK(err); } } err = cs_render(cs, &str, mcs_strcb); JUMP_NOK(err, wnext); /* * produce output filename */ val = mcs_hdf_attr(child, PRE_CFG_OUTPUT, "ftime"); if (val) { char tm[LEN_TM]; mutil_getdatetime(tm, sizeof(tm), val, 0); outfile = mstr_repstr(1, outfile, "$ftime$", tm); } snprintf(fname, sizeof(fname), PATH_DOC"%s", outfile); /* * output file */ err = mfile_makesure_dir(fname); JUMP_NOK(err, wnext); err = mcs_str2file(str, fname); JUMP_NOK(err, wnext); #ifdef DEBUG_HDF snprintf(fname, sizeof(fname), "%s/hdf.%s", TC_ROOT, hdf_obj_name(child)); hdf_write_file(child, fname); #endif } wnext: if (cs != NULL && outhash == NULL) cs_destroy(&cs); string_clear(&str); child = hdf_obj_next(child); } if (node != NULL) hdf_destroy(&node); return STATUS_OK; }
NEOERR* ltpl_parse_file(HASH *dbh, void *lib, char *dir, char *name, HASH *outhash) { char *tp = NULL, *tpl = NULL, *val = NULL; HDF *node = NULL, *dhdf = NULL, *child = NULL; CSPARSE *cs = NULL; STRING str; char fname[_POSIX_PATH_MAX], tok[64]; NEOERR* (*data_handler)(HDF *hdf, HASH *dbh); NEOERR *err; memset(fname, 0x0, sizeof(fname)); snprintf(fname, sizeof(fname), "%s/%s", dir, name); err = hdf_init(&node); if (err != STATUS_OK) return nerr_pass(err); err = hdf_read_file(node, fname); if (err != STATUS_OK) return nerr_pass(err); child = hdf_obj_child(node); while (child != NULL) { mtc_dbg("parse node %s", hdf_obj_name(child)); string_init(&str); val = mutil_obj_attr(child, "merge"); if (val) { snprintf(fname, sizeof(fname), "%s/%s", dir, val); err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_read_file(dhdf, fname); JUMP_NOK(err, wnext); err = hdf_copy(child, NULL, dhdf); JUMP_NOK(err, wnext); } err = cs_init(&cs, hdf_get_obj(child, PRE_CFG_DATASET)); JUMP_NOK(err, wnext); hdf_set_value(cs->hdf, "hdf.loadpaths.local", dir); err = cgi_register_strfuncs(cs); JUMP_NOK(err, wnext); err = mcs_register_bitop_functions(cs); JUMP_NOK(err, wnext); err = mcs_register_mkd_functions(cs); JUMP_NOK(err, wnext); tpl = hdf_get_value(child, PRE_CFG_LAYOUT, "null.html"); snprintf(fname, sizeof(fname), "%s/%s", PATH_TPL, tpl); err = cs_parse_file(cs, fname); JUMP_NOK(err, wnext); if (outhash != NULL) { /* * strdup the key, baby, because we'll free the hdf later */ err = hash_insert(outhash, (void*)strdup(hdf_obj_name(child)), (void*)cs); JUMP_NOK(err, wnext); if (hdf_get_obj(child, PRE_CFG_DATASET)) { err = hdf_init(&dhdf); JUMP_NOK(err, wnext); err = hdf_copy(dhdf, NULL, hdf_get_obj(child, PRE_CFG_DATASET)); JUMP_NOK(err, wnext); snprintf(tok, sizeof(tok), "%s_hdf", hdf_obj_name(child)); err = hash_insert(outhash, (void*)strdup(tok), (void*)dhdf); JUMP_NOK(err, wnext); } } if (hdf_get_value(child, PRE_CFG_OUTPUT, NULL) != NULL) { ltpl_prepare_rend(hdf_get_obj(child, PRE_CFG_DATASET), tpl); /* * get_data */ val = hdf_get_value(child, PRE_CFG_DATAER, NULL); if (val != NULL && lib) { data_handler = dlsym(lib, val); if( (tp = dlerror()) != NULL) { mtc_err("%s", tp); //continue; } else { err = (*data_handler)(hdf_get_obj(child, PRE_CFG_DATASET), dbh); TRACE_NOK(err); } } err = cs_render(cs, &str, mcs_strcb); JUMP_NOK(err, wnext); snprintf(fname, sizeof(fname), PATH_DOC"%s", hdf_get_value(child, PRE_CFG_OUTPUT, "null.html")); err = mutil_makesure_dir(fname); JUMP_NOK(err, wnext); err = mcs_str2file(str, fname); JUMP_NOK(err, wnext); #ifdef DEBUG_HDF snprintf(fname, sizeof(fname), "%s/hdf.%s", TC_ROOT, hdf_obj_name(child)); hdf_write_file(child, fname); #endif } wnext: if (cs != NULL && outhash == NULL) cs_destroy(&cs); string_clear(&str); child = hdf_obj_next(child); } if (node != NULL) hdf_destroy(&node); return STATUS_OK; }
static NEOERR* city_cmd_s(struct city_entry *e, QueueEntry *q) { unsigned char *val = NULL; size_t vsize = 0; char *p = NULL, *c; NEOERR *err; mdb_conn *db = e->db; struct cache *cd = e->cd; REQ_GET_PARAM_STR(q->hdfrcv, "c", c); REQ_FETCH_PARAM_STR(q->hdfrcv, "p", p); if (cache_getf(cd, &val, &vsize, PREFIX_CITY"%s.%s", p, c)) { unpack_hdf(val, vsize, &q->hdfsnd); } else { if (p) { char tok[64] = {0}; strncpy(tok, p, 64); if (!strstr(p, "省") && !strstr(p, "区")) snprintf(tok, sizeof(tok), "%s省", p); MDB_QUERY_RAW(db, "city", _COL_CITY, "s=$1", "s", tok); mdb_set_row(q->hdfsnd, db, _COL_CITY, "province", MDB_FLAG_NO_ERR); } MDB_QUERY_RAW(db, "city", _COL_CITY, "s=$1", "s", c); err = mdb_set_rows(q->hdfsnd, db, _COL_CITY, "citys", NULL, MDB_FLAG_Z); if (nerr_handle(&err, NERR_NOT_FOUND)) { if (strstr(c, "市")) c[strlen(c)-3] = '\0'; MDB_QUERY_RAW(db, "city", _COL_CITY, "s=$1", "s", c); err = mdb_set_rows(q->hdfsnd, db, _COL_CITY, "citys", NULL, MDB_FLAG_EMPTY_OK); } if (err != STATUS_OK) return nerr_pass(err); /* * get city's parents */ int cnt = 0; char *pid = hdf_get_valuef(q->hdfsnd, "citys.0.pid"); while (pid && atoi(pid) > 0) { MDB_QUERY_RAW(db, "city", _COL_CITY, "id=%d", NULL, atoi(pid)); err = mdb_set_rows(q->hdfsnd, db, _COL_CITY, "citys", NULL, MDB_FLAG_Z); TRACE_NOK(err); pid = hdf_get_valuef(q->hdfsnd, "citys.%d.pid", ++cnt); } /* * 北京市 has no subcities */ /* int id = hdf_get_int_value(q->hdfsnd, "city.id", 0); MDB_QUERY_RAW(db, "city", _COL_CITY, "pid=%d", NULL, id); err = mdb_set_rows(q->hdfsnd, db, _COL_CITY, "subcities", NULL, MDB_FLAG_EMPTY_OK); if (err != STATUS_OK) return nerr_pass(err); */ CACHE_HDF(q->hdfsnd, CITY_CC_SEC, PREFIX_CITY"%s.%s", p, c); } return STATUS_OK; }
void msparse_buf(moc_t *evt, int order, int fd, unsigned char *buf, size_t len, moc_arg *arg) { uint32_t totaltoget = 0; moc_srv *srv; NEOERR *err; if (!evt || !buf) { mtc_err("param null"); return; } /* * validate */ if (evt->nservers < order) { mtc_err("order %d > server %d", order, evt->nservers); return; } srv = &(evt->servers[order]); if (srv->fd != fd) { mtc_err("fd not equal %d %d", srv->fd, fd); return; } /* * copy from process_buf() on server/tcp.c */ if (len >= 4) { totaltoget = * (uint32_t*) buf; totaltoget = ntohl(totaltoget); if (totaltoget > (64 * 1024) || totaltoget <= 8) { mtc_err("message illegal %d", totaltoget); return; } } else totaltoget = 4; if (totaltoget > len) { if (srv->buf == NULL) { srv->buf = malloc(SBSIZE); if (!srv->buf) { mtc_foo("out of memory"); return; } memcpy(srv->buf, buf, len); srv->len = len; } else { srv->len = len; } srv->pktsize = totaltoget; /* need rereceive */ return; } if (totaltoget < len) { srv->excess = len - totaltoget; len = totaltoget; } err = msparse_msg(srv, buf + 4, len - 4, arg); TRACE_NOK(err); if (srv->excess) { memmove(buf, buf + len, srv->excess); srv->len = srv->excess; srv->excess = 0; msparse_buf(evt, order, fd, buf, srv->len, arg); /* need reprocess */ return; } if (srv->buf) { free(srv->buf); srv->buf = NULL; srv->len = 0; srv->pktsize = 0; srv->excess = 0; } return; }