NEOERR* mmg_string_update(mmg_conn *db, char *dsn, int flags, char *up, char *sel)
{
bson *doca, *docb;
MCS_NOT_NULLC(db, dsn, up);
mtc_noise("update %s %s %s", dsn, up, sel);
if (sel) {
doca = mbson_new_from_string(sel, true);
if (!doca) return nerr_raise(NERR_ASSERT, "build doc sel: %s: %s",
sel, strerror(errno));
} else doca = NULL;
docb = mbson_new_from_string(up, true);
if (!docb) return nerr_raise(NERR_ASSERT, "build doc up: %s: %s",
up, strerror(errno));
if (!mongo_sync_cmd_update(db->con, dsn, flags, doca, docb))
return nerr_raise(NERR_DB, "sync_cmd_update: %s", strerror(errno));
bson_free(doca);
bson_free(docb);
return STATUS_OK;
}
NEOERR* mimg_accept(CGI *cgi, char *form_name, char *imgroot,
char result[LEN_MD5], int *ftype)
{
unsigned char data[IMAGE_MD5_SIZE];
unsigned int bytes;
char tok[3] = {0};
NEOERR *err;
FILE *fp, *fpout;
char *s;
MCS_NOT_NULLC(cgi->hdf, imgroot, ftype);
/* TODO memory leak */
fp = mfile_get_safe_from_std(cgi_filehandle(cgi, form_name));
MCS_NOT_NULLA(fp);
s = mfile_get_type(cgi, form_name);
if (!s || strncmp(s, "image/", 6)) {
return nerr_raise(NERR_ASSERT, "file %s not image type", s);
}
s = s + 6;
*ftype = mimg_type_str2int(s);
memset(data, 0x0, sizeof(data));
fseek(fp, 0, SEEK_SET);
bytes = fread(data, 1, sizeof(data), fp);
if (bytes <= 0) return nerr_raise(NERR_IO, "read image file error %d ", bytes);
mstr_md5_buf(data, bytes, result);
strncpy(tok, result, 2);
err = mfile_openf(&fpout, "w+", "%s/%s/%s.%s",
imgroot, tok, result, mimg_type_int2str(*ftype));
if (err != STATUS_OK) return nerr_pass(err);
s = hdf_get_value(cgi->hdf, PRE_QUERY"._upfile_data_type", NULL);
if (s && !strcmp(s, "dataurl")) {
err = mb64_decode(fp, fpout);
if (err != STATUS_OK) return nerr_pass(err);
} else {
if (bytes < IMAGE_MD5_SIZE-10) {
fwrite(data, 1, bytes, fpout);
} else {
mfile_copy(fpout, fp);
}
}
fclose(fpout);
return STATUS_OK;
}
NEOERR* 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;
}
NEOERR* base_msg_new(char *cmd, HDF *datanode, unsigned char **buf, size_t *size)
{
NEOERR *err;
MCS_NOT_NULLC(cmd, datanode, buf);
MCS_NOT_NULLA(size);
size_t bsize, vsize;
unsigned char *rbuf;
uint32_t t;
memset(static_buf, 0x0, MAX_PACKET_LEN);
hdf_set_value(datanode, "_Reserve", "moc");
err = hdf_set_attr(datanode, "_Reserve", "cmd", cmd);
if (err != STATUS_OK) return nerr_pass(err);
TRACE_HDF(datanode);
vsize = pack_hdf(datanode, static_buf, MAX_PACKET_LEN);
if(vsize <= 0) return nerr_raise(NERR_ASSERT, "packet error");
/*
* copy from tcp.c tcp_reply_long()
*/
bsize = 4 + 4 + 4 + 4 + vsize;
rbuf = calloc(1, bsize);
if (!rbuf) return nerr_raise(NERR_NOMEM, "alloc msg buffer");
t = htonl(bsize);
memcpy(rbuf, &t, 4);
/*
* server 主动发给 client 的包，reqid == 0, && reply == 10000
*/
t = 0;
memcpy(rbuf + 4, &t, 4);
t = htonl(10000);
memcpy(rbuf + 8, &t, 4);
t = htonl(vsize);
memcpy(rbuf + 12, &t, 4);
memcpy(rbuf + 16, static_buf, vsize);
*buf = rbuf;
*size = bsize;
return STATUS_OK;
}
NEOERR* masset_node_load(char *dir, char *name, RendAsset **pa)
{
AssetDriver *driver;
RendAsset *asset = NULL;
int driverindex;
HASH *mh;
NEOERR *err;
mh = hash_lookup(g_datah, ASSET_KEY);
MCS_NOT_NULLC(name, pa, mh);
*pa = NULL;
asset = hash_lookup(mh, name);
if (asset) goto done;
char *p = strrchr(name, '.');
if (p) p = p + 1;
if (!p || !*p) return nerr_raise(NERR_ASSERT, "unknown asset type %s", name);
driverindex = uListIndex(asset_drivers, p, asset_driver_comp);
if (driverindex < 0) return nerr_raise(NERR_ASSERT, "unknown asset type %s", name);
err = uListGet(asset_drivers, driverindex, (void**)&driver);
if (err != STATUS_OK) return nerr_pass(err);
mtc_dbg("load asset %s%s", dir, name);
err = driver->load(dir, name, &asset);
if (err != STATUS_OK) return nerr_pass(err);
if (!asset) return nerr_raise(NERR_ASSERT, "asset node %s empty", name);
asset->name = strdup(name);
asset->driverindex = driverindex;
hash_remove(mh, name);
hash_insert(mh, strdup(name), asset);
done:
*pa = asset;
return STATUS_OK;
}
NEOERR* mmg_delete(mmg_conn *db, char *dsn, int flags, char *sel)
{
bson *doc;
MCS_NOT_NULLC(db, dsn, sel);
mtc_noise("delete %s %s", dsn, sel);
doc = mbson_new_from_string(sel, true);
if (!doc) return nerr_raise(NERR_ASSERT, "build doc: %s: %s",
sel, strerror(errno));
if (!mongo_sync_cmd_delete(db->con, dsn, flags, doc))
return nerr_raise(NERR_DB, "sync_cmd_delete: %s", strerror(errno));
bson_free(doc);
return STATUS_OK;
}
NEOERR* mmg_count(mmg_conn *db, char *dbname, char *collname, int *ret, char *querys)
{
bson *doc;
MCS_NOT_NULLC(db, dbname, collname);
MCS_NOT_NULLB(querys, ret);
mtc_noise("count %s.%s %s", dbname, collname, querys);
doc = mbson_new_from_string(querys, true);
if (!doc) return nerr_raise(NERR_ASSERT, "build doc: %s: %s",
querys, strerror(errno));
*ret = (int)mongo_sync_cmd_count(db->con, dbname, collname, doc);
bson_free(doc);
return STATUS_OK;
}
NEOERR* mmg_hdf_insert(mmg_conn *db, char *dsn, HDF *node)
{
bson *doc;
NEOERR *err;
MCS_NOT_NULLC(db, dsn, node);
mtc_noise("insert hdf %s", dsn);
err = mbson_import_from_hdf(node, &doc, true);
if (err != STATUS_OK) return nerr_pass(err);
if (!mongo_sync_cmd_insert(db->con, dsn, doc, NULL))
return nerr_raise(NERR_DB, "sync_cmd_insert: %s", strerror(errno));
bson_free(doc);
return STATUS_OK;
}
NEOERR* mmg_string_insert(mmg_conn *db, char *dsn, char *str)
{
bson *doc;
MCS_NOT_NULLC(db, dsn, str);
mtc_noise("insert string %s %s", dsn, str);
doc = mbson_new_from_string(str, true);
if (!doc) return nerr_raise(NERR_ASSERT, "build doc: %s: %s",
str, strerror(errno));
if (!mongo_sync_cmd_insert(db->con, dsn, doc, NULL))
return nerr_raise(NERR_DB, "sync_cmd_insert: %s", strerror(errno));
bson_free(doc);
return STATUS_OK;
}
NEOERR* ldml_render(char *filename, char *keyname, HDF *datanode, HDF *outnode)
{
HASH *datah;
HDF *confignode;
MCS_NOT_NULLC(filename, keyname, outnode);
datah = hash_lookup(g_datah, "runtime_dml");
MCS_NOT_NULLA(datah);
confignode = hash_lookupf(datah, "%s.hdf", filename);
if (!confignode) return nerr_raise(NERR_ASSERT, "data file %s nexist", filename);
confignode = hdf_get_obj(confignode, keyname);
if (!confignode) return nerr_raise(NERR_ASSERT, "%s.hdf %s nexist",
filename, keyname);
return nerr_pass(mcs_data_rend(confignode, datanode, outnode));
}
NEOERR* email_add(HDF *datanode, HASH *evth, char *emailtype, char *mname)
{
mevent_t *evt;
NEOERR *err;
MCS_NOT_NULLC(datanode, evth, mname);
evt = hash_lookup(evth, "aux");
MCS_NOT_NULLA(evt);
err = mtpl_InConfigRend_get(evt->hdfsnd, datanode, "email", emailtype, g_datah);
if (err != STATUS_OK) return nerr_pass(err);
hdf_set_value(evt->hdfsnd, "to", mname);
MEVENT_TRIGGER(evt, NULL, REQ_CMD_AUX_EMAIL_ADD, FLAGS_NONE);
return STATUS_OK;
}
NEOERR* mmg_custom(mmg_conn *db, char *dbname,
char *prefix, HDF *outnode, char *command)
{
mongo_packet *p;
mongo_sync_cursor *c;
bson *doc;
NEOERR *err;
MCS_NOT_NULLC(db, dbname, command);
mtc_noise("custom %s %s", dbname, command);
/*
* doc
*/
doc = mbson_new_from_string(command, true);
if (!doc) return nerr_raise(NERR_ASSERT, "build doc custom %s", command);
p = mongo_sync_cmd_custom(db->con, dbname, doc);
bson_free(doc);
if (!p)
return nerr_raise(NERR_DB, "sync_cmd_custom: %s %s", command, strerror(errno));
c = mongo_sync_cursor_new(db->con, dbname, p);
if (!c) return nerr_raise(NERR_DB, "cursor: %s", strerror(errno));
if (outnode) {
if (mongo_sync_cursor_next(c)) {
doc = mongo_sync_cursor_get_data(c);
if (!doc) return nerr_raise(NERR_DB, "doc: %s", strerror(errno));
err = mbson_export_to_hdf(outnode, doc, prefix, MBSON_EXPORT_TYPE, true);
if (err != STATUS_OK) return nerr_pass(err);
} else return nerr_raise(NERR_DB, "cursor next: %s", strerror(errno));
}
mongo_sync_cursor_free(c);
return STATUS_OK;
}
NEOERR* mfile_openf(FILE **fp, const char *mode, char *fmt, ...)
{
NEOERR *err;
MCS_NOT_NULLC(fp, mode, fmt);
char fname[LEN_FN];
va_list ap;
va_start(ap, fmt);
vsnprintf(fname, sizeof(fname), fmt, ap);
va_end(ap);
err = mfile_makesure_dir(fname);
if (err != STATUS_OK) return nerr_pass(err);
FILE *fpout = fopen(fname, mode);
if (!fpout) return nerr_raise(NERR_SYSTEM, "create %s failre", fname);
*fp = fpout;
return STATUS_OK;
}
/*
* we don't pass tplh parameter to it,
* because walker don't have it. so, tplh stored in the g_datah
*/
NEOERR* ltpl_render2file(CGI *cgi, char *render, char *fname)
{
STRING str; string_init(&str);
HASH *tplh;
CSPARSE *cs;
HDF *dhdf;
NEOERR *err;
MCS_NOT_NULLC(cgi->hdf, render, fname);
tplh = hash_lookup(g_datah, "runtime_templates");
MCS_NOT_NULLA(tplh);
cs = hash_lookup(tplh, render);
MCS_NOT_NULLA(cs);
dhdf = hash_lookupf(tplh, "%s_hdf", render);
if (dhdf) hdf_copy(cgi->hdf, NULL, dhdf);
ltpl_prepare_rend(cgi->hdf, hdf_get_value(cgi->hdf,
PRE_RESERVE"."PRE_CFG_LAYOUT,
"layout.html"));
cs->hdf = cgi->hdf;
err = cs_render(cs, &str, mcs_strcb);
if (err != STATUS_OK) return nerr_pass(err);
err = mfile_makesure_dir(fname);
if (err != STATUS_OK) return nerr_pass(err);
err = mcs_str2file(str, fname);
if (err != STATUS_OK) return nerr_pass(err);
string_clear(&str);
return STATUS_OK;
}
