bool Tree::ParseFromHdfFile(const std::string &filename)
{
Clear();
HDF *hdf;
NEOERR *err = hdf_init(&hdf);
if (err != STATUS_OK) {
nerr_ignore(&err);
return false;
}
err = hdf_read_file(hdf, filename.c_str());
if (err != STATUS_OK) {
nerr_ignore(&err);
hdf_destroy(&hdf);
return false;
}
HDF *child = hdf_obj_child(hdf);
if (!child) {
hdf_destroy(&hdf);
return false;
}
if (!ParseFromHdfInternal(child)) {
hdf_destroy(&hdf);
return false;
}
hdf_destroy(&hdf);
return true;
}
bool Tree::ParseFromHdfString(const std::string &serialized)
{
Clear();
if (serialized.empty()) {
return true;
}
HDF *hdf;
NEOERR *err = hdf_init(&hdf);
if (err != STATUS_OK) {
nerr_ignore(&err);
return false;
}
err = hdf_read_string(hdf, serialized.c_str());
if (err != STATUS_OK) {
nerr_ignore(&err);
hdf_destroy(&hdf);
return false;
}
HDF *child = hdf_obj_child(hdf);
if (!child) {
hdf_destroy(&hdf);
return false;
}
if (!ParseFromHdfInternal(child)) {
hdf_destroy(&hdf);
return false;
}
hdf_destroy(&hdf);
return true;
}
bool Tree::SerializeToHdfString(std::string *serialized,
bool only_nodes_with_value) const
{
if (!serialized) {
return false;
}
NEOERR *err;
HDF *hdf;
err = hdf_init(&hdf);
if (err != STATUS_OK) {
nerr_ignore(&err);
return false;
}
if (!SerializeToHdfInternal(hdf, only_nodes_with_value)) {
hdf_destroy(&hdf);
return false;
}
char *str;
err = hdf_write_string(hdf, &str);
if (err != STATUS_OK) {
nerr_ignore(&err);
hdf_destroy(&hdf);
return false;
}
serialized->assign(str);
hdf_destroy(&hdf);
free(str);
return true;
}
bool Tree::SerializeToHdfFile(const std::string &filename,
bool only_nodes_with_value) const
{
NEOERR *err;
HDF *hdf;
err = hdf_init(&hdf);
if (err != STATUS_OK) {
nerr_ignore(&err);
return false;
}
if (!SerializeToHdfInternal(hdf, only_nodes_with_value)) {
hdf_destroy(&hdf);
return false;
}
err = hdf_write_file(hdf, filename.c_str());
if (err != STATUS_OK) {
nerr_ignore(&err);
hdf_destroy(&hdf);
return false;
}
hdf_destroy(&hdf);
return true;
}
bool Tree::SerializeToHdfInternal(struct _hdf *hdf,
bool only_nodes_with_value) const
{
for (std::map<std::string, Tree *>::const_iterator p = _children.begin();
p != _children.end(); ++p) {
if (!p->second->SerializeToHdfInternal(hdf, only_nodes_with_value)) {
return false;
}
}
// Any intermediate nodes with empty value are filtered out.
// Leaf nodes are controlled by only_nodes_with_value.
if (_value.empty()) {
if (!_children.empty() || only_nodes_with_value) {
return true;
}
}
NEOERR *err = hdf_set_value(hdf, _full_path.c_str(), _value.c_str());
if (err != STATUS_OK) {
nerr_ignore(&err);
return false;
}
return true;
}
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);
}
void ewf_fastcgi_display( const char *name )
{
NEOERR *err;
/*printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n"); */
if ( access( name, F_OK | R_OK ) != 0 ) {
nbu_log_debug( "cannot read CST file: '%s'", name );
}
else {
nbu_log_debug( "read CST file: '%s'", name );
}
err = cgi_display( cgi, name );
#ifdef DEBUG
if ( err != NULL ) {
nbu_log_debug( "error in cgi_display!" );
cgi_neo_error( cgi, err );
}
#endif
nerr_ignore( &err );
return;
}
void api_begin( void )
{
NEOERR *err;
err = cgi_init( &cgi, NULL );
nerr_ignore( &err );
}
void lerr_opfinish_json(NEOERR *err, HDF *hdf)
{
if (err == STATUS_OK) {
hdf_set_value(hdf, PRE_SUCCESS, "1");
mcs_set_int_attr(hdf, PRE_SUCCESS, "type", CNODE_TYPE_INT);
return;
}
hdf_remove_tree(hdf, PRE_SUCCESS);
NEOERR *neede = mcs_err_valid(err);
/* set PRE_ERRXXX with the most recently err */
mcs_set_int_value_with_type(hdf, PRE_ERRCODE, neede->error, CNODE_TYPE_INT);
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);
}
void ewf_fastcgi_parse( void )
{
NEOERR *err;
err = cgi_parse( cgi );
nerr_ignore( &err );
nbu_log_info( "POST request method" );
return;
}
PyObject * p_neo_error (NEOERR *err)
{
STRING str;
string_init (&str);
if (nerr_match(err, NERR_PARSE))
{
nerr_error_string (err, &str);
PyErr_SetString (NeoParseError, str.buf);
}
else
{
nerr_error_traceback (err, &str);
PyErr_SetString (NeoError, str.buf);
}
string_clear (&str);
nerr_ignore(&err);
return NULL;
}
void ewf_request_init(ewf_request_t *request)
{
NEOERR *err = NULL;
/* fill cgi struct */
err = cgi_init(&cgi, NULL);
if (err != NULL)
{
#ifdef DEBUG
cgi_neo_error(cgi, err);
#endif
nerr_log_error(err);
nerr_ignore(&err);
}
request->type = ewf_request_type();
request->uri = hdf_get_value(cgi->hdf, "CGI.RequestURI", "/");
}
// Throws a runtime exception back to the Java VM appropriate for the type of
// error and frees the NEOERR that is passed in.
// TODO: throw more specific exceptions for errors like NERR_IO and NERR_NOMEM
int jNeoErr(JNIEnv *env, NEOERR *err) {
STRING str;
string_init(&str);
if (nerr_match(err, NERR_PARSE)) {
nerr_error_string(err, &str);
throwRuntimeException(env, str.buf);
} else if (nerr_match(err, NERR_IO)) {
nerr_error_string(err, &str);
throwIOException(env, str.buf);
} else if (nerr_match(err, NERR_NOMEM)) {
nerr_error_string(err, &str);
throwOutOfMemoryError(env, str.buf);
} else {
nerr_error_traceback(err, &str);
throwRuntimeException(env, str.buf);
}
nerr_ignore(&err); // free err, otherwise it would leak
string_clear(&str);
return 0;
}
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;
}
int main(int argc, char *argv[])
{
argv = cmdline_setup(argc, argv);
if (!argv) {
fprintf(stderr, "Failed to setup cmdline library.\n");
return EXIT_FAILURE;
}
// Initialize timezone before going multi-threaded.
tzset();
// Initialize weak (but fast) PRG rand(3).
randomize();
#if HAVE_OPENSSL_OPENSSLV_H
// Initialize OpenSSL.
OpenSSL_add_all_algorithms();
if (SSL_library_init() != 1) {
fprintf(stderr, "Failed to initialize OpenSSL.\n");
return false;
}
#endif
#if HAVE_CURL_CURL_H_
// Initialize libcurl.
if (curl_global_init(CURL_GLOBAL_ALL)) {
fprintf(stderr, "Failed to initialize libcurl.\n");
return EXIT_FAILURE;
}
#endif
#if HAVE_LIBXML_XMLVERSION_H
// Initialize XML.
if (!flinter::Xml::Initialize()) {
fprintf(stderr, "Failed to initialize libxml2.\n");
return false;
}
#endif
// Initialize FastCGI.
if (FCGX_Init()) {
fprintf(stderr, "Failed to initialize FastCGI.\n");
return false;
}
// Initialize ClearSilver.
// Nothing to do.
int ret = fastcgi_main(argc, argv);
#if HAVE_NERR_SHUTDOWN
// ClearSilver leaks.
NEOERR *err = nerr_shutdown();
if (err != STATUS_OK) {
nerr_ignore(&err);
}
#endif
// FCGX leaks.
OS_LibShutdown();
#if HAVE_LIBXML_XMLVERSION_H
// Shutdown libxml2.
flinter::Xml::Shutdown();
#endif
#if HAVE_CURL_CURL_H
// Shutdown libcurl.
curl_global_cleanup();
#endif
#if HAVE_OPENSSL_OPENSSLV_H
// Shutdown OpenSSL.
#if HAVE_SSL_LIBRARY_CLEANUP
SSL_library_cleanup();
#endif
EVP_cleanup();
CRYPTO_cleanup_all_ex_data();
ERR_remove_thread_state(NULL);
#endif
google::protobuf::ShutdownProtobufLibrary();
return ret;
}
bool Tree::RenderTemplateInternal(const std::string &tmpl,
bool file_or_string,
std::ostream *out,
std::string *error) const
{
if (!out) {
return false;
}
CSPARSE *csparse = NULL;
HDF *hdf = NULL;
NEOERR *err;
do {
err = hdf_init(&hdf);
if (err != STATUS_OK) {
break;
}
if (!SerializeToHdfInternal(hdf, true)) {
hdf_destroy(&hdf);
if (error) {
*error = "SerializationError: serializing to HDF failed";
}
return false;
}
err = cs_init(&csparse, hdf);
if (err != STATUS_OK) {
break;
}
err = cgi_register_strfuncs(csparse);
if (err != STATUS_OK) {
break;
}
if (file_or_string) {
err = cs_parse_file(csparse, tmpl.c_str());
} else {
char *ctmpl = strdup(tmpl.c_str());
if (!ctmpl) {
cs_destroy(&csparse);
hdf_destroy(&hdf);
if (error) {
*error = "MemoryError: allocating buffer for template";
}
break;
}
err = cs_parse_string(csparse, ctmpl, tmpl.length());
}
if (err != STATUS_OK) {
break;
}
err = cs_render(csparse, out, RenderCallback);
if (err != STATUS_OK) {
break;
}
} while (false);
cs_destroy(&csparse);
hdf_destroy(&hdf);
if (err != STATUS_OK && error) {
STRING str;
string_init(&str);
nerr_error_string(err, &str);
*error = str.buf;
string_clear(&str);
nerr_ignore(&err);
return false;
}
return true;
}
