void invoke_protected_memory_method (MonoArray *data, MonoObject *scope, gboolean encrypt) { MonoClass *klass; MonoMethod *method; void *params [2]; MONO_ARCH_SAVE_REGS; if (system_security_assembly == NULL) { system_security_assembly = mono_image_loaded ("System.Security"); if (!system_security_assembly) { MonoAssembly *sa = mono_assembly_open ("System.Security.dll", NULL); if (!sa) g_assert_not_reached (); system_security_assembly = mono_assembly_get_image (sa); } } klass = mono_class_from_name (system_security_assembly, "System.Security.Cryptography", "ProtectedMemory"); method = mono_class_get_method_from_name (klass, encrypt ? "Protect" : "Unprotect", 2); params [0] = data; params [1] = scope; /* MemoryProtectionScope.SameProcess */ mono_runtime_invoke (method, NULL, params, NULL); }
static MonoReflectionAssembly * ves_icall_VInvoke_LoadAssemblyFromVirtuoso (MonoAppDomain *ad, MonoString *message) { char *asm_name; caddr_t name = NULL; caddr_t code = NULL; long len; MonoAssembly *ass; MonoDomain *domain = virtuoso_domain; MonoImage *image = NULL; #ifdef OLD_KIT_1_1_5 MonoImageOpenStatus *status; #else MonoImageOpenStatus status; #endif asm_name = mono_string_to_utf8 (message); name = box_copy (asm_name); code = mono_get_assembly_by_name (&name); if (!code) return NULL; len = box_length (code); image = mono_image_open_from_data (code, len, 0, NULL); if (!image) return NULL; #ifdef OLD_KIT_1_1_5 ass = mono_assembly_open ("", NULL, image); #else ass = mono_assembly_load_from (image, "", &status); #endif if (!ass && !status) return NULL; return mono_assembly_get_object (domain, ass); }
static int mono_attach_load_agent (MonoDomain *domain, char *agent, char *args, MonoObject **exc) { MonoError error; MonoAssembly *agent_assembly; MonoImage *image; MonoMethod *method; guint32 entry; MonoArray *main_args; gpointer pa [1]; MonoImageOpenStatus open_status; agent_assembly = mono_assembly_open (agent, &open_status); if (!agent_assembly) { fprintf (stderr, "Cannot open agent assembly '%s': %s.\n", agent, mono_image_strerror (open_status)); g_free (agent); return 2; } /* * Can't use mono_jit_exec (), as it sets things which might confuse the * real Main method. */ image = mono_assembly_get_image (agent_assembly); entry = mono_image_get_entry_point (image); if (!entry) { g_print ("Assembly '%s' doesn't have an entry point.\n", mono_image_get_filename (image)); g_free (agent); return 1; } method = mono_get_method_checked (image, entry, NULL, NULL, &error); if (method == NULL){ g_print ("The entry point method of assembly '%s' could not be loaded due to %s\n", agent, mono_error_get_message (&error)); mono_error_cleanup (&error); g_free (agent); return 1; } if (args) { main_args = (MonoArray*)mono_array_new (domain, mono_defaults.string_class, 1); mono_array_set (main_args, MonoString*, 0, mono_string_new (domain, args)); } else {
/* Entry point called by LdrLoadDll of ntdll.dll after _CorValidateImage. */ BOOL STDMETHODCALLTYPE _CorDllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved) { MonoAssembly* assembly; MonoImage* image; gchar* file_name; gchar* error; switch (dwReason) { case DLL_PROCESS_ATTACH: DisableThreadLibraryCalls (hInst); file_name = mono_get_module_file_name (hInst); if (mono_get_root_domain ()) { image = mono_image_open_from_module_handle (hInst, mono_path_resolve_symlinks (file_name), TRUE, NULL); } else { init_from_coree = TRUE; mono_runtime_load (file_name, NULL); error = (gchar*) mono_check_corlib_version (); if (error) { g_free (error); g_free (file_name); mono_runtime_quit (); return FALSE; } image = mono_image_open (file_name, NULL); if (image) { image->has_entry_point = TRUE; mono_close_exe_image (); /* Decrement reference count to zero. (Image will not be closed.) */ mono_image_close (image); } } if (!image) { g_free (file_name); return FALSE; } /* * FIXME: Find a better way to call mono_image_fixup_vtable. Only * loader trampolines should be used and assembly loading should * probably be delayed until the first call to an exported function. */ if (image->tables [MONO_TABLE_ASSEMBLY].rows && ((MonoCLIImageInfo*) image->image_info)->cli_cli_header.ch_vtable_fixups.rva) assembly = mono_assembly_open (file_name, NULL); g_free (file_name); break; case DLL_PROCESS_DETACH: if (lpReserved != NULL) /* The process is terminating. */ return TRUE; file_name = mono_get_module_file_name (hInst); image = mono_image_loaded (file_name); if (image) mono_image_close (image); g_free (file_name); break; } return TRUE; }
/* Called by ntdll.dll reagardless of entry point after _CorValidateImage. */ __int32 STDMETHODCALLTYPE _CorExeMain(void) { MonoDomain* domain; MonoAssembly* assembly; MonoImage* image; MonoMethod* method; guint32 entry; gchar* file_name; gchar* error; int argc; gunichar2** argvw; gchar** argv; int i; file_name = mono_get_module_file_name (NULL); init_from_coree = TRUE; domain = mono_runtime_load (file_name, NULL); error = (gchar*) mono_check_corlib_version (); if (error) { g_free (error); g_free (file_name); MessageBox (NULL, L"Corlib not in sync with this runtime.", NULL, MB_ICONERROR); mono_runtime_quit (); ExitProcess (1); } assembly = mono_assembly_open (file_name, NULL); mono_close_exe_image (); if (!assembly) { g_free (file_name); MessageBox (NULL, L"Cannot open assembly.", NULL, MB_ICONERROR); mono_runtime_quit (); ExitProcess (1); } image = assembly->image; entry = mono_image_get_entry_point (image); if (!entry) { g_free (file_name); MessageBox (NULL, L"Assembly doesn't have an entry point.", NULL, MB_ICONERROR); mono_runtime_quit (); ExitProcess (1); } method = mono_get_method (image, entry, NULL); if (method == NULL) { g_free (file_name); MessageBox (NULL, L"The entry point method could not be loaded.", NULL, MB_ICONERROR); mono_runtime_quit (); ExitProcess (1); } argvw = CommandLineToArgvW (GetCommandLine (), &argc); argv = g_new0 (gchar*, argc); argv [0] = file_name; for (i = 1; i < argc; ++i) argv [i] = g_utf16_to_utf8 (argvw [i], -1, NULL, NULL, NULL); LocalFree (argvw); mono_runtime_run_main (method, argc, argv, NULL); mono_thread_manage (); mono_runtime_quit (); /* return does not terminate the process. */ ExitProcess (mono_environment_exitcode_get ()); }
int main (int argc, char *argv[]) { MonoAssembly *assembly = NULL; const char *aname = NULL; const char *outfile = NULL; const char *rootfile = NULL; int i; gboolean all_meta = FALSE; mono_init (argv [0]); type_table = g_hash_table_new (NULL, NULL); method_table = g_hash_table_new (NULL, NULL); field_table = g_hash_table_new (NULL, NULL); image_table = g_hash_table_new (NULL, NULL); for (i = 1; i < argc; ++i) { all_meta = FALSE; aname = argv [i]; if (strcmp (aname, "-v") == 0) { verbose++; continue; } else if (strcmp (aname, "-e") == 0) { force_enums = 1; continue; } else if (strcmp (aname, "-h") == 0) { usage (0); } else if (strcmp (aname, "-o") == 0) { i++; if (i >= argc) usage (1); outfile = argv [i]; continue; } else if (strcmp (aname, "-F") == 0) { i++; if (i >= argc) usage (1); all_meta = TRUE; aname = argv [i]; } else if (strcmp (aname, "-a") == 0) { i++; if (i >= argc) usage (1); rootfile = argv [i]; continue; } assembly = mono_assembly_open (aname, NULL); if (!assembly) { g_print ("cannot open assembly %s\n", aname); exit (1); } process_assembly (assembly, all_meta); } if (!assembly) usage (1); if (rootfile) load_roots (rootfile); process_images (); dump_images (outfile); return 0; }
int main (void) { int res = 0; MonoDomain *domain = NULL; MonoAssembly *assembly = NULL; MonoImage *prog_image = NULL; MonoImage *corlib = NULL; MonoClass *prog_klass, *console_klass; MonoMethod *meth; MonoImageOpenStatus status; //FIXME This is a fugly hack due to embedding simply not working from the tree mono_set_assemblies_path ("../../mcs/class/lib/net_4_x"); test_methods = g_array_new (FALSE, TRUE, sizeof (MonoMethod *)); if (!test_methods) { res = 1; printf ("FAILED INITIALIZING METHODS ARRAY\n"); goto out; } domain = mono_jit_init_version ("TEST RUNNER", "mobile"); assembly = mono_assembly_open (TESTPROG, &status); if (!domain || !assembly) { res = 1; printf("FAILED LOADING TEST PROGRAM\n"); goto out; } mono_callspec_set_assembly(assembly); prog_image = mono_assembly_get_image (assembly); prog_klass = test_mono_class_from_name (prog_image, "Baz", "Foo"); if (!prog_klass) { res = 1; printf ("FAILED FINDING Baz.Foo\n"); goto out; } meth = mono_class_get_method_from_name (prog_klass, "Bar", 0); if (!meth) { res = 1; printf ("FAILED FINDING Baz.Foo:Bar ()\n"); goto out; } g_array_append_val (test_methods, meth); meth = mono_class_get_method_from_name (prog_klass, "Bar", 1); if (!meth) { res = 1; printf ("FAILED FINDING Baz.Foo:Bar (string)\n"); goto out; } g_array_append_val (test_methods, meth); prog_klass = test_mono_class_from_name (prog_image, "Baz", "Goo"); if (!prog_klass) { res = 1; printf ("FAILED FINDING Baz.Goo\n"); goto out; } meth = mono_class_get_method_from_name (prog_klass, "Bar", 1); if (!meth) { res = 1; printf ("FAILED FINDING Baz.Goo:Bar (string)\n"); goto out; } g_array_append_val (test_methods, meth); prog_klass = test_mono_class_from_name (prog_image, "Baz", "Foo2"); if (!prog_klass) { res = 1; printf ("FAILED FINDING Baz.Foo2\n"); goto out; } meth = mono_class_get_method_from_name (prog_klass, "Bar", 1); if (!meth) { res = 1; printf ("FAILED FINDING Baz.Foo2:Bar (string)\n"); goto out; } g_array_append_val (test_methods, meth); corlib = mono_get_corlib (); console_klass = test_mono_class_from_name (corlib, "System", "Console"); if (!console_klass) { res = 1; printf ("FAILED FINDING System.Console\n"); goto out; } meth = mono_class_get_method_from_name (console_klass, "WriteLine", 1); if (!meth) { res = 1; printf ("FAILED FINDING System.Console:WriteLine\n"); goto out; } g_array_append_val (test_methods, meth); res = test_all_callspecs (); out: return res; }
int main (int argc, char *argv []) { int image_result = 0; MonoImage *image; char *file = NULL; char *flags = NULL; MiniVerifierMode verifier_mode = MONO_VERIFIER_MODE_VERIFIABLE; const char *flag_desc [] = {"error", "warn", "cls", "all", "code", "fail-on-verifiable", "non-strict", "valid-only", "metadata", "partial-md", NULL}; guint flag_vals [] = {MONO_VERIFY_ERROR, MONO_VERIFY_WARNING, MONO_VERIFY_CLS, MONO_VERIFY_ALL, VERIFY_CODE_ONLY, MONO_VERIFY_FAIL_FAST, MONO_VERIFY_NON_STRICT, VALID_ONLY_FLAG, VERIFY_METADATA_ONLY, VERIFY_PARTIAL_METADATA, 0}; int i, verify_flags = MONO_VERIFY_REPORT_ALL_ERRORS, run_new_metadata_verifier = 0; for (i = 1; i < argc; i++){ if (argv [i][0] != '-'){ file = argv [i]; continue; } if (strcmp (argv [i], "--help") == 0) usage (); else if (strcmp (argv [i], "--verify") == 0) { verify_pe = 1; dump_data = 0; ++i; flags = argv [i]; } else { usage (); } } if (!file) usage (); #ifndef DISABLE_PERFCOUNTERS mono_perfcounters_init (); #endif mono_counters_init (); mono_metadata_init (); mono_images_init (); mono_assemblies_init (); mono_loader_init (); if (verify_pe) { char *tok = strtok (flags, ","); verify_metadata = 1; verify_code = 0; while (tok) { for (i = 0; flag_desc [i]; ++i) { if (strcmp (tok, flag_desc [i]) == 0) { if (flag_vals [i] == VERIFY_CODE_ONLY) { verify_metadata = 0; verify_code = 1; } else if(flag_vals [i] == MONO_VERIFY_ALL) { verify_code = 1; } else if(flag_vals [i] == VERIFY_METADATA_ONLY) { verify_metadata = 0; run_new_metadata_verifier = 1; } else if(flag_vals [i] == VERIFY_PARTIAL_METADATA) { verify_partial_md = 1; } if (flag_vals [i] == VALID_ONLY_FLAG) verifier_mode = MONO_VERIFIER_MODE_VALID; else verify_flags |= flag_vals [i]; break; } } if (!flag_desc [i]) g_print ("Unknown verify flag %s\n", tok); tok = strtok (NULL, ","); } mono_verifier_set_mode (verifier_mode); /**/ } if (verify_pe || run_new_metadata_verifier) { run_new_metadata_verifier = 1; } if (run_new_metadata_verifier) { mono_verifier_set_mode (verifier_mode); image_result = verify_image_file (file); if (image_result == 1 || !verify_code) return image_result; } image = mono_image_open (file, NULL); if (!image){ fprintf (stderr, "Cannot open image %s\n", file); exit (1); } if (dump_data) dump_dotnet_iinfo (image); if (verify_pe) { MonoAssembly *assembly; MonoImage *image; MonoImageOpenStatus status; int code_result; mono_verifier_set_mode (verifier_mode); assembly = mono_assembly_open (file, NULL); /*fake an assembly for netmodules so the verifier works*/ if (!assembly && (image = mono_image_open (file, &status)) && image->tables [MONO_TABLE_ASSEMBLY].rows == 0) { assembly = g_new0 (MonoAssembly, 1); assembly->in_gac = FALSE; assembly->image = image; image->assembly = assembly; } if (!assembly) { g_print ("Could not open assembly %s\n", file); return 4; } code_result = dump_verify_info (assembly->image, verify_flags); return code_result ? code_result : image_result; } else mono_image_close (image); return 0; }
static void CDECL ReallyFixupVTable(struct dll_fixup *fixup) { HRESULT hr=S_OK; WCHAR filename[MAX_PATH]; ICLRRuntimeInfo *info=NULL; RuntimeHost *host; char *filenameA; MonoImage *image=NULL; MonoAssembly *assembly=NULL; MonoImageOpenStatus status=0; MonoDomain *domain; if (fixup->done) return; /* It's possible we'll have two threads doing this at once. This is * considered preferable to the potential deadlock if we use a mutex. */ GetModuleFileNameW(fixup->dll, filename, MAX_PATH); TRACE("%p,%p,%s\n", fixup, fixup->dll, debugstr_w(filename)); filenameA = WtoA(filename); if (!filenameA) hr = E_OUTOFMEMORY; if (SUCCEEDED(hr)) 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)) { mono_thread_attach(domain); assembly = mono_assembly_open(filenameA, &status); } if (assembly) { int i; /* Mono needs an image that belongs to an assembly. */ image = mono_assembly_get_image(assembly); if (fixup->fixup->type & COR_VTABLE_32BIT) { DWORD *vtable = fixup->vtable; DWORD *tokens = fixup->tokens; for (i=0; i<fixup->fixup->count; i++) { TRACE("%x\n", tokens[i]); vtable[i] = PtrToUint(mono_marshal_get_vtfixup_ftnptr( image, tokens[i], fixup->fixup->type)); } } fixup->done = TRUE; } if (info != NULL) ICLRRuntimeInfo_Release(info); HeapFree(GetProcessHeap(), 0, filenameA); if (!fixup->done) { ERR("unable to fixup vtable, hr=%x, status=%d\n", hr, status); /* If we returned now, we'd get an infinite loop. */ assert(0); } }