int main() { /* TODO: using abs paths just to test this shit. */ // Set path where managed assemblies live. mono_set_assemblies_path("C:\\Users\\Niko\\Source\\Repos\\SaNi\\vs2013\\sanimono\\SaNi\\bin\\Debug"); // Set Mono library and configuration paths. mono_set_dirs("C:\\Program Files (x86)\\Mono\\lib", "C:\\Program Files (x86)\\Mono\\etc"); // Our application assembly that contains // the code we are going to run. domain = mono_jit_init_version("SaNi", "v4.0.30319"); // Our domain in which the code will be // executed. MonoAssembly* assembly = mono_domain_assembly_open(domain, "C:\\Users\\Niko\\Source\\Repos\\SaNi\\vs2013\\sanimono\\SaNi\\bin\\Debug\\SaNi.exe"); if (!assembly) throw std::runtime_error("could not load the given Mono assembly"); mono_add_internal_call("SaNi.Utils::Print(string)", (void*)print); mono_add_internal_call("SaNi.Utils::GetString()", (void*)getString); const auto argc = 6; char* argv[argc] = { "HELLO", "WORLD", "FROM", "THE", "F*****G", "MONO" }; mono_jit_exec(domain, assembly, argc, argv); // Clean mono. mono_jit_cleanup(domain); return 0; }
void main(int argc, char* argv[]) { mono_set_dirs("lib", ""); mono_config_parse(NULL); MonoDomain* domain = mono_jit_init("managed.exe"); if(!domain) { printf("Unable to initialize mono jit.\n"); return; } MonoAssembly* assembly = mono_domain_assembly_open(domain, "managed.exe"); if (!assembly) { printf("Unable to open assembly.\n"); return; } char* argvv[1] = { "managed" }; mono_jit_exec(domain, assembly, 1, argvv); mono_jit_cleanup(domain); return; }
int app_mono_run(struct sip_msg *msg, char *arg) { int ret; char *argv[2]; int argc; sr_mono_load_t *mi; if(_sr_mono_load_list == NULL) return -1; mi = _sr_mono_load_list; LM_DBG("running Mono assembly: [[%s]]\n", mi->script); _sr_M_env.msg = msg; _sr_M_env.domain = mi->domain; _sr_M_env.assembly = mi->assembly; if (_sr_M_env.assembly==NULL) { LM_DBG("empty assembly\n"); memset(&_sr_M_env, 0, sizeof(sr_mono_env_t)); return -1; } mono_domain_set(_sr_M_env.domain, 0); argc = 1; argv[0] = mi->script; if(arg!=NULL) { argc++; argv[1] = arg; } mono_jit_exec(_sr_M_env.domain, _sr_M_env.assembly, argc, argv); ret = mono_environment_exitcode_get(); LM_DBG("returned code from mono environment: %d\n", ret); memset(&_sr_M_env, 0, sizeof(sr_mono_env_t)); return (ret==0)?1:-1; }
Error GDMonoAssembly::load(MonoDomain *p_domain) { ERR_FAIL_COND_V(loaded, ERR_FILE_ALREADY_IN_USE); uint64_t last_modified_time = FileAccess::get_modified_time(path); Vector<uint8_t> data = FileAccess::get_file_as_array(path); ERR_FAIL_COND_V(data.empty(), ERR_FILE_CANT_READ); String image_filename(path); MonoImageOpenStatus status; image = mono_image_open_from_data_with_name( (char *)&data[0], data.size(), true, &status, false, image_filename.utf8().get_data()); ERR_FAIL_COND_V(status != MONO_IMAGE_OK || image == NULL, ERR_FILE_CANT_OPEN); #ifdef DEBUG_ENABLED String pdb_path(path + ".pdb"); if (!FileAccess::exists(pdb_path)) { pdb_path = path.get_basename() + ".pdb"; // without .dll if (!FileAccess::exists(pdb_path)) goto no_pdb; } pdb_data.clear(); pdb_data = FileAccess::get_file_as_array(pdb_path); mono_debug_open_image_from_memory(image, &pdb_data[0], pdb_data.size()); no_pdb: #endif assembly = mono_assembly_load_from_full(image, image_filename.utf8().get_data(), &status, false); ERR_FAIL_COND_V(status != MONO_IMAGE_OK || assembly == NULL, ERR_FILE_CANT_OPEN); if (p_domain && mono_image_get_entry_point(image)) { // TODO should this be removed? do we want to call main? what other effects does this have? mono_jit_exec(p_domain, assembly, 0, NULL); } loaded = true; modified_time = last_modified_time; return OK; }
static void main_function (MonoDomain *domain, const char *file, int argc, char** argv) { MonoAssembly *assembly; assembly = mono_domain_assembly_open (domain, file); if (!assembly) exit (2); /* * mono_jit_exec() will run the Main() method in the assembly. * The return value needs to be looked up from * System.Environment.ExitCode. */ mono_jit_exec (domain, assembly, argc, argv); }
int app_mono_exec(struct sip_msg *msg, char *script, char *param) { int ret; char *argv[2]; int argc; argc = 1; argv[0] = script; if(param!=NULL) { argc++; argv[1] = param; } LM_DBG("executing Mono assembly: [[%s]]\n", argv[0]); _sr_M_env.msg = msg; mono_config_parse (NULL); /* * mono_jit_init() creates a domain: each assembly is * loaded and run in a MonoDomain. */ _sr_M_env.domain = mono_jit_init (argv[0]); /* * We add our special internal functions, so that C# code * can call us back. */ sr_mono_load_class_core(); sr_mono_load_class_pv(); sr_mono_load_class_hdr(); _sr_M_env.assembly = mono_domain_assembly_open(_sr_M_env.domain, argv[0]); if (_sr_M_env.assembly==NULL) { ret = -1; goto done; } /* * mono_jit_exec() will run the Main() method in the assembly. * The return value needs to be looked up from * System.Environment.ExitCode. */ mono_jit_exec(_sr_M_env.domain, _sr_M_env.assembly, argc, argv); ret = mono_environment_exitcode_get(); LM_DBG("returned code from mono environment: %d\n", ret); done: mono_jit_cleanup(_sr_M_env.domain); memset(&_sr_M_env, 0, sizeof(sr_mono_env_t)); return (ret==0)?1:-1; }
int main(int argc, char* argv[]) { MonoDomain *domain; MonoAssembly *assembly; const char *file; int retval; if (argc < 2) { fprintf(stderr, "Please provide name of mono assembly to load.\n"); return 1; } file = argv[1]; // Load the default Mono configuration file, this is needed // if you are planning on using the dllmaps defined on the // system configuration mono_config_parse(NULL); // Create mono AppDomain domain = mono_jit_init(file); // Open entry assembly in new AppDomain assembly = mono_domain_assembly_open(domain, file); if (assembly != NULL) { // mono_jit_exec runs the Main() method in the assembly mono_jit_exec(domain, assembly, argc - 1, argv + 1); // Get exit code from entry assembly retval = mono_environment_exitcode_get(); } else { fprintf(stderr, "Failed to load mono assembly: %s\n", file); retval = 2; } // This clean up call tends to crash - since we are exiting anyway, we skip it... //mono_jit_cleanup(domain); return retval; }
void mono_convert_symbols(const char * path) { std::string converter_path_string = PathUtil::GetLibDirectory() .append("mono/4.5/pdb2mdb.exe"); char *converter_path = new char[converter_path_string.size() + 1]; converter_path[converter_path_string.size()] = 0; memcpy(converter_path, converter_path_string.c_str(), converter_path_string.size()); MonoAssembly *converter_assembly = mono_domain_assembly_open( mono_domain_get(), converter_path); assert(converter_assembly); char * argv[2]; argv[0] = (char *)converter_path; argv[1] = (char *)path; mono_jit_exec(mono_domain_get(), converter_assembly, 2, argv); }
/** * This program must be run like this: ./test MonoEmbedded.exe * (it requires one argument, even when it is not going to be used because I do not know what * parameters to use in mono_jit_exec method, it crashes with NULL value :/) */ int main (int argc, char *argv[]) { /* * Load the default Mono configuration file, this is needed * if you are planning on using the dllmaps defined on the * system configuration */ mono_config_parse (NULL); /* * mono_jit_init() creates a domain: each assembly is * loaded and run in a MonoDomain. */ MonoDomain *domain = mono_jit_init ("../MonoEmbedded/bin/Debug/MonoEmbedded.exe"); /* * Optionally, add an internal call that your startup.exe * code can call, this will bridge startup.exe to Mono */ mono_add_internal_call ("MonoEmbedded.MainClass::Print", (void *)p_Print); /* * Open the executable, and run the Main method declared * in the executable */ MonoAssembly *assembly = mono_domain_assembly_open (domain, "../MonoEmbedded/bin/Debug/MonoEmbedded.exe"); if (!assembly) { exit (2); } /* * mono_jit_exec() will run the Main() method in the assembly. * The return value needs to be looked up from * System.Environment.ExitCode. */ mono_jit_exec (domain, assembly, argc - 1, argv + 1); return 0; }
__int32 WINAPI _CorExeMain(void) { int exit_code; int argc; char **argv; MonoDomain *domain=NULL; MonoImage *image; MonoImageOpenStatus status; MonoAssembly *assembly=NULL; WCHAR filename[MAX_PATH]; char *filenameA; ICLRRuntimeInfo *info; RuntimeHost *host; HRESULT hr; int i; get_utf8_args(&argc, &argv); GetModuleFileNameW(NULL, filename, MAX_PATH); TRACE("%s", debugstr_w(filename)); for (i=0; i<argc; i++) TRACE(" %s", debugstr_a(argv[i])); TRACE("\n"); filenameA = WtoA(filename); if (!filenameA) return -1; FixupVTable(GetModuleHandleW(NULL)); hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info); if (SUCCEEDED(hr)) { hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host); if (SUCCEEDED(hr)) hr = RuntimeHost_GetDefaultDomain(host, &domain); if (SUCCEEDED(hr)) { image = mono_image_open_from_module_handle(GetModuleHandleW(NULL), filenameA, 1, &status); if (image) assembly = mono_assembly_load_from(image, filenameA, &status); if (assembly) { mono_trace_set_assembly(assembly); exit_code = mono_jit_exec(domain, assembly, argc, argv); } else { ERR("couldn't load %s, status=%d\n", debugstr_w(filename), status); exit_code = -1; } RuntimeHost_DeleteDomain(host, domain); } else exit_code = -1; ICLRRuntimeInfo_Release(info); } else exit_code = -1; HeapFree(GetProcessHeap(), 0, argv); if (domain) { mono_thread_manage(); mono_jit_cleanup(domain); } return exit_code; }