2 * assembly.c: Routines for loading assemblies.
5 * Miguel de Icaza (miguel@ximian.com)
7 * (C) 2001 Ximian, Inc. http://www.ximian.com
19 #include "rawbuffer.h"
20 #include <mono/metadata/loader.h>
21 #include <mono/metadata/tabledefs.h>
22 #include <mono/metadata/metadata-internals.h>
23 #include <mono/metadata/class-internals.h>
24 #include <mono/metadata/domain-internals.h>
25 #include <mono/metadata/mono-endian.h>
26 #include <mono/io-layer/io-layer.h>
27 #include <mono/utils/mono-uri.h>
28 #include <mono/metadata/mono-config.h>
29 #include <mono/utils/mono-digest.h>
30 #include <mono/utils/mono-logger.h>
31 #include <mono/os/util.h>
33 /* AssemblyVersionMap: an assembly name and the assembly version set on which it is based */
35 const char* assembly_name;
36 guint8 version_set_index;
39 /* the default search path is empty, the first slot is replaced with the computed value */
46 /* Contains the list of directories to be searched for assemblies (MONO_PATH) */
47 static char **assemblies_path = NULL;
49 /* Contains the list of directories that point to auxiliary GACs */
50 static char **extra_gac_paths = NULL;
52 /* The list of system assemblies what will be remapped to the running
53 * runtime version. WARNING: this list must be sorted.
55 static const AssemblyVersionMap framework_assemblies [] = {
57 {"Commons.Xml.Relaxng", 0},
64 {"Microsoft.VisualBasic", 1},
65 {"Microsoft.VisualC", 1},
67 {"Mono.CompilerServices.SymbolWriter", 0},
69 {"Mono.Data.SqliteClient", 0},
70 {"Mono.Data.SybaseClient", 0},
72 {"Mono.Data.TdsClient", 0},
73 {"Mono.GetOptions", 0},
77 {"Mono.Security.Win32", 0},
79 {"Novell.Directory.Ldap", 0},
83 {"System.Configuration.Install", 0},
85 {"System.Data.OracleClient", 0},
86 {"System.Data.SqlXml", 0},
88 {"System.DirectoryServices", 0},
89 {"System.Drawing", 0},
90 {"System.Drawing.Design", 0},
91 {"System.EnterpriseServices", 0},
92 {"System.Management", 0},
93 {"System.Messaging", 0},
94 {"System.Runtime.Remoting", 0},
95 {"System.Runtime.Serialization.Formatters.Soap", 0},
96 {"System.Security", 0},
97 {"System.ServiceProcess", 0},
99 {"System.Web.Mobile", 0},
100 {"System.Web.Services", 0},
101 {"System.Windows.Forms", 0},
107 * keeps track of loaded assemblies
109 static GList *loaded_assemblies = NULL;
110 static MonoAssembly *corlib;
112 /* This protects loaded_assemblies and image->references */
113 #define mono_assemblies_lock() EnterCriticalSection (&assemblies_mutex)
114 #define mono_assemblies_unlock() LeaveCriticalSection (&assemblies_mutex)
115 static CRITICAL_SECTION assemblies_mutex;
117 /* A hastable of thread->assembly list mappings */
118 static GHashTable *assemblies_loading;
120 /* A hashtable of reflection only load thread->assemblies mappings */
121 static GHashTable *assemblies_refonly_loading;
123 /* If defined, points to the bundled assembly information */
124 const MonoBundledAssembly **bundles;
126 /* Loaded assembly binding info */
127 static GSList *loaded_assembly_bindings = NULL;
130 mono_assembly_invoke_search_hook_internal (MonoAssemblyName *aname, gboolean refonly, gboolean postload);
133 encode_public_tok (const guchar *token, gint32 len)
135 const static gchar allowed [] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
139 res = g_malloc (len * 2 + 1);
140 for (i = 0; i < len; i++) {
141 res [i * 2] = allowed [token [i] >> 4];
142 res [i * 2 + 1] = allowed [token [i] & 0xF];
149 check_path_env (void)
154 path = g_getenv ("MONO_PATH");
158 splitted = g_strsplit (path, G_SEARCHPATH_SEPARATOR_S, 1000);
160 g_strfreev (assemblies_path);
161 assemblies_path = splitted;
162 if (g_getenv ("MONO_DEBUG") == NULL)
166 if (**splitted && !g_file_test (*splitted, G_FILE_TEST_IS_DIR))
167 g_warning ("'%s' in MONO_PATH doesn't exist or has wrong permissions.", *splitted);
174 check_extra_gac_path_env (void) {
178 path = g_getenv ("MONO_GAC_PREFIX");
182 splitted = g_strsplit (path, G_SEARCHPATH_SEPARATOR_S, 1000);
184 g_strfreev (extra_gac_paths);
185 extra_gac_paths = splitted;
186 if (g_getenv ("MONO_DEBUG") == NULL)
190 if (**splitted && !g_file_test (*splitted, G_FILE_TEST_IS_DIR))
191 g_warning ("'%s' in MONO_GAC_PATH doesn't exist or has wrong permissions.", *splitted);
198 assembly_binding_maps_name (MonoAssemblyBindingInfo *info, MonoAssemblyName *aname)
200 if (strcmp (info->name, aname->name))
203 if (info->major != aname->major || info->minor != aname->minor)
206 if ((info->culture != NULL) != (aname->culture != NULL))
209 if (info->culture && strcmp (info->culture, aname->culture))
212 if (strcmp ((const char *)info->public_key_token, (const char *)aname->public_key_token))
219 mono_assembly_binding_info_free (MonoAssemblyBindingInfo *info)
222 g_free (info->culture);
226 get_publisher_policy_info (MonoImage *image, MonoAssemblyName *aname, MonoAssemblyBindingInfo *binding_info)
229 guint32 cols [MONO_MANIFEST_SIZE];
230 const gchar *filename;
231 gchar *subpath, *fullpath;
233 t = &image->tables [MONO_TABLE_MANIFESTRESOURCE];
234 /* MS Impl. accepts policy assemblies with more than
235 * one manifest resource, and only takes the first one */
237 binding_info->is_valid = FALSE;
241 mono_metadata_decode_row (t, 0, cols, MONO_MANIFEST_SIZE);
242 if ((cols [MONO_MANIFEST_IMPLEMENTATION] & MONO_IMPLEMENTATION_MASK) != MONO_IMPLEMENTATION_FILE) {
243 binding_info->is_valid = FALSE;
247 filename = mono_metadata_string_heap (image, cols [MONO_MANIFEST_NAME]);
248 g_assert (filename != NULL);
250 subpath = g_path_get_dirname (image->name);
251 fullpath = g_build_path (G_DIR_SEPARATOR_S, subpath, filename, NULL);
252 mono_config_parse_publisher_policy (fullpath, binding_info);
256 /* Define the optional elements/attributes before checking */
257 if (!binding_info->culture)
258 binding_info->culture = g_strdup ("");
260 /* Check that the most important elements/attributes exist */
261 if (!binding_info->name || !binding_info->public_key_token [0] || !binding_info->has_old_version_bottom ||
262 !binding_info->has_new_version || !assembly_binding_maps_name (binding_info, aname)) {
263 mono_assembly_binding_info_free (binding_info);
264 binding_info->is_valid = FALSE;
268 binding_info->is_valid = TRUE;
272 compare_versions (AssemblyVersionSet *v, MonoAssemblyName *aname)
274 if (v->major > aname->major)
276 else if (v->major < aname->major)
279 if (v->minor > aname->minor)
281 else if (v->minor < aname->minor)
284 if (v->build > aname->build)
286 else if (v->build < aname->build)
289 if (v->revision > aname->revision)
291 else if (v->revision < aname->revision)
298 check_policy_versions (MonoAssemblyBindingInfo *info, MonoAssemblyName *name)
303 /* If has_old_version_top doesn't exist, we don't have an interval */
304 if (!info->has_old_version_top) {
305 if (compare_versions (&info->old_version_bottom, name) == 0)
311 /* Check that the version defined by name is valid for the interval */
312 if (compare_versions (&info->old_version_top, name) < 0)
315 /* We should be greater or equal than the small version */
316 if (compare_versions (&info->old_version_bottom, name) > 0)
323 * mono_assembly_names_equal:
325 * @r: second assembly.
327 * Compares two MonoAssemblyNames and returns whether they are equal.
328 * This compares the names, the cultures, the release version and their
331 * Returns: TRUE if both assembly names are equal.
334 mono_assembly_names_equal (MonoAssemblyName *l, MonoAssemblyName *r)
336 if (!l->name || !r->name)
339 if (strcmp (l->name, r->name))
342 if (l->culture && r->culture && strcmp (l->culture, r->culture))
345 if (l->major != r->major || l->minor != r->minor ||
346 l->build != r->build || l->revision != r->revision)
347 if (! ((l->major == 0 && l->minor == 0 && l->build == 0 && l->revision == 0) || (r->major == 0 && r->minor == 0 && r->build == 0 && r->revision == 0)))
350 if (!l->public_key_token [0] || !r->public_key_token [0])
353 if (strcmp (l->public_key_token, r->public_key_token))
360 search_loaded (MonoAssemblyName* aname, gboolean refonly)
366 ass = mono_assembly_invoke_search_hook_internal (aname, refonly, FALSE);
371 * The assembly might be under load by this thread. In this case, it is
372 * safe to return an incomplete instance to prevent loops.
374 loading = g_hash_table_lookup (refonly ? assemblies_refonly_loading : assemblies_loading, GetCurrentThread ());
375 for (tmp = loading; tmp; tmp = tmp->next) {
377 if (!mono_assembly_names_equal (aname, &ass->aname))
386 static MonoAssembly *
387 load_in_path (const char *basename, const char** search_path, MonoImageOpenStatus *status, MonoBoolean refonly)
391 MonoAssembly *result;
393 for (i = 0; search_path [i]; ++i) {
394 fullpath = g_build_filename (search_path [i], basename, NULL);
395 result = mono_assembly_open_full (fullpath, status, refonly);
404 * mono_assembly_setrootdir:
405 * @root_dir: The pathname of the root directory where we will locate assemblies
407 * This routine sets the internal default root directory for looking up
408 * assemblies. This is used by Windows installations to compute dynamically
409 * the place where the Mono assemblies are located.
413 mono_assembly_setrootdir (const char *root_dir)
416 * Override the MONO_ASSEMBLIES directory configured at compile time.
418 /* Leak if called more than once */
419 default_path [0] = g_strdup (root_dir);
423 * mono_assembly_getrootdir:
425 * Returns: The internal root directory used for looking up assemblies
427 G_CONST_RETURN gchar *
428 mono_assembly_getrootdir (void)
430 return default_path [0];
435 * @assembly_dir: the base directory for assemblies
436 * @config_dir: the base directory for configuration files
438 * This routine is used internally and by developers embedding
439 * the runtime into their own applications. There are a number
440 * of cases to consider: Mono as a system-installed package that
441 * is available on the location preconfigured or Mono in a relocated
444 * If you are using a system-installed Mono, you can pass NULL
445 * to both parameters. If you are not, you should compute both
446 * directory values and call this routine.
448 * The values for a given PREFIX are:
450 * assembly_dir: PREFIX/lib
451 * config_dir: PREFIX/etc
453 * Notice that embedders that use Mono in a relocated way must
454 * compute the location at runtime, as they will be in control
455 * of where Mono is installed.
458 mono_set_dirs (const char *assembly_dir, const char *config_dir)
460 if (assembly_dir == NULL)
461 assembly_dir = MONO_ASSEMBLIES;
462 if (config_dir == NULL)
463 config_dir = MONO_CFG_DIR;
464 mono_assembly_setrootdir (assembly_dir);
465 mono_set_config_dir (config_dir);
469 * mono_assemblies_init:
471 * Initialize global variables used by this module.
474 mono_assemblies_init (void)
477 * Initialize our internal paths if we have not been initialized yet.
478 * This happens when embedders use Mono.
480 if (mono_assembly_getrootdir () == NULL)
484 check_extra_gac_path_env ();
486 InitializeCriticalSection (&assemblies_mutex);
488 assemblies_loading = g_hash_table_new (NULL, NULL);
489 assemblies_refonly_loading = g_hash_table_new (NULL, NULL);
493 mono_assembly_fill_assembly_name (MonoImage *image, MonoAssemblyName *aname)
495 MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLY];
496 guint32 cols [MONO_ASSEMBLY_SIZE];
501 mono_metadata_decode_row (t, 0, cols, MONO_ASSEMBLY_SIZE);
504 aname->hash_value = NULL;
505 aname->name = mono_metadata_string_heap (image, cols [MONO_ASSEMBLY_NAME]);
506 aname->culture = mono_metadata_string_heap (image, cols [MONO_ASSEMBLY_CULTURE]);
507 aname->flags = cols [MONO_ASSEMBLY_FLAGS];
508 aname->major = cols [MONO_ASSEMBLY_MAJOR_VERSION];
509 aname->minor = cols [MONO_ASSEMBLY_MINOR_VERSION];
510 aname->build = cols [MONO_ASSEMBLY_BUILD_NUMBER];
511 aname->revision = cols [MONO_ASSEMBLY_REV_NUMBER];
512 aname->hash_alg = cols [MONO_ASSEMBLY_HASH_ALG];
513 if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
514 gchar* token = g_malloc (8);
518 aname->public_key = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
519 len = mono_metadata_decode_blob_size (aname->public_key, (const char**)&aname->public_key);
521 mono_digest_get_public_token (token, aname->public_key, len);
522 encoded = encode_public_tok (token, 8);
523 g_strlcpy (aname->public_key_token, encoded, MONO_PUBLIC_KEY_TOKEN_LENGTH);
529 aname->public_key = NULL;
530 memset (aname->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
533 if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
534 aname->public_key = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
537 aname->public_key = 0;
543 * mono_stringify_assembly_name:
545 * Convert @aname into its string format. The returned string is dynamically
546 * allocated and should be freed by the caller.
549 mono_stringify_assembly_name (MonoAssemblyName *aname)
551 return g_strdup_printf (
552 "%s, Version=%d.%d.%d.%d, Culture=%s%s%s",
554 aname->major, aname->minor, aname->build, aname->revision,
555 aname->culture && *aname->culture? aname->culture: "neutral",
556 aname->public_key_token [0] ? ", PublicKeyToken=" : "",
557 aname->public_key_token [0] ? (char *)aname->public_key_token : "");
561 assemblyref_public_tok (MonoImage *image, guint32 key_index, guint32 flags)
563 const gchar *public_tok;
566 public_tok = mono_metadata_blob_heap (image, key_index);
567 len = mono_metadata_decode_blob_size (public_tok, &public_tok);
569 if (flags & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG) {
571 mono_digest_get_public_token (token, public_tok, len);
572 return encode_public_tok (token, 8);
575 return encode_public_tok (public_tok, len);
579 * mono_assembly_addref:
580 * @assemnly: the assembly to reference
582 * This routine increments the reference count on a MonoAssembly.
583 * The reference count is reduced every time the method mono_assembly_close() is
587 mono_assembly_addref (MonoAssembly *assembly)
589 InterlockedIncrement (&assembly->ref_count);
592 static MonoAssemblyName *
593 mono_assembly_remap_version (MonoAssemblyName *aname, MonoAssemblyName *dest_aname)
595 const MonoRuntimeInfo *current_runtime;
596 int pos, first, last;
598 if (aname->name == NULL) return aname;
599 current_runtime = mono_get_runtime_info ();
602 last = G_N_ELEMENTS (framework_assemblies) - 1;
604 while (first <= last) {
606 pos = first + (last - first) / 2;
607 res = strcmp (aname->name, framework_assemblies[pos].assembly_name);
609 const AssemblyVersionSet* vset;
610 int index = framework_assemblies[pos].version_set_index;
611 g_assert (index < G_N_ELEMENTS (current_runtime->version_sets));
612 vset = ¤t_runtime->version_sets [index];
614 if (aname->major == vset->major && aname->minor == vset->minor &&
615 aname->build == vset->build && aname->revision == vset->revision)
618 if ((aname->major | aname->minor | aname->build | aname->revision) != 0)
619 mono_trace (G_LOG_LEVEL_WARNING, MONO_TRACE_ASSEMBLY,
620 "The request to load the assembly %s v%d.%d.%d.%d was remapped to v%d.%d.%d.%d",
622 aname->major, aname->minor, aname->build, aname->revision,
623 vset->major, vset->minor, vset->build, vset->revision
626 memcpy (dest_aname, aname, sizeof(MonoAssemblyName));
627 dest_aname->major = vset->major;
628 dest_aname->minor = vset->minor;
629 dest_aname->build = vset->build;
630 dest_aname->revision = vset->revision;
632 } else if (res < 0) {
642 * mono_assembly_get_assemblyref:
644 * Fill out ANAME with the assembly name of the INDEXth assembly reference in IMAGE.
647 mono_assembly_get_assemblyref (MonoImage *image, int index, MonoAssemblyName *aname)
650 guint32 cols [MONO_ASSEMBLYREF_SIZE];
653 t = &image->tables [MONO_TABLE_ASSEMBLYREF];
655 mono_metadata_decode_row (t, index, cols, MONO_ASSEMBLYREF_SIZE);
657 hash = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLYREF_HASH_VALUE]);
658 aname->hash_len = mono_metadata_decode_blob_size (hash, &hash);
659 aname->hash_value = hash;
660 aname->name = mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME]);
661 aname->culture = mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE]);
662 aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
663 aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION];
664 aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION];
665 aname->build = cols [MONO_ASSEMBLYREF_BUILD_NUMBER];
666 aname->revision = cols [MONO_ASSEMBLYREF_REV_NUMBER];
668 if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
669 gchar *token = assemblyref_public_tok (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY], aname->flags);
670 g_strlcpy (aname->public_key_token, token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
673 memset (aname->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
678 mono_assembly_load_reference (MonoImage *image, int index)
680 MonoAssembly *reference;
681 MonoAssemblyName aname;
682 MonoImageOpenStatus status;
685 * image->references is shared between threads, so we need to access
686 * it inside a critical section.
688 mono_assemblies_lock ();
689 reference = image->references [index];
690 mono_assemblies_unlock ();
694 mono_assembly_get_assemblyref (image, index, &aname);
696 if (image->assembly->ref_only) {
697 /* We use the loaded corlib */
698 if (!strcmp (aname.name, "mscorlib"))
699 reference = mono_assembly_load_full (&aname, image->assembly->basedir, &status, FALSE);
701 reference = mono_assembly_loaded_full (&aname, TRUE);
703 * Here we must advice that the error was due to
704 * a non loaded reference using the ReflectionOnly api
707 reference = (gpointer)-1;
709 reference = mono_assembly_load (&aname, image->assembly->basedir, &status);
711 if (reference == NULL){
712 char *extra_msg = g_strdup ("");
714 if (status == MONO_IMAGE_ERROR_ERRNO && errno == ENOENT) {
715 extra_msg = g_strdup_printf ("The assembly was not found in the Global Assembly Cache, a path listed in the MONO_PATH environment variable, or in the location of the executing assembly (%s).\n", image->assembly->basedir);
716 } else if (status == MONO_IMAGE_ERROR_ERRNO) {
717 extra_msg = g_strdup_printf ("System error: %s\n", strerror (errno));
718 } else if (status == MONO_IMAGE_MISSING_ASSEMBLYREF) {
719 extra_msg = g_strdup ("Cannot find an assembly referenced from this one.\n");
720 } else if (status == MONO_IMAGE_IMAGE_INVALID) {
721 extra_msg = g_strdup ("The file exists but is not a valid assembly.\n");
724 g_warning ("The following assembly referenced from %s could not be loaded:\n"
725 " Assembly: %s (assemblyref_index=%d)\n"
726 " Version: %d.%d.%d.%d\n"
727 " Public Key: %s\n%s",
728 image->name, aname.name, index,
729 aname.major, aname.minor, aname.build, aname.revision,
730 strlen(aname.public_key_token) == 0 ? "(none)" : (char*)aname.public_key_token, extra_msg);
734 mono_assemblies_lock ();
735 if (reference == NULL) {
736 /* Flag as not found */
737 reference = (gpointer)-1;
739 mono_assembly_addref (reference);
742 if (!image->references [index])
743 image->references [index] = reference;
744 mono_assemblies_unlock ();
746 if (image->references [index] != reference) {
747 /* Somebody loaded it before us */
748 mono_assembly_close (reference);
753 mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status)
758 *status = MONO_IMAGE_OK;
760 t = &image->tables [MONO_TABLE_ASSEMBLYREF];
762 image->references = g_new0 (MonoAssembly *, t->rows + 1);
764 /* resolve assembly references for modules */
765 for (i = 0; i < image->module_count; i++){
766 if (image->modules [i]) {
767 image->modules [i]->assembly = image->assembly;
768 mono_assembly_load_references (image->modules [i], status);
773 typedef struct AssemblyLoadHook AssemblyLoadHook;
774 struct AssemblyLoadHook {
775 AssemblyLoadHook *next;
776 MonoAssemblyLoadFunc func;
780 AssemblyLoadHook *assembly_load_hook = NULL;
783 mono_assembly_invoke_load_hook (MonoAssembly *ass)
785 AssemblyLoadHook *hook;
787 for (hook = assembly_load_hook; hook; hook = hook->next) {
788 hook->func (ass, hook->user_data);
793 mono_install_assembly_load_hook (MonoAssemblyLoadFunc func, gpointer user_data)
795 AssemblyLoadHook *hook;
797 g_return_if_fail (func != NULL);
799 hook = g_new0 (AssemblyLoadHook, 1);
801 hook->user_data = user_data;
802 hook->next = assembly_load_hook;
803 assembly_load_hook = hook;
806 typedef struct AssemblySearchHook AssemblySearchHook;
807 struct AssemblySearchHook {
808 AssemblySearchHook *next;
809 MonoAssemblySearchFunc func;
815 AssemblySearchHook *assembly_search_hook = NULL;
818 mono_assembly_invoke_search_hook_internal (MonoAssemblyName *aname, gboolean refonly, gboolean postload)
820 AssemblySearchHook *hook;
822 for (hook = assembly_search_hook; hook; hook = hook->next) {
823 if ((hook->refonly == refonly) && (hook->postload == postload)) {
824 MonoAssembly *ass = hook->func (aname, hook->user_data);
834 mono_assembly_invoke_search_hook (MonoAssemblyName *aname)
836 return mono_assembly_invoke_search_hook_internal (aname, FALSE, FALSE);
840 mono_install_assembly_search_hook_internal (MonoAssemblySearchFunc func, gpointer user_data, gboolean refonly, gboolean postload)
842 AssemblySearchHook *hook;
844 g_return_if_fail (func != NULL);
846 hook = g_new0 (AssemblySearchHook, 1);
848 hook->user_data = user_data;
849 hook->refonly = refonly;
850 hook->postload = postload;
851 hook->next = assembly_search_hook;
852 assembly_search_hook = hook;
856 mono_install_assembly_search_hook (MonoAssemblySearchFunc func, gpointer user_data)
858 mono_install_assembly_search_hook_internal (func, user_data, FALSE, FALSE);
862 mono_install_assembly_refonly_search_hook (MonoAssemblySearchFunc func, gpointer user_data)
864 mono_install_assembly_search_hook_internal (func, user_data, TRUE, FALSE);
868 mono_install_assembly_postload_search_hook (MonoAssemblySearchFunc func, gpointer user_data)
870 mono_install_assembly_search_hook_internal (func, user_data, FALSE, TRUE);
874 mono_install_assembly_postload_refonly_search_hook (MonoAssemblySearchFunc func, gpointer user_data)
876 mono_install_assembly_search_hook_internal (func, user_data, TRUE, TRUE);
879 typedef struct AssemblyPreLoadHook AssemblyPreLoadHook;
880 struct AssemblyPreLoadHook {
881 AssemblyPreLoadHook *next;
882 MonoAssemblyPreLoadFunc func;
886 static AssemblyPreLoadHook *assembly_preload_hook = NULL;
887 static AssemblyPreLoadHook *assembly_refonly_preload_hook = NULL;
889 static MonoAssembly *
890 invoke_assembly_preload_hook (MonoAssemblyName *aname, gchar **assemblies_path)
892 AssemblyPreLoadHook *hook;
893 MonoAssembly *assembly;
895 for (hook = assembly_preload_hook; hook; hook = hook->next) {
896 assembly = hook->func (aname, assemblies_path, hook->user_data);
897 if (assembly != NULL)
904 static MonoAssembly *
905 invoke_assembly_refonly_preload_hook (MonoAssemblyName *aname, gchar **assemblies_path)
907 AssemblyPreLoadHook *hook;
908 MonoAssembly *assembly;
910 for (hook = assembly_refonly_preload_hook; hook; hook = hook->next) {
911 assembly = hook->func (aname, assemblies_path, hook->user_data);
912 if (assembly != NULL)
920 mono_install_assembly_preload_hook (MonoAssemblyPreLoadFunc func, gpointer user_data)
922 AssemblyPreLoadHook *hook;
924 g_return_if_fail (func != NULL);
926 hook = g_new0 (AssemblyPreLoadHook, 1);
928 hook->user_data = user_data;
929 hook->next = assembly_preload_hook;
930 assembly_preload_hook = hook;
934 mono_install_assembly_refonly_preload_hook (MonoAssemblyPreLoadFunc func, gpointer user_data)
936 AssemblyPreLoadHook *hook;
938 g_return_if_fail (func != NULL);
940 hook = g_new0 (AssemblyPreLoadHook, 1);
942 hook->user_data = user_data;
943 hook->next = assembly_refonly_preload_hook;
944 assembly_refonly_preload_hook = hook;
948 absolute_dir (const gchar *filename)
959 if (g_path_is_absolute (filename))
960 return g_path_get_dirname (filename);
962 cwd = g_get_current_dir ();
963 mixed = g_build_filename (cwd, filename, NULL);
964 parts = g_strsplit (mixed, G_DIR_SEPARATOR_S, 0);
969 for (i = 0; (part = parts [i]) != NULL; i++) {
970 if (!strcmp (part, "."))
973 if (!strcmp (part, "..")) {
974 if (list && list->next) /* Don't remove root */
975 list = g_list_delete_link (list, list);
977 list = g_list_prepend (list, part);
981 result = g_string_new ("");
982 list = g_list_reverse (list);
984 /* Ignores last data pointer, which should be the filename */
985 for (tmp = list; tmp && tmp->next != NULL; tmp = tmp->next)
987 g_string_append_printf (result, "%s%c", (char *) tmp->data,
991 g_string_free (result, FALSE);
996 return g_strdup (".");
1003 * mono_assembly_open_from_bundle:
1004 * @filename: Filename requested
1005 * @status: return value
1007 * This routine tries to open the assembly specified by `filename' from the
1008 * defined bundles, if found, returns the MonoImage for it, if not found
1012 mono_assembly_open_from_bundle (const char *filename, MonoImageOpenStatus *status, gboolean refonly)
1015 char *name = g_path_get_basename (filename);
1016 MonoImage *image = NULL;
1019 * we do a very simple search for bundled assemblies: it's not a general
1020 * purpose assembly loading mechanism.
1022 mono_assemblies_lock ();
1023 for (i = 0; !image && bundles [i]; ++i) {
1024 if (strcmp (bundles [i]->name, name) == 0) {
1025 image = mono_image_open_from_data_full ((char*)bundles [i]->data, bundles [i]->size, FALSE, status, refonly);
1029 mono_assemblies_unlock ();
1032 mono_image_addref (image);
1039 do_mono_assembly_open (const char *filename, MonoImageOpenStatus *status, gboolean refonly)
1041 MonoImage *image = NULL;
1043 if (bundles != NULL){
1044 image = mono_assembly_open_from_bundle (filename, status, refonly);
1049 mono_assemblies_lock ();
1050 image = mono_image_open_full (filename, status, refonly);
1051 mono_assemblies_unlock ();
1057 mono_assembly_open_full (const char *filename, MonoImageOpenStatus *status, gboolean refonly)
1061 MonoImageOpenStatus def_status;
1064 g_return_val_if_fail (filename != NULL, NULL);
1067 status = &def_status;
1068 *status = MONO_IMAGE_OK;
1070 if (strncmp (filename, "file://", 7) == 0) {
1071 GError *error = NULL;
1072 gchar *uri = (gchar *) filename;
1076 * MS allows file://c:/... and fails on file://localhost/c:/...
1077 * They also throw an IndexOutOfRangeException if "file://"
1080 uri = g_strdup_printf ("file:///%s", uri + 7);
1083 uri = mono_escape_uri_string (tmpuri);
1084 fname = g_filename_from_uri (uri, NULL, &error);
1087 if (tmpuri != filename)
1090 if (error != NULL) {
1091 g_warning ("%s\n", error->message);
1092 g_error_free (error);
1093 fname = g_strdup (filename);
1096 fname = g_strdup (filename);
1099 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY,
1100 "Assembly Loader probing location: '%s'.", filename);
1101 image = do_mono_assembly_open (fname, status, refonly);
1104 *status = MONO_IMAGE_ERROR_ERRNO;
1109 ass = mono_assembly_load_from_full (image, fname, status, refonly);
1112 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY,
1113 "Assembly Loader loaded assembly from location: '%s'.", filename);
1115 mono_config_for_assembly (ass->image);
1124 * mono_assembly_open:
1125 * @filename: Opens the assembly pointed out by this name
1126 * @status: where a status code can be returned
1128 * mono_assembly_open opens the PE-image pointed by @filename, and
1129 * loads any external assemblies referenced by it.
1131 * NOTE: we could do lazy loading of the assemblies. Or maybe not worth
1135 mono_assembly_open (const char *filename, MonoImageOpenStatus *status)
1137 return mono_assembly_open_full (filename, status, FALSE);
1141 mono_assembly_load_from_full (MonoImage *image, const char*fname,
1142 MonoImageOpenStatus *status, gboolean refonly)
1144 MonoAssembly *ass, *ass2;
1147 GHashTable *ass_loading;
1149 #if defined (PLATFORM_WIN32)
1154 tmp_fn = g_strdup (fname);
1155 for (i = strlen (tmp_fn) - 1; i >= 0; i--) {
1156 if (tmp_fn [i] == '/')
1160 base_dir = absolute_dir (tmp_fn);
1164 base_dir = absolute_dir (fname);
1168 * To avoid deadlocks and scalability problems, we load assemblies outside
1169 * the assembly lock. This means that multiple threads might try to load
1170 * the same assembly at the same time. The first one to load it completely
1171 * "wins", the other threads free their copy and use the one loaded by
1172 * the winning thread.
1176 * Create assembly struct, and enter it into the assembly cache
1178 ass = g_new0 (MonoAssembly, 1);
1179 ass->basedir = base_dir;
1180 ass->ref_only = refonly;
1184 mono_assembly_fill_assembly_name (image, &ass->aname);
1187 * Atomically search the loaded list and add ourselves to it if necessary.
1189 mono_assemblies_lock ();
1190 if (ass->aname.name) {
1191 /* avoid loading the same assembly twice for now... */
1192 ass2 = search_loaded (&ass->aname, refonly);
1196 mono_image_close (image);
1197 *status = MONO_IMAGE_OK;
1198 mono_assemblies_unlock ();
1202 ass_loading = refonly ? assemblies_refonly_loading : assemblies_loading;
1203 loading = g_hash_table_lookup (ass_loading, GetCurrentThread ());
1204 loading = g_list_prepend (loading, ass);
1205 g_hash_table_insert (ass_loading, GetCurrentThread (), loading);
1206 mono_assemblies_unlock ();
1208 image->assembly = ass;
1210 mono_assembly_load_references (image, status);
1212 mono_assemblies_lock ();
1214 loading = g_hash_table_lookup (ass_loading, GetCurrentThread ());
1215 loading = g_list_remove (loading, ass);
1216 if (loading == NULL)
1217 /* Prevent memory leaks */
1218 g_hash_table_remove (ass_loading, GetCurrentThread ());
1220 g_hash_table_insert (ass_loading, GetCurrentThread (), loading);
1221 if (*status != MONO_IMAGE_OK) {
1222 mono_assemblies_unlock ();
1223 mono_assembly_close (ass);
1227 if (ass->aname.name) {
1228 ass2 = search_loaded (&ass->aname, refonly);
1230 /* Somebody else has loaded the assembly before us */
1231 mono_assemblies_unlock ();
1232 mono_assembly_close (ass);
1237 loaded_assemblies = g_list_prepend (loaded_assemblies, ass);
1238 mono_assemblies_unlock ();
1240 mono_assembly_invoke_load_hook (ass);
1246 mono_assembly_load_from (MonoImage *image, const char *fname,
1247 MonoImageOpenStatus *status)
1249 return mono_assembly_load_from_full (image, fname, status, FALSE);
1253 * mono_assembly_name_free:
1254 * @aname: assembly name to free
1256 * Frees the provided assembly name object.
1257 * (it does not frees the object itself, only the name members).
1260 mono_assembly_name_free (MonoAssemblyName *aname)
1265 g_free ((void *) aname->name);
1266 g_free ((void *) aname->culture);
1267 g_free ((void *) aname->hash_value);
1271 parse_public_key (const gchar *key, gchar** pubkey)
1274 gchar header [16], val, *arr;
1275 gint i, j, offset, bitlen, keylen, pkeylen;
1277 keylen = strlen (key) >> 1;
1281 val = g_ascii_xdigit_value (key [0]) << 4;
1282 val |= g_ascii_xdigit_value (key [1]);
1287 val = g_ascii_xdigit_value (key [24]);
1288 val |= g_ascii_xdigit_value (key [25]);
1300 /* We need the first 16 bytes
1301 * to check whether this key is valid or not */
1302 pkeylen = strlen (pkey) >> 1;
1306 for (i = 0, j = 0; i < 16; i++) {
1307 header [i] = g_ascii_xdigit_value (pkey [j++]) << 4;
1308 header [i] |= g_ascii_xdigit_value (pkey [j++]);
1311 if (header [0] != 0x06 || /* PUBLICKEYBLOB (0x06) */
1312 header [1] != 0x02 || /* Version (0x02) */
1313 header [2] != 0x00 || /* Reserved (word) */
1314 header [3] != 0x00 ||
1315 (guint)(read32 (header + 8)) != 0x31415352) /* DWORD magic = RSA1 */
1318 /* Based on this length, we _should_ be able to know if the length is right */
1319 bitlen = read32 (header + 12) >> 3;
1320 if ((bitlen + 16 + 4) != pkeylen)
1323 /* Encode the size of the blob */
1325 if (keylen <= 127) {
1326 arr = g_malloc (keylen + 1);
1327 arr [offset++] = keylen;
1329 arr = g_malloc (keylen + 2);
1330 arr [offset++] = 0x80; /* 10bs */
1331 arr [offset++] = keylen;
1334 for (i = offset, j = 0; i < keylen + offset; i++) {
1335 arr [i] = g_ascii_xdigit_value (key [j++]) << 4;
1336 arr [i] |= g_ascii_xdigit_value (key [j++]);
1345 build_assembly_name (const char *name, const char *version, const char *culture, const char *token, const char *key, MonoAssemblyName *aname, gboolean save_public_key)
1347 gint major, minor, build, revision;
1349 gchar *pkey, *pkeyptr, *encoded, tok [8];
1351 memset (aname, 0, sizeof (MonoAssemblyName));
1354 if (sscanf (version, "%u.%u.%u.%u", &major, &minor, &build, &revision) != 4)
1357 aname->major = major;
1358 aname->minor = minor;
1359 aname->build = build;
1360 aname->revision = revision;
1363 aname->name = g_strdup (name);
1366 if (g_strcasecmp (culture, "neutral") == 0)
1367 aname->culture = g_strdup ("");
1369 aname->culture = g_strdup (culture);
1372 if (token && strncmp (token, "null", 4) != 0)
1373 g_strlcpy ((char*)aname->public_key_token, token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
1375 if (key && strncmp (key, "null", 4) != 0) {
1376 if (!parse_public_key (key, &pkey)) {
1377 mono_assembly_name_free (aname);
1381 len = mono_metadata_decode_blob_size ((const gchar *) pkey, (const gchar **) &pkeyptr);
1382 // We also need to generate the key token
1383 mono_digest_get_public_token ((guchar*) tok, (guint8*) pkeyptr, len);
1384 encoded = encode_public_tok ((guchar*) tok, 8);
1385 g_strlcpy ((gchar*)aname->public_key_token, encoded, MONO_PUBLIC_KEY_TOKEN_LENGTH);
1388 if (save_public_key)
1389 aname->public_key = (guint8*) pkey;
1398 parse_assembly_directory_name (const char *name, const char *dirname, MonoAssemblyName *aname)
1403 parts = g_strsplit (dirname, "_", 3);
1404 if (!parts || !parts[0] || !parts[1] || !parts[2]) {
1409 res = build_assembly_name (name, parts[0], parts[1], parts[2], NULL, aname, FALSE);
1415 mono_assembly_name_parse_full (const char *name, MonoAssemblyName *aname, gboolean save_public_key, gboolean *is_version_defined)
1418 gchar *version = NULL;
1419 gchar *culture = NULL;
1420 gchar *token = NULL;
1426 gboolean version_defined;
1428 if (!is_version_defined)
1429 is_version_defined = &version_defined;
1430 *is_version_defined = FALSE;
1432 parts = tmp = g_strsplit (name, ",", 4);
1433 if (!tmp || !*tmp) {
1438 dllname = g_strstrip (*tmp);
1443 value = g_strstrip (*tmp);
1444 if (!g_ascii_strncasecmp (value, "Version=", 8)) {
1445 *is_version_defined = TRUE;
1446 version = g_strstrip (value + 8);
1451 if (!g_ascii_strncasecmp (value, "Culture=", 8)) {
1452 culture = g_strstrip (value + 8);
1457 if (!g_ascii_strncasecmp (value, "PublicKeyToken=", 15)) {
1458 token = g_strstrip (value + 15);
1463 if (!g_ascii_strncasecmp (value, "PublicKey=", 10)) {
1464 key = g_strstrip (value + 10);
1473 res = build_assembly_name (dllname, version, culture, token, key, aname, save_public_key);
1479 * mono_assembly_name_parse:
1480 * @name: name to parse
1481 * @aname: the destination assembly name
1482 * Returns: true if the name could be parsed.
1484 * Parses an assembly qualified type name and assigns the name,
1485 * version, culture and token to the provided assembly name object.
1488 mono_assembly_name_parse (const char *name, MonoAssemblyName *aname)
1490 return mono_assembly_name_parse_full (name, aname, FALSE, NULL);
1493 static MonoAssembly*
1494 probe_for_partial_name (const char *basepath, const char *fullname, MonoAssemblyName *aname, MonoImageOpenStatus *status)
1496 gchar *fullpath = NULL;
1498 const char* direntry;
1499 MonoAssemblyName gac_aname;
1500 gint major=-1, minor=0, build=0, revision=0;
1501 gboolean exact_version;
1503 dirhandle = g_dir_open (basepath, 0, NULL);
1507 exact_version = (aname->major | aname->minor | aname->build | aname->revision) != 0;
1509 while ((direntry = g_dir_read_name (dirhandle))) {
1510 gboolean match = TRUE;
1512 parse_assembly_directory_name (aname->name, direntry, &gac_aname);
1514 if (aname->culture != NULL && strcmp (aname->culture, gac_aname.culture) != 0)
1517 if (match && strlen ((char*)aname->public_key_token) > 0 &&
1518 strcmp ((char*)aname->public_key_token, (char*)gac_aname.public_key_token) != 0)
1522 if (exact_version) {
1523 match = (aname->major == gac_aname.major && aname->minor == gac_aname.minor &&
1524 aname->build == gac_aname.build && aname->revision == gac_aname.revision);
1526 else if (gac_aname.major < major)
1528 else if (gac_aname.major == major) {
1529 if (gac_aname.minor < minor)
1531 else if (gac_aname.minor == minor) {
1532 if (gac_aname.build < build)
1534 else if (gac_aname.build == build && gac_aname.revision <= revision)
1541 major = gac_aname.major;
1542 minor = gac_aname.minor;
1543 build = gac_aname.build;
1544 revision = gac_aname.revision;
1546 fullpath = g_build_path (G_DIR_SEPARATOR_S, basepath, direntry, fullname, NULL);
1549 mono_assembly_name_free (&gac_aname);
1552 g_dir_close (dirhandle);
1554 if (fullpath == NULL)
1557 MonoAssembly *res = mono_assembly_open (fullpath, status);
1564 mono_assembly_load_with_partial_name (const char *name, MonoImageOpenStatus *status)
1567 MonoAssemblyName *aname, base_name, maped_aname;
1568 gchar *fullname, *gacpath;
1571 memset (&base_name, 0, sizeof (MonoAssemblyName));
1574 if (!mono_assembly_name_parse (name, aname))
1578 * If no specific version has been requested, make sure we load the
1579 * correct version for system assemblies.
1581 if ((aname->major | aname->minor | aname->build | aname->revision) == 0)
1582 aname = mono_assembly_remap_version (aname, &maped_aname);
1584 res = mono_assembly_loaded (aname);
1586 mono_assembly_name_free (aname);
1590 res = invoke_assembly_preload_hook (aname, assemblies_path);
1592 res->in_gac = FALSE;
1593 mono_assembly_name_free (aname);
1597 fullname = g_strdup_printf ("%s.dll", aname->name);
1599 if (extra_gac_paths) {
1600 paths = extra_gac_paths;
1601 while (!res && *paths) {
1602 gacpath = g_build_path (G_DIR_SEPARATOR_S, *paths, "lib", "mono", "gac", aname->name, NULL);
1603 res = probe_for_partial_name (gacpath, fullname, aname, status);
1612 mono_assembly_name_free (aname);
1616 gacpath = g_build_path (G_DIR_SEPARATOR_S, mono_assembly_getrootdir (), "mono", "gac", aname->name, NULL);
1617 res = probe_for_partial_name (gacpath, fullname, aname, status);
1624 mono_assembly_name_free (aname);
1630 mono_assembly_load_publisher_policy (MonoAssemblyName *aname)
1633 gchar *filename, *pname, *name, *culture, *version, *fullpath, *subpath;
1637 if (strstr (aname->name, ".dll")) {
1638 len = strlen (aname->name) - 4;
1639 name = g_malloc (len);
1640 strncpy (name, aname->name, len);
1642 name = g_strdup (aname->name);
1644 if (aname->culture) {
1645 culture = g_strdup (aname->culture);
1646 g_strdown (culture);
1648 culture = g_strdup ("");
1650 pname = g_strdup_printf ("policy.%d.%d.%s", aname->major, aname->minor, name);
1651 version = g_strdup_printf ("0.0.0.0_%s_%s", culture, aname->public_key_token);
1655 filename = g_strconcat (pname, ".dll", NULL);
1656 subpath = g_build_path (G_DIR_SEPARATOR_S, pname, version, filename, NULL);
1662 if (extra_gac_paths) {
1663 paths = extra_gac_paths;
1664 while (!image && *paths) {
1665 fullpath = g_build_path (G_DIR_SEPARATOR_S, *paths,
1666 "lib", "mono", "gac", subpath, NULL);
1667 image = mono_image_open (fullpath, NULL);
1678 fullpath = g_build_path (G_DIR_SEPARATOR_S, mono_assembly_getrootdir (),
1679 "mono", "gac", subpath, NULL);
1680 image = mono_image_open (fullpath, NULL);
1687 static MonoAssemblyName*
1688 mono_assembly_bind_version (MonoAssemblyBindingInfo *info, MonoAssemblyName *aname, MonoAssemblyName *dest_name)
1690 memcpy (dest_name, aname, sizeof (MonoAssemblyName));
1691 dest_name->major = info->new_version.major;
1692 dest_name->minor = info->new_version.minor;
1693 dest_name->build = info->new_version.build;
1694 dest_name->revision = info->new_version.revision;
1699 /* LOCKING: Assumes that we are already locked */
1700 static MonoAssemblyBindingInfo*
1701 search_binding_loaded (MonoAssemblyName *aname)
1705 for (tmp = loaded_assembly_bindings; tmp; tmp = tmp->next) {
1706 MonoAssemblyBindingInfo *info = tmp->data;
1707 if (assembly_binding_maps_name (info, aname))
1714 static MonoAssemblyName*
1715 mono_assembly_apply_binding (MonoAssemblyName *aname, MonoAssemblyName *dest_name)
1717 MonoAssemblyBindingInfo *info, *info2;
1720 if (aname->public_key_token [0] == 0)
1723 mono_loader_lock ();
1724 info = search_binding_loaded (aname);
1725 mono_loader_unlock ();
1727 if (!check_policy_versions (info, aname))
1730 mono_assembly_bind_version (info, aname, dest_name);
1734 info = g_new0 (MonoAssemblyBindingInfo, 1);
1735 info->major = aname->major;
1736 info->minor = aname->minor;
1738 ppimage = mono_assembly_load_publisher_policy (aname);
1740 get_publisher_policy_info (ppimage, aname, info);
1741 mono_image_close (ppimage);
1744 /* Define default error value if needed */
1745 if (!info->is_valid) {
1746 info->name = g_strdup (aname->name);
1747 info->culture = g_strdup (aname->culture);
1748 g_strlcpy ((char *)info->public_key_token, (const char *)aname->public_key_token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
1751 mono_loader_lock ();
1752 info2 = search_binding_loaded (aname);
1754 /* This binding was added by another thread
1756 mono_assembly_binding_info_free (info);
1761 loaded_assembly_bindings = g_slist_prepend (loaded_assembly_bindings, info);
1763 mono_loader_unlock ();
1765 if (!info->is_valid || !check_policy_versions (info, aname))
1768 mono_assembly_bind_version (info, aname, dest_name);
1773 * mono_assembly_load_from_gac
1775 * @aname: The assembly name object
1777 static MonoAssembly*
1778 mono_assembly_load_from_gac (MonoAssemblyName *aname, gchar *filename, MonoImageOpenStatus *status, MonoBoolean refonly)
1780 MonoAssembly *result = NULL;
1781 gchar *name, *version, *culture, *fullpath, *subpath;
1785 if (aname->public_key_token [0] == 0) {
1789 if (strstr (aname->name, ".dll")) {
1790 len = strlen (filename) - 4;
1791 name = g_malloc (len);
1792 strncpy (name, aname->name, len);
1794 name = g_strdup (aname->name);
1797 if (aname->culture) {
1798 culture = g_strdup (aname->culture);
1799 g_strdown (culture);
1801 culture = g_strdup ("");
1804 version = g_strdup_printf ("%d.%d.%d.%d_%s_%s", aname->major,
1805 aname->minor, aname->build, aname->revision,
1806 culture, aname->public_key_token);
1808 subpath = g_build_path (G_DIR_SEPARATOR_S, name, version, filename, NULL);
1813 if (extra_gac_paths) {
1814 paths = extra_gac_paths;
1815 while (!result && *paths) {
1816 fullpath = g_build_path (G_DIR_SEPARATOR_S, *paths, "lib", "mono", "gac", subpath, NULL);
1817 result = mono_assembly_open_full (fullpath, status, refonly);
1824 result->in_gac = TRUE;
1829 fullpath = g_build_path (G_DIR_SEPARATOR_S, mono_assembly_getrootdir (),
1830 "mono", "gac", subpath, NULL);
1831 result = mono_assembly_open_full (fullpath, status, refonly);
1835 result->in_gac = TRUE;
1844 mono_assembly_load_corlib (const MonoRuntimeInfo *runtime, MonoImageOpenStatus *status)
1849 /* g_print ("corlib already loaded\n"); */
1853 if (assemblies_path) {
1854 corlib = load_in_path ("mscorlib.dll", (const char**)assemblies_path, status, FALSE);
1859 /* Load corlib from mono/<version> */
1861 corlib_file = g_build_filename ("mono", runtime->framework_version, "mscorlib.dll", NULL);
1862 if (assemblies_path) {
1863 corlib = load_in_path (corlib_file, (const char**)assemblies_path, status, FALSE);
1865 g_free (corlib_file);
1869 corlib = load_in_path (corlib_file, default_path, status, FALSE);
1870 g_free (corlib_file);
1877 mono_assembly_load_full (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status, gboolean refonly)
1879 MonoAssembly *result;
1880 char *fullpath, *filename;
1881 MonoAssemblyName maped_aname, maped_name_pp;
1885 aname = mono_assembly_remap_version (aname, &maped_aname);
1887 /* Reflection only assemblies don't get assembly binding */
1889 aname = mono_assembly_apply_binding (aname, &maped_name_pp);
1891 result = mono_assembly_loaded_full (aname, refonly);
1895 result = refonly ? invoke_assembly_refonly_preload_hook (aname, assemblies_path) : invoke_assembly_preload_hook (aname, assemblies_path);
1897 result->in_gac = FALSE;
1901 /* Currently we retrieve the loaded corlib for reflection
1902 * only requests, like a common reflection only assembly
1904 if (strcmp (aname->name, "mscorlib") == 0 || strcmp (aname->name, "mscorlib.dll") == 0) {
1905 return mono_assembly_load_corlib (mono_get_runtime_info (), status);
1908 for (ext_index = 0; ext_index < 2; ext_index ++) {
1909 ext = ext_index == 0 ? ".dll" : ".exe";
1910 if (strstr (aname->name, ".dll"))
1911 filename = g_strdup (aname->name);
1913 filename = g_strconcat (aname->name, ext, NULL);
1915 result = mono_assembly_load_from_gac (aname, filename, status, refonly);
1922 fullpath = g_build_filename (basedir, filename, NULL);
1923 result = mono_assembly_open_full (fullpath, status, refonly);
1926 result->in_gac = FALSE;
1932 result = load_in_path (filename, default_path, status, refonly);
1934 result->in_gac = FALSE;
1940 /* Try a postload search hook */
1941 result = mono_assembly_invoke_search_hook_internal (aname, refonly, TRUE);
1947 mono_assembly_load (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status)
1949 return mono_assembly_load_full (aname, basedir, status, FALSE);
1953 mono_assembly_loaded_full (MonoAssemblyName *aname, gboolean refonly)
1956 MonoAssemblyName maped_aname;
1958 aname = mono_assembly_remap_version (aname, &maped_aname);
1960 mono_assemblies_lock ();
1961 res = search_loaded (aname, refonly);
1962 mono_assemblies_unlock ();
1968 mono_assembly_loaded (MonoAssemblyName *aname)
1970 return mono_assembly_loaded_full (aname, FALSE);
1974 * mono_assembly_close:
1975 * @assembly: the assembly to release.
1977 * This method releases a reference to the @assembly. The assembly is
1978 * only released when all the outstanding references to it are released.
1981 mono_assembly_close (MonoAssembly *assembly)
1983 g_return_if_fail (assembly != NULL);
1985 if (InterlockedDecrement (&assembly->ref_count))
1988 mono_assemblies_lock ();
1989 loaded_assemblies = g_list_remove (loaded_assemblies, assembly);
1990 mono_assemblies_unlock ();
1991 /* assemblies belong to domains, so the domain code takes care of unloading the
1992 * referenced assemblies
1995 mono_image_close (assembly->image);
1997 g_free (assembly->basedir);
1998 if (!assembly->dynamic)
2003 mono_assembly_load_module (MonoAssembly *assembly, guint32 idx)
2005 MonoImageOpenStatus status;
2008 module = mono_image_load_file_for_image (assembly->image, idx);
2010 mono_assembly_load_references (module, &status);
2016 mono_assembly_foreach (GFunc func, gpointer user_data)
2021 * We make a copy of the list to avoid calling the callback inside the
2022 * lock, which could lead to deadlocks.
2024 mono_assemblies_lock ();
2025 copy = g_list_copy (loaded_assemblies);
2026 mono_assemblies_unlock ();
2028 g_list_foreach (loaded_assemblies, func, user_data);
2034 * Holds the assembly of the application, for
2035 * System.Diagnostics.Process::MainModule
2037 static MonoAssembly *main_assembly=NULL;
2040 mono_assembly_set_main (MonoAssembly *assembly)
2042 main_assembly=assembly;
2046 mono_assembly_get_main (void)
2048 return(main_assembly);
2054 mono_assembly_get_image (MonoAssembly *assembly)
2056 return assembly->image;
2060 mono_register_bundled_assemblies (const MonoBundledAssembly **assemblies)
2062 bundles = assemblies;