int workflow::execute(const int argc, const char* argv[]) { try { const auto o(generate_darting_options(argc, argv)); /* * Can only happen if the options are valid but do not * require any action. */ if (!o) return 0; const auto& s(*o); initialise_model_name(s); initialise_logging(s); dart(s); } catch (const darter::parser_validation_error& e) { /* * Log known not to be initialised as we are still parsing * command line options. */ std::cerr << usage_error_msg << e.what() << std::endl << more_information << std::endl; return 1; } catch (const std::exception& e) { report_exception(e); return 1; } catch(...) { report_exception(); return 1; } return 0; }
static v8::Handle<v8::Value> Include(const v8::Arguments& args) { for (int i=0; i < args.Length(); i++) { v8::String::Utf8Value filename(args[i]); std::string javascript_source = load_file(*filename); if (javascript_source.length() > 0) { v8::TryCatch tryCatch; v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(javascript_source.c_str()), v8::String::New(*filename)); if (script.IsEmpty()) { std::cerr << "Compiling included script failed:" << std::endl; report_exception(&tryCatch); exit(1); } v8::Handle<v8::Value> result = script->Run(); if (result.IsEmpty()) { std::cerr << "Running included script failed:" << std::endl; report_exception(&tryCatch); exit(1); } } } return v8::Undefined(); }
int workflow::execute(const int argc, const char* argv[]) { try { const auto o(generate_stitching_options_activity(argc, argv)); /* can only happen if the options are valid but do not * require any action. */ if (!o) return 0; const auto& s(*o); initialise_template_name(s); initialise_logging_activity(s); stitch_activity(s); } catch (const stitcher::parser_validation_error& e) { /* log known not to be initialised as we are still parsing * command line options. */ std::cerr << usage_error_msg << e.what() << std::endl; return 1; } catch (const std::exception& e) { report_exception(e); return 1; } catch(...) { report_exception(); return 1; } return 0; }
/* create/initialize an object */ DB_ENV_JAVAINFO * dbjie_construct(JNIEnv *jnienv, jobject default_errcall, int is_dbopen) { DB_ENV_JAVAINFO *dbjie; dbjie = (DB_ENV_JAVAINFO *)malloc(sizeof(DB_ENV_JAVAINFO)); memset(dbjie, 0, sizeof(DB_ENV_JAVAINFO)); dbjie->is_dbopen_ = is_dbopen; if ((*jnienv)->GetJavaVM(jnienv, &dbjie->javavm_) != 0) { free(dbjie); report_exception(jnienv, "cannot get Java VM", 0, 0); return (NULL); } /* The default error call just prints to the 'System.err' * stream. If the user does set_errcall to null, we'll * want to have a reference to set it back to. * * Why do we have always set db_errcall to our own callback? * Because it makes the interaction between setting the * error prefix, error stream, and user's error callback * that much easier. */ dbjie->default_errcall_ = NEW_GLOBAL_REF(jnienv, default_errcall); dbjie->errcall_ = NEW_GLOBAL_REF(jnienv, default_errcall); return (dbjie); }
void dbji_set_h_hash_object(DB_JAVAINFO *dbji, JNIEnv *jnienv, DB *db, jobject jhash) { jclass h_hash_class; if (dbji->h_hash_method_id_ == NULL) { h_hash_class = get_class(jnienv, name_DbHash); dbji->h_hash_method_id_ = (*jnienv)->GetMethodID(jnienv, h_hash_class, "hash", "(Lcom/sleepycat/db/Db;" "[BI)I"); if (dbji->h_hash_method_id_ == NULL) { /* XXX * We should really have a better way * to translate this to a Java exception class. * In theory, it shouldn't happen. */ report_exception(jnienv, "Cannot find callback method", EFAULT, 0); return; } } if (dbji->h_hash_ != NULL) DELETE_GLOBAL_REF(jnienv, dbji->h_hash_); if (jhash == NULL) db->set_h_hash(db, NULL); else db->set_h_hash(db, Db_h_hash_callback); dbji->h_hash_ = NEW_GLOBAL_REF(jnienv, jhash); }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { // Fetching the high res timer's global scale factor ensures that it // is calibrated (if necessary on this platform) at the beginning of // the test. While the timer would otherwise be calibrated on first // use, this introduces delay in the middle of the test's execution. // This leads to failures due to timing assumptions (timeouts, etc.) // within the test itself. (void) ACE_High_Res_Timer::global_scale_factor(); try { CORBA::ORB_var orb = initialize_orb_and_poa(argc, argv); parse_args(argc, argv); test_i servant (orb.in()); CORBA::String_var ior = servant.create_and_activate_server(); write_ior_to_file(ior.in()); orb->run(); } catch(...) { report_exception(); return 1; } return 0; }
int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { ACE_DEBUG ((LM_DEBUG, "Starting client\n")); CORBA::ORB_var orb = initialize_orb_and_poa(argc, argv); parse_args(argc, argv); ACE_DEBUG ((LM_DEBUG, "Testing remote\n")); test_remote_calls(orb.in()); ACE_DEBUG ((LM_DEBUG, "Testing colocated\n")); test_colocated_calls(orb.in()); ACE_DEBUG ((LM_DEBUG, "Testing ready\n")); } catch(...) { report_exception(); return 1; } return 0; }
void dbji_set_dup_compare_object(DB_JAVAINFO *dbji, JNIEnv *jnienv, DB *db, jobject jcompare) { jclass dup_compare_class; if (dbji->dup_compare_method_id_ == NULL) { dup_compare_class = get_class(jnienv, name_DbDupCompare); dbji->dup_compare_method_id_ = (*jnienv)->GetMethodID(jnienv, dup_compare_class, "dup_compare", "(Lcom/sleepycat/db/Db;" "Lcom/sleepycat/db/Dbt;" "Lcom/sleepycat/db/Dbt;)I"); if (dbji->dup_compare_method_id_ == NULL) { /* XXX * We should really have a better way * to translate this to a Java exception class. * In theory, it shouldn't happen. */ report_exception(jnienv, "Cannot find callback method", EFAULT, 0); return; } } if (dbji->dup_compare_ != NULL) DELETE_GLOBAL_REF(jnienv, dbji->dup_compare_); if (jcompare == NULL) db->set_dup_compare(db, NULL); else db->set_dup_compare(db, Db_dup_compare_callback); dbji->dup_compare_ = NEW_GLOBAL_REF(jnienv, jcompare); }
/* If the object is null, report an exception and return false (0), * otherwise return true (1). */ int verify_non_null(JNIEnv *jnienv, void *obj) { if (obj == NULL) { report_exception(jnienv, "null object", EINVAL, 0); return (0); } return (1); }
/* If the error code is non-zero, report an exception and return false (0), * otherwise return true (1). */ int verify_return(JNIEnv *jnienv, int err, unsigned long expect_mask) { if (err == 0) return 1; report_exception(jnienv, db_strerror(err), err, expect_mask); return 0; }
int WINAPI WinMain (HINSTANCE hInstance ,HINSTANCE hPrevInstance ,LPSTR lpCmdLine ,int nCmdShow ) #endif // LMI_MSW defined. { // (Historical notes.) Using wx-2.5.1 and mpatrol-1.4.8, both // dynamically linked to this application built with gcc-3.2.3, // three memory leaks are reported with: // MPATROL_OPTIONS='SHOWUNFREED' // It's easier to trace them with: // MPATROL_OPTIONS='LOGALL SHOWUNFREED USEDEBUG' // Two are apparently mpatrol artifacts traceable to symbols: // [space follows leading underscores in reserved names] // "_ _ _ mp_findsource" // "_ _ _ mp_init" // The third is traceable in 'mpatrol.log' with 'USEDEBUG' to // Skeleton::GetEventHashTable() const // (although stepping through the code in gdb suggests it's really // WinMain(), and mpatrol or libbfd just got the symbol wrong) // and seems to be triggered the first time the program allocates // memory. The next line forces that to occur here; otherwise, // tracing this 'leak' becomes cumbersome and mysterious. std::string unused("Seems to trigger initialization of something."); int result = EXIT_FAILURE; try { initialize_application(); initialize_filesystem(); #ifndef LMI_MSW result = wxEntry(argc, argv); #else // LMI_MSW defined. result = wxEntry(hInstance, hPrevInstance, lpCmdLine, nCmdShow); #endif // LMI_MSW defined. } catch(...) { try { report_exception(); } catch(...) { safely_show_message("Logic error: untrapped exception."); } } fenv_validate(); return result; }
void dbjie_set_tx_recover_object(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv, DB_ENV *dbenv, jobject jtx_recover) { int err; if (dbjie->tx_recover_ != NULL) { DELETE_GLOBAL_REF(jnienv, dbjie->tx_recover_); } if (jtx_recover == NULL) { if ((err = dbenv->set_tx_recover(dbenv, NULL)) != 0) report_exception(jnienv, "set_tx_recover failed", err, 0); } else { if ((err = dbenv->set_tx_recover(dbenv, DbEnv_tx_recover_callback)) != 0) report_exception(jnienv, "set_tx_recover failed", err, 0); } dbjie->tx_recover_ = NEW_GLOBAL_REF(jnienv, jtx_recover); }
void dbjie_set_feedback_object(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv, DB_ENV *dbenv, jobject jfeedback) { int err; if (dbjie->feedback_ != NULL) { DELETE_GLOBAL_REF(jnienv, dbjie->feedback_); } if (jfeedback == NULL) { if ((err = dbenv->set_feedback(dbenv, NULL)) != 0) report_exception(jnienv, "set_feedback failed", err, 0); } else { if ((err = dbenv->set_feedback(dbenv, DbEnv_feedback_callback)) != 0) report_exception(jnienv, "set_feedback failed", err, 0); } dbjie->feedback_ = NEW_GLOBAL_REF(jnienv, jfeedback); }
Authenticity& Authenticity::Instance() { try { static Authenticity z; return z; } catch(...) { report_exception(); fatal_error() << "Instantiation failed." << LMI_FLUSH; throw "Unreachable--silences a compiler diagnostic."; } }
MswDllPreloader& MswDllPreloader::instance() { try { static MswDllPreloader z; return z; } catch(...) { report_exception(); fatal_error() << "Instantiation failed." << LMI_FLUSH; throw "Unreachable--silences a compiler diagnostic."; } }
configurable_settings& configurable_settings::instance() { try { static configurable_settings z; return z; } catch(...) { report_exception(); fatal_error() << "Instantiation failed." << LMI_FLUSH; throw "Unreachable--silences a compiler diagnostic."; } }
void dbjie_set_recovery_init_object(DB_ENV_JAVAINFO *dbjie, JNIEnv *jnienv, DB_ENV *dbenv, jobject jrecovery_init) { int err; if (dbjie->recovery_init_ != NULL) { DELETE_GLOBAL_REF(jnienv, dbjie->recovery_init_); } if (jrecovery_init == NULL) { if ((err = dbenv->set_recovery_init(dbenv, NULL)) != 0) report_exception(jnienv, "set_recovery_init failed", err, 0); } else { if ((err = dbenv->set_recovery_init(dbenv, DbEnv_recovery_init_callback)) != 0) report_exception(jnienv, "set_recovery_init failed", err, 0); } dbjie->recovery_init_ = NEW_GLOBAL_REF(jnienv, jrecovery_init); }
int test_main(int, char*[]) { try { throw std::runtime_error(" This message should appear on stderr."); } catch(...) { report_exception(); BOOST_TEST(true); } // Test the // catch(...) { try{report_exception();} catch(...){/*warning*/} } // technique to trap every exception--even stealth_exception or an // exception derived from it. try { std::cout << "Expect a success message..." << std::endl; throw sneaky_exception("ERROR"); } catch(...) { try { report_exception(); // Should rethrow. BOOST_TEST(false); } catch(...) { std::cout << "...Success: caught elusive exception." << std::endl; BOOST_TEST(true); } } return 0; }
DB_JAVAINFO *dbji_construct(JNIEnv *jnienv, jint flags) { DB_JAVAINFO *dbji; dbji = (DB_JAVAINFO *)malloc(sizeof(DB_JAVAINFO)); memset(dbji, 0, sizeof(DB_JAVAINFO)); if ((*jnienv)->GetJavaVM(jnienv, &dbji->javavm_) != 0) { report_exception(jnienv, "cannot get Java VM", 0, 0); free(dbji); return (NULL); } dbji->construct_flags_ = flags; return (dbji); }
int database_entity::getndata() const { try { return getndata(axis_lengths_); } catch(...) { report_exception(); fatal_error() << "Database item '" << GetDBNames()[key_].ShortName << "' has invalid dimensions." << LMI_FLUSH ; } throw "Unreachable--silences a compiler diagnostic."; }
int try_main(int argc, char* argv[]) { bool error_flag = false; statistics z; for(int j = 1; j < argc; ++j) { try { z += process_file(argv[j]); } catch(...) { error_flag = true; std::cerr << "Exception--file '" << argv[j] << "': " << std::flush; report_exception(); } } z.print_summary(); return error_flag ? EXIT_FAILURE : EXIT_SUCCESS; }
configurable_settings::configurable_settings() :calculation_summary_columns_ (default_calculation_summary_columns()) ,cgi_bin_log_filename_ ("cgi_bin.log" ) ,custom_input_0_filename_ ("custom.ini" ) ,custom_input_1_filename_ ("custom.inix" ) ,custom_output_0_filename_ ("custom.out0" ) ,custom_output_1_filename_ ("custom.out1" ) ,default_input_filename_ ("/etc/opt/lmi/default.ill" ) ,libraries_to_preload_ ("" ) ,offer_hobsons_choice_ (false ) ,print_directory_ ("/var/opt/lmi/spool" ) ,seconds_to_pause_between_printouts_ (10 ) ,skin_filename_ ("skin.xrc" ) ,spreadsheet_file_extension_ (".gnumeric" ) ,use_builtin_calculation_summary_ (false ) ,xsl_fo_command_ ("fo" ) { ascribe_members(); load(); default_input_filename_ = fs::system_complete(default_input_filename_).string(); print_directory_ = fs::system_complete(print_directory_ ).string(); try { validate_directory(print_directory_, "Print directory"); } catch(...) { report_exception(); print_directory_ = fs::system_complete(".").string(); warning() << "If possible, current directory '" << print_directory_ << "' will be used for print files instead." << LMI_FLUSH ; validate_directory(print_directory_, "Fallback print directory"); save(); } }
void dbji_set_bt_prefix_object(DB_JAVAINFO *dbji, JNIEnv *jnienv, DB *db, jobject jprefix) { jclass bt_prefix_class; if (dbji->bt_prefix_method_id_ == NULL) { bt_prefix_class = get_class(jnienv, name_DbBtreePrefix); dbji->bt_prefix_method_id_ = (*jnienv)->GetMethodID(jnienv, bt_prefix_class, "bt_prefix", "(Lcom/sleepycat/db/Db;" "Lcom/sleepycat/db/Dbt;" "Lcom/sleepycat/db/Dbt;)I"); if (dbji->bt_prefix_method_id_ == NULL) { /* XXX * We should really have a better way * to translate this to a Java exception class. * In theory, it shouldn't happen. */ report_exception(jnienv, "Cannot find callback method", EFAULT, 0); return; } } if (dbji->bt_prefix_ != NULL) { DELETE_GLOBAL_REF(jnienv, dbji->bt_prefix_); } if (jprefix == NULL) { db->set_bt_prefix(db, NULL); } else { db->set_bt_prefix(db, Db_bt_prefix_callback); } dbji->bt_prefix_ = NEW_GLOBAL_REF(jnienv, jprefix); }
void dbji_set_feedback_object(DB_JAVAINFO *dbji, JNIEnv *jnienv, DB *db, jobject jfeedback) { jclass feedback_class; if (dbji->feedback_method_id_ == NULL) { feedback_class = get_class(jnienv, name_DbFeedback); dbji->feedback_method_id_ = (*jnienv)->GetMethodID(jnienv, feedback_class, "feedback", "(Lcom/sleepycat/db/Db;II)V"); if (dbji->feedback_method_id_ != NULL) { /* XXX * We should really have a better way * to translate this to a Java exception class. * In theory, it shouldn't happen. */ report_exception(jnienv, "Cannot find callback method", EFAULT, 0); return; } } if (dbji->feedback_ != NULL) { DELETE_GLOBAL_REF(jnienv, dbji->feedback_); } if (jfeedback == NULL) { db->set_feedback(db, NULL); } else { db->set_feedback(db, Db_feedback_callback); } dbji->feedback_ = NEW_GLOBAL_REF(jnienv, jfeedback); }
void dbji_set_append_recno_object(DB_JAVAINFO *dbji, JNIEnv *jnienv, DB *db, jobject jcallback) { jclass append_recno_class; if (dbji->append_recno_method_id_ == NULL) { append_recno_class = get_class(jnienv, name_DbAppendRecno); dbji->append_recno_method_id_ = (*jnienv)->GetMethodID(jnienv, append_recno_class, "db_append_recno", "(Lcom/sleepycat/db/Db;" "Lcom/sleepycat/db/Dbt;I)V"); if (dbji->append_recno_method_id_ == NULL) { /* XXX * We should really have a better way * to translate this to a Java exception class. * In theory, it shouldn't happen. */ report_exception(jnienv, "Cannot find callback method", EFAULT, 0); return; } } if (dbji->append_recno_ != NULL) { DELETE_GLOBAL_REF(jnienv, dbji->append_recno_); } if (jcallback == NULL) { db->set_append_recno(db, NULL); } else { db->set_append_recno(db, Db_append_recno_callback); } dbji->append_recno_ = NEW_GLOBAL_REF(jnienv, jcallback); }
Javascript(std::vector<std::string> include_files, const char* filename) : Base() { // v8::HandleScope handle_scope; v8::Handle<v8::String> init_source = v8::String::New("Osmium = { Callbacks: {}, Output: { } };"); v8::Handle<v8::Script> init_script = v8::Script::Compile(init_source); osmium_object = v8::Persistent<v8::Object>::New(init_script->Run()->ToObject()); v8::Handle<v8::Object> output_object = osmium_object->Get(v8::String::NewSymbol("Output"))->ToObject(); osmium_object->Set(v8::String::NewSymbol("debug"), v8::Boolean::New(Osmium::debug())); v8::Handle<v8::ObjectTemplate> output_csv_template = v8::ObjectTemplate::New(); output_csv_template->Set(v8::String::NewSymbol("open"), v8::FunctionTemplate::New(OutputCSVOpen)); output_object->Set(v8::String::NewSymbol("CSV"), output_csv_template->NewInstance()); #ifdef OSMIUM_WITH_SHPLIB v8::Handle<v8::ObjectTemplate> output_shapefile_template = v8::ObjectTemplate::New(); output_shapefile_template->Set(v8::String::NewSymbol("open"), v8::FunctionTemplate::New(OutputShapefileOpen)); output_object->Set(v8::String::NewSymbol("Shapefile"), output_shapefile_template->NewInstance()); #endif // OSMIUM_WITH_SHPLIB v8::Handle<v8::Object> callbacks_object = osmium_object->Get(v8::String::NewSymbol("Callbacks"))->ToObject(); v8::TryCatch tryCatch; for (std::vector<std::string>::const_iterator vi(include_files.begin()); vi != include_files.end(); vi++) { if (Osmium::debug()) { std::cerr << "include javascript file: " << *vi << std::endl; } std::string javascript_source = load_file((*vi).c_str()); v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(javascript_source.c_str()), v8::String::New((*vi).c_str())); if (script.IsEmpty()) { std::cerr << "Compiling script failed:" << std::endl; report_exception(&tryCatch); exit(1); } v8::Handle<v8::Value> result = script->Run(); if (result.IsEmpty()) { std::cerr << "Running script failed:" << std::endl; report_exception(&tryCatch); exit(1); } } std::string javascript_source = load_file(filename); if (javascript_source.length() == 0) { std::cerr << "Javascript file " << filename << " is empty" << std::endl; exit(1); } v8::Handle<v8::Script> script = v8::Script::Compile(v8::String::New(javascript_source.c_str()), v8::String::New(filename)); if (script.IsEmpty()) { std::cerr << "Compiling script failed:" << std::endl; report_exception(&tryCatch); exit(1); } v8::Handle<v8::Value> result = script->Run(); if (result.IsEmpty()) { std::cerr << "Running script failed:" << std::endl; report_exception(&tryCatch); exit(1); } v8::Handle<v8::Value> cc; cc = callbacks_object->Get(v8::String::NewSymbol("init")); if (cc->IsFunction()) { cb.init = v8::Handle<v8::Function>::Cast(cc); } cc = callbacks_object->Get(v8::String::NewSymbol("node")); if (cc->IsFunction()) { cb.node = v8::Handle<v8::Function>::Cast(cc); } cc = callbacks_object->Get(v8::String::NewSymbol("way")); if (cc->IsFunction()) { cb.way = v8::Handle<v8::Function>::Cast(cc); } cc = callbacks_object->Get(v8::String::NewSymbol("relation")); if (cc->IsFunction()) { cb.relation = v8::Handle<v8::Function>::Cast(cc); } cc = callbacks_object->Get(v8::String::NewSymbol("area")); if (cc->IsFunction()) { cb.area = v8::Handle<v8::Function>::Cast(cc); } cc = callbacks_object->Get(v8::String::NewSymbol("end")); if (cc->IsFunction()) { cb.end = v8::Handle<v8::Function>::Cast(cc); } }
int try_main(int argc, char* argv[]) { int c; int option_index = 0; // Long options are meta-options not directly supported by the borland // librarian. TRICKY !! They are aliased to unlikely octal values. static Option long_options[] = { {"help", NO_ARG, 0, 001, 0, "display this help and exit"}, {"license", NO_ARG, 0, 002, 0, "display license and exit"}, {"accept", NO_ARG, 0, 003, 0, "accept license (-l to display)"}, {"program", REQD_ARG, 0, 004, 0, "librarian's filepath"}, {"r", REQD_ARG, 0, 'r', 0, "see inline documentation"}, {"s", REQD_ARG, 0, 's', 0, "see inline documentation"}, {"u", REQD_ARG, 0, 'u', 0, "see inline documentation"}, {"v", REQD_ARG, 0, 'v', 0, "see inline documentation"}, {0, NO_ARG, 0, 0, 0, ""} }; bool license_accepted = false; bool show_license = false; bool show_help = false; std::string program; std::string library_filename; std::string ar_options; GetOpt getopt_long (argc ,argv ,"" ,long_options ,&option_index ,true ); getopt_long.opterr = false; while(EOF != (c = getopt_long())) { switch(c) { case 001: { show_help = true; } break; case 002: { show_license = true; } break; case 003: { license_accepted = true; } break; case 004: { program = getopt_long.optarg; } break; case 'r': case 's': case 'u': case 'v': { // Do nothing. } break; case '?': { // Forward any unrecognized options to the tool. int offset = getopt_long.optind - 1; if(0 < offset) { std::string s = getopt_long.nargv[offset]; std::cerr << "Unknown option'" << s << "'.\n"; } else { std::cerr << "Internal error\n"; } } break; default: std::cerr << "getopt returned character code 0" << c << '\n'; } } if((c = getopt_long.optind) < argc) { library_filename = std::string(argv[c++]); while(c < argc) { // Forward any unrecognized arguments to the tool. ar_options += " +" + std::string(argv[c++]); } } if(!license_accepted) { std::cerr << license_notices_as_text() << "\n\n"; } if(show_license) { std::cerr << license_as_text() << "\n\n"; return EXIT_SUCCESS; } if(show_help) { std::cout << "This program's emulation of gnu 'ar' is very limited.\n" << "Read the inline documentation in file '" __FILE__ "'.\n" ; getopt_long.usage(); return EXIT_SUCCESS; } if("" == program) { std::cerr << "Must specify --program=(librarian name)\n"; return EXIT_FAILURE; } std::remove(library_filename.c_str()); // The borland librarian allows up to 2^16 'pages', each of a // size specified on the command line. The version supplied with // their 5.02 compiler fails if the specified page size is not // sufficient. The version supplied with their 5.5.1 compiler // seems to adjust the page size automatically. It might be nice // to perform such an automatic adjustment here for the older // version, but we aren't very interested in breathing new life // into old tools that were badly designed in the first place. std::string command_line = program + " " + "/P1024" + " " + library_filename + " " + ar_options ; try { system_command(command_line); } catch(...) { report_exception(); std::cerr << "Command failed." << "\ncommand line: " << command_line << '\n' << "\nprogram: " << program << "\nlibrary: " << library_filename << "\noptions: " << ar_options << '\n' ; } return 0; }
extern int dbji_call_append_recno(DB_JAVAINFO *dbji, DB *db, jobject jdb, DBT *dbt, jint recno) { JNIEnv *jnienv; jobject jdbt; DBT_JAVAINFO *dbtji; jbyteArray arr; unsigned int arraylen; unsigned char *data; COMPQUIET(db, NULL); jnienv = dbji_get_jnienv(dbji); if (jnienv == NULL) { fprintf(stderr, "Cannot attach to current thread!\n"); return (0); } /* XXX * We should have a pool of Dbt objects used for this purpose * instead of creating new ones each time. Because of * multithreading, we may need an arbitrary number (more than two). * We might also have a byte arrays that grow as needed, * so we don't need to allocate those either. * * Note, we do not set the 'create_array_' flag as on other * callbacks as we are creating the array here. */ jdbt = create_default_object(jnienv, name_DBT); dbtji = get_DBT_JAVAINFO(jnienv, jdbt); memcpy(&dbtji->dbt, dbt, sizeof(DBT)); dbtji->dbt.data = NULL; arr = (*jnienv)->NewByteArray(jnienv, dbt->size); (*jnienv)->SetByteArrayRegion(jnienv, arr, 0, dbt->size, (jbyte *)dbt->data); dbtji->array_ = (jbyteArray)NEW_GLOBAL_REF(jnienv, arr); DB_ASSERT(dbji->append_recno_method_id_ != NULL); (*jnienv)->CallVoidMethod(jnienv, dbji->append_recno_, dbji->append_recno_method_id_, jdb, jdbt, recno); /* The underlying C API requires that an errno be returned * on error. Java users know nothing of errnos, so we * allow them to throw exceptions instead. We leave the * exception in place and return DB_JAVA_CALLBACK to the C API * that called us. Eventually the DB->get will fail and * when java prepares to throw an exception in * report_exception(), this will be spotted as a special case, * and the original exception will be preserved. * * Note: we have sometimes noticed strange behavior with * exceptions under Linux 1.1.7 JVM. (i.e. multiple calls * to ExceptionOccurred() may report different results). * Currently we don't know of any problems related to this * in our code, but if it pops up in the future, users are * encouranged to get a more recent JVM. */ if ((*jnienv)->ExceptionOccurred(jnienv) != NULL) return (DB_JAVA_CALLBACK); if (dbtji->array_ == NULL) { report_exception(jnienv, "Dbt.data is null", 0, 0); return (EFAULT); } arraylen = (*jnienv)->GetArrayLength(jnienv, dbtji->array_); if (dbtji->offset_ < 0 ) { report_exception(jnienv, "Dbt.offset illegal", 0, 0); return (EFAULT); } if (dbt->ulen + dbtji->offset_ > arraylen) { report_exception(jnienv, "Dbt.ulen + Dbt.offset greater than array length", 0, 0); return (EFAULT); } data = (*jnienv)->GetByteArrayElements(jnienv, dbtji->array_, (jboolean *)0); dbt->data = data + dbtji->offset_; return (0); }
/**************************************************************** * * Implementation of functions to manipulate LOCKED_DBT. */ int locked_dbt_get(LOCKED_DBT *ldbt, JNIEnv *jnienv, DB_ENV *dbenv, jobject jdbt, OpKind kind) { DBT *dbt; COMPQUIET(dbenv, NULL); ldbt->jdbt = jdbt; ldbt->java_array_len = 0; ldbt->flags = 0; ldbt->kind = kind; ldbt->java_data = 0; ldbt->before_data = 0; ldbt->javainfo = (DBT_JAVAINFO *)get_private_dbobj(jnienv, name_DBT, jdbt); if (!verify_non_null(jnienv, ldbt->javainfo)) { report_exception(jnienv, "Dbt is gc'ed?", 0, 0); F_SET(ldbt, LOCKED_ERROR); return (EINVAL); } if (F_ISSET(ldbt->javainfo, DBT_JAVAINFO_LOCKED)) { report_exception(jnienv, "Dbt is already in use", 0, 0); F_SET(ldbt, LOCKED_ERROR); return (EINVAL); } dbt = &ldbt->javainfo->dbt; if ((*jnienv)->GetBooleanField(jnienv, jdbt, fid_Dbt_must_create_data) != 0) F_SET(ldbt, LOCKED_CREATE_DATA); else ldbt->javainfo->array = (*jnienv)->GetObjectField(jnienv, jdbt, fid_Dbt_data); dbt->size = (*jnienv)->GetIntField(jnienv, jdbt, fid_Dbt_size); dbt->ulen = (*jnienv)->GetIntField(jnienv, jdbt, fid_Dbt_ulen); dbt->dlen = (*jnienv)->GetIntField(jnienv, jdbt, fid_Dbt_dlen); dbt->doff = (*jnienv)->GetIntField(jnienv, jdbt, fid_Dbt_doff); dbt->flags = (*jnienv)->GetIntField(jnienv, jdbt, fid_Dbt_flags); ldbt->javainfo->offset = (*jnienv)->GetIntField(jnienv, jdbt, fid_Dbt_offset); /* * If no flags are set, use default behavior of DB_DBT_MALLOC. * We can safely set dbt->flags because flags will never be copied * back to the Java Dbt. */ if (kind != inOp && !F_ISSET(dbt, DB_DBT_USERMEM | DB_DBT_MALLOC | DB_DBT_REALLOC)) F_SET(dbt, DB_DBT_MALLOC); /* * If this is requested to be realloc with an existing array, * we cannot use the underlying realloc, because the array we * will pass in is allocated by the Java VM, not us, so it * cannot be realloced. We simulate the reallocation by using * USERMEM and reallocating the java array when a ENOMEM error * occurs. We change the flags during the operation, and they * are reset when the operation completes (in locked_dbt_put). */ if (F_ISSET(dbt, DB_DBT_REALLOC) && ldbt->javainfo->array != NULL) { F_CLR(dbt, DB_DBT_REALLOC); F_SET(dbt, DB_DBT_USERMEM); F_SET(ldbt, LOCKED_REALLOC_NONNULL); } if ((F_ISSET(dbt, DB_DBT_USERMEM) || kind != outOp) && !F_ISSET(ldbt, LOCKED_CREATE_DATA)) { /* * If writing with DB_DBT_USERMEM * or it's a set (or get/set) operation, * then the data should point to a java array. * Note that outOp means data is coming out of the database * (it's a get). inOp means data is going into the database * (either a put, or a key input). */ if (!ldbt->javainfo->array) { report_exception(jnienv, "Dbt.data is null", 0, 0); F_SET(ldbt, LOCKED_ERROR); return (EINVAL); } /* Verify other parameters */ ldbt->java_array_len = (*jnienv)->GetArrayLength(jnienv, ldbt->javainfo->array); if (ldbt->javainfo->offset < 0 ) { report_exception(jnienv, "Dbt.offset illegal", 0, 0); F_SET(ldbt, LOCKED_ERROR); return (EINVAL); } if (dbt->size + ldbt->javainfo->offset > ldbt->java_array_len) { report_exception(jnienv, "Dbt.size + Dbt.offset greater than array length", 0, 0); F_SET(ldbt, LOCKED_ERROR); return (EINVAL); } ldbt->java_data = (*jnienv)->GetByteArrayElements(jnienv, ldbt->javainfo->array, (jboolean *)0); dbt->data = ldbt->before_data = ldbt->java_data + ldbt->javainfo->offset; } else if (!F_ISSET(ldbt, LOCKED_CREATE_DATA)) { /* * If writing with DB_DBT_MALLOC or DB_DBT_REALLOC with * a null array, then the data is allocated by DB. */ dbt->data = ldbt->before_data = 0; } /* * RPC makes the assumption that if dbt->size is non-zero, there * is data to copy from dbt->data. We may have set dbt->size * to a non-zero integer above but decided not to point * dbt->data at anything. (One example is if we're doing an outOp * with an already-used Dbt whose values we expect to just * overwrite.) * * Clean up the dbt fields so we don't run into trouble. * (Note that doff, dlen, and flags all may contain meaningful * values.) */ if (dbt->data == NULL) dbt->size = dbt->ulen = 0; F_SET(ldbt->javainfo, DBT_JAVAINFO_LOCKED); return (0); }
std::string Authenticity::Assay (calendar_date const& candidate ,fs::path const& data_path ) { // The cached date is valid unless it's the peremptorily-invalid // default value of JDN zero. if ( calendar_date(jdn_t(0)) != Instance().CachedDate_ && candidate == Instance().CachedDate_ ) { return "cached"; } ResetCache(); std::ostringstream oss; // Read the passkey and valid-date-range files each time // because they might change while the program is running. // They'll be validated against validated md5sums a fraction // of a second later, to guard against fraudulent manipulation. // Read saved passkey from file. std::string passkey; { fs::path passkey_path(data_path / "passkey"); fs::ifstream is(passkey_path); if(!is) { oss << "Unable to read passkey file '" << passkey_path << "'. Try reinstalling." ; return oss.str(); } is >> passkey; if(!is.eof()) { oss << "Error reading passkey file '" << passkey_path << "'. Try reinstalling." ; return oss.str(); } if(passkey.size() != chars_per_formatted_hex_byte * md5len) { oss << "Length of passkey '" << passkey << "' is " << passkey.size() << " but should be " << chars_per_formatted_hex_byte * md5len << ". Try reinstalling." ; return oss.str(); } } // Read valid date range [begin, end) from file. calendar_date begin(last_yyyy_date ()); calendar_date end (gregorian_epoch()); { fs::path expiry_path(data_path / "expiry"); fs::ifstream is(expiry_path); if(!is) { oss << "Unable to read expiry file '" << expiry_path << "'. Try reinstalling." ; return oss.str(); } is >> begin >> end; if(!is || !is.eof()) { oss << "Error reading expiry file '" << expiry_path << "'. Try reinstalling." ; return oss.str(); } } // Make sure candidate date is within valid range. if(candidate < begin) { oss << "Current date " << candidate.str() << " is invalid: this system cannot be used before " << begin.str() << ". Contact the home office." ; return oss.str(); } if(end <= candidate) { oss << "Current date " << candidate.str() << " is invalid: this system cannot be used after " << (-1 + end).str() << ". Contact the home office." ; return oss.str(); } // Validate all data files. fs::path original_path(fs::current_path()); if(0 != chdir(data_path.string().c_str())) { oss << "Unable to change directory to '" << data_path << "'. Try reinstalling." ; return oss.str(); } try { system_command("md5sum --check --status " + std::string(md5sum_file())); } catch(...) { report_exception(); oss << "At least one required file is missing, altered, or invalid." << " Try reinstalling." ; return oss.str(); } if(0 != chdir(original_path.string().c_str())) { oss << "Unable to restore directory to '" << original_path << "'. Try reinstalling." ; return oss.str(); } // The passkey must match the md5 sum of the md5 sum of the file // of md5 sums of secured files. char c_passkey[md5len]; unsigned char u_passkey[md5len]; std::FILE* md5sums_file = std::fopen ((data_path / md5sum_file()).string().c_str() ,"rb" ); md5_stream(md5sums_file, u_passkey); std::fclose(md5sums_file); std::memcpy(c_passkey, u_passkey, md5len); md5_buffer(c_passkey, md5len, u_passkey); std::memcpy(c_passkey, u_passkey, md5len); md5_buffer(c_passkey, md5len, u_passkey); std::string expected = md5_hex_string (std::vector<unsigned char>(u_passkey, u_passkey + md5len) ); if(passkey != expected) { oss << "Passkey is incorrect for this version." << " Contact the home office." ; return oss.str(); } // Cache the validated date. Instance().CachedDate_ = candidate; return "validated"; }