#include <mono/metadata/class-internals.h>
#include <mono/metadata/domain-internals.h>
#include <mono/metadata/mono-endian.h>
+#include <mono/metadata/mono-debug.h>
#include <mono/io-layer/io-layer.h>
#include <mono/utils/mono-uri.h>
#include <mono/metadata/mono-config.h>
{"Mono.Cairo", 0},
{"Mono.CompilerServices.SymbolWriter", 0},
{"Mono.Data", 0},
- {"Mono.Data.SqliteClient", 0},
{"Mono.Data.SybaseClient", 0},
{"Mono.Data.Tds", 0},
{"Mono.Data.TdsClient", 0},
check_path_env (void)
{
const char *path;
- char **splitted;
+ char **splitted, **dest;
path = g_getenv ("MONO_PATH");
if (!path)
splitted = g_strsplit (path, G_SEARCHPATH_SEPARATOR_S, 1000);
if (assemblies_path)
g_strfreev (assemblies_path);
- assemblies_path = splitted;
+ assemblies_path = dest = splitted;
+ while (*splitted){
+ if (**splitted)
+ *dest++ = *splitted;
+ splitted++;
+ }
+ *dest = *splitted;
+
if (g_getenv ("MONO_DEBUG") == NULL)
return;
static void
check_extra_gac_path_env (void) {
const char *path;
- char **splitted;
+ char **splitted, **dest;
path = g_getenv ("MONO_GAC_PREFIX");
if (!path)
splitted = g_strsplit (path, G_SEARCHPATH_SEPARATOR_S, 1000);
if (extra_gac_paths)
g_strfreev (extra_gac_paths);
- extra_gac_paths = splitted;
+ extra_gac_paths = dest = splitted;
+ while (*splitted){
+ if (**splitted)
+ *dest++ = *splitted;
+ splitted++;
+ }
+ *dest = *splitted;
+
if (g_getenv ("MONO_DEBUG") == NULL)
return;
* @r: second assembly.
*
* Compares two MonoAssemblyNames and returns whether they are equal.
+ *
* This compares the names, the cultures, the release version and their
* public tokens.
*
* @root_dir: The pathname of the root directory where we will locate assemblies
*
* This routine sets the internal default root directory for looking up
- * assemblies. This is used by Windows installations to compute dynamically
- * the place where the Mono assemblies are located.
+ * assemblies.
+ *
+ * This is used by Windows installations to compute dynamically the
+ * place where the Mono assemblies are located.
*
*/
void
/**
* mono_assembly_getrootdir:
+ *
+ * Obtains the root directory used for looking up assemblies.
*
- * Returns: The internal root directory used for looking up assemblies
+ * Returns: a string with the directory, this string should not be freed.
*/
G_CONST_RETURN gchar *
mono_assembly_getrootdir (void)
* @config_dir: the base directory for configuration files
*
* This routine is used internally and by developers embedding
- * the runtime into their own applications. There are a number
- * of cases to consider: Mono as a system-installed package that
- * is available on the location preconfigured or Mono in a relocated
- * location.
+ * the runtime into their own applications.
+ *
+ * There are a number of cases to consider: Mono as a system-installed
+ * package that is available on the location preconfigured or Mono in
+ * a relocated location.
*
* If you are using a system-installed Mono, you can pass NULL
* to both parameters. If you are not, you should compute both
aname->revision = cols [MONO_ASSEMBLY_REV_NUMBER];
aname->hash_alg = cols [MONO_ASSEMBLY_HASH_ALG];
if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
- gchar* token = g_malloc (8);
+ guchar* token = g_malloc (8);
gchar* encoded;
+ const gchar* pkey;
int len;
- aname->public_key = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
- len = mono_metadata_decode_blob_size (aname->public_key, (const char**)&aname->public_key);
+ pkey = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
+ len = mono_metadata_decode_blob_size (pkey, &pkey);
+ aname->public_key = (guchar*)pkey;
mono_digest_get_public_token (token, aname->public_key, len);
encoded = encode_public_tok (token, 8);
- g_strlcpy (aname->public_key_token, encoded, MONO_PUBLIC_KEY_TOKEN_LENGTH);
+ g_strlcpy ((char*)aname->public_key_token, encoded, MONO_PUBLIC_KEY_TOKEN_LENGTH);
g_free (encoded);
g_free (token);
}
if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
- aname->public_key = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
+ aname->public_key = (guchar*)mono_metadata_blob_heap (image, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
}
else
aname->public_key = 0;
return TRUE;
}
-/*
+/**
* mono_stringify_assembly_name:
+ * @aname: the assembly name.
*
- * Convert @aname into its string format. The returned string is dynamically
+ * Convert @aname into its string format. The returned string is dynamically
* allocated and should be freed by the caller.
+ *
+ * Returns: a newly allocated string with a string representation of
+ * the assembly name.
*/
char*
mono_stringify_assembly_name (MonoAssemblyName *aname)
len = mono_metadata_decode_blob_size (public_tok, &public_tok);
if (flags & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG) {
- gchar token [8];
- mono_digest_get_public_token (token, public_tok, len);
+ guchar token [8];
+ mono_digest_get_public_token (token, (guchar*)public_tok, len);
return encode_public_tok (token, 8);
}
- return encode_public_tok (public_tok, len);
+ return encode_public_tok ((guchar*)public_tok, len);
}
/**
if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
gchar *token = assemblyref_public_tok (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY], aname->flags);
- g_strlcpy (aname->public_key_token, token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
+ g_strlcpy ((char*)aname->public_key_token, token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
g_free (token);
} else {
memset (aname->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
* it inside a critical section.
*/
mono_assemblies_lock ();
+ if (!image->references)
+ mono_assembly_load_references (image, &status);
reference = image->references [index];
mono_assemblies_unlock ();
if (reference)
mono_assembly_get_assemblyref (image, index, &aname);
- if (image->assembly->ref_only) {
+ if (image->assembly && image->assembly->ref_only) {
/* We use the loaded corlib */
if (!strcmp (aname.name, "mscorlib"))
reference = mono_assembly_load_full (&aname, image->assembly->basedir, &status, FALSE);
if (!reference)
reference = REFERENCE_MISSING;
} else
- reference = mono_assembly_load (&aname, image->assembly->basedir, &status);
+ reference = mono_assembly_load (&aname, image->assembly? image->assembly->basedir: NULL, &status);
if (reference == NULL){
char *extra_msg = g_strdup ("");
" Public Key: %s\n%s",
image->name, aname.name, index,
aname.major, aname.minor, aname.build, aname.revision,
- strlen(aname.public_key_token) == 0 ? "(none)" : (char*)aname.public_key_token, extra_msg);
+ strlen ((char*)aname.public_key_token) == 0 ? "(none)" : (char*)aname.public_key_token, extra_msg);
g_free (extra_msg);
}
if (!image->references [index]) {
if (reference != REFERENCE_MISSING){
mono_assembly_addref (reference);
- mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Assembly Ref addref %s %p -> %s %p: %d\n",
+ if (image->assembly)
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Assembly Ref addref %s %p -> %s %p: %d\n",
image->assembly->aname.name, image->assembly, reference->aname.name, reference, reference->ref_count);
} else {
- mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Failed to load assembly %s %p\n",
+ if (image->assembly)
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Failed to load assembly %s %p\n",
image->assembly->aname.name, image->assembly);
}
mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status)
{
MonoTableInfo *t;
- int i;
*status = MONO_IMAGE_OK;
t = &image->tables [MONO_TABLE_ASSEMBLYREF];
image->references = g_new0 (MonoAssembly *, t->rows + 1);
-
- /* resolve assembly references for modules */
- for (i = 0; i < image->module_count; i++){
- if (image->modules [i]) {
- image->modules [i]->assembly = image->assembly;
- mono_assembly_load_references (image->modules [i], status);
- }
- }
}
typedef struct AssemblyLoadHook AssemblyLoadHook;
list = g_list_reverse (list);
/* Ignores last data pointer, which should be the filename */
- for (tmp = list; tmp && tmp->next != NULL; tmp = tmp->next)
+ for (tmp = list; tmp && tmp->next != NULL; tmp = tmp->next){
if (tmp->data)
g_string_append_printf (result, "%s%c", (char *) tmp->data,
G_DIR_SEPARATOR);
-
+ }
+
res = result->str;
g_string_free (result, FALSE);
g_list_free (list);
* defined bundles, if found, returns the MonoImage for it, if not found
* returns NULL
*/
-static MonoImage *
+MonoImage *
mono_assembly_open_from_bundle (const char *filename, MonoImageOpenStatus *status, gboolean refonly)
{
int i;
- char *name = g_path_get_basename (filename);
+ char *name;
MonoImage *image = NULL;
/*
* we do a very simple search for bundled assemblies: it's not a general
* purpose assembly loading mechanism.
*/
+
+ if (!bundles)
+ return NULL;
+
+ name = g_path_get_basename (filename);
+
mono_assemblies_lock ();
for (i = 0; !image && bundles [i]; ++i) {
if (strcmp (bundles [i]->name, name) == 0) {
}
/*
- * load_friend_assemblies:
+ * mono_load_friend_assemblies:
* @ass: an assembly
*
* Load the list of friend assemblies that are allowed to access
* the assembly's internal types and members. They are stored as assembly
* names in custom attributes.
+ *
+ * This is an internal method, we need this because when we load mscorlib
+ * we do not have the mono_defaults.internals_visible_class loaded yet,
+ * so we need to load these after we initialize the runtime.
*/
-static void
-load_friend_assemblies (MonoAssembly* ass)
+void
+mono_assembly_load_friends (MonoAssembly* ass)
{
int i;
MonoCustomAttrInfo* attrs = mono_custom_attrs_from_assembly (ass);
for (i = 0; i < attrs->num_attrs; ++i) {
MonoCustomAttrEntry *attr = &attrs->attrs [i];
MonoAssemblyName *aname;
- const guchar *data;
+ const gchar *data;
guint slen;
/* Do some sanity checking */
if (!attr->ctor || attr->ctor->klass != mono_defaults.internals_visible_class)
continue;
if (attr->data_size < 4)
continue;
- data = attr->data;
+ data = (const char*)attr->data;
/* 0xFF means null string, see custom attr format */
- if (data [0] != 1 || data [1] != 0 || data [2] == 0xFF)
+ if (data [0] != 1 || data [1] != 0 || (data [2] & 0xFF) == 0xFF)
continue;
slen = mono_metadata_decode_value (data + 2, &data);
aname = g_new0 (MonoAssemblyName, 1);
GList *loading;
GHashTable *ass_loading;
+ if (!image->tables [MONO_TABLE_ASSEMBLY].rows) {
+ /* 'image' doesn't have a manifest -- maybe someone is trying to Assembly.Load a .netmodule */
+ *status = MONO_IMAGE_IMAGE_INVALID;
+ return NULL;
+ }
+
+
#if defined (PLATFORM_WIN32)
{
gchar *tmp_fn;
/* avoid loading the same assembly twice for now... */
ass2 = search_loaded (&ass->aname, refonly);
if (ass2) {
+ mono_assemblies_unlock ();
g_free (ass);
g_free (base_dir);
mono_image_close (image);
*status = MONO_IMAGE_OK;
- mono_assemblies_unlock ();
return ass2;
}
}
loaded_assemblies = g_list_prepend (loaded_assemblies, ass);
if (mono_defaults.internals_visible_class)
- load_friend_assemblies (ass);
+ mono_assembly_load_friends (ass);
mono_assemblies_unlock ();
mono_assembly_invoke_load_hook (ass);
}
/**
-* mono_assembly_name_free:
-* @aname: assembly name to free
-*
-* Frees the provided assembly name object.
-* (it does not frees the object itself, only the name members).
-*/
+ * mono_assembly_name_free:
+ * @aname: assembly name to free
+ *
+ * Frees the provided assembly name object.
+ * (it does not frees the object itself, only the name members).
+ */
void
mono_assembly_name_free (MonoAssemblyName *aname)
{
{
gint major, minor, build, revision;
gint len;
+ gint version_parts;
gchar *pkey, *pkeyptr, *encoded, tok [8];
memset (aname, 0, sizeof (MonoAssemblyName));
if (version) {
- if (sscanf (version, "%u.%u.%u.%u", &major, &minor, &build, &revision) != 4)
+ version_parts = sscanf (version, "%u.%u.%u.%u", &major, &minor, &build, &revision);
+ if (version_parts < 2 || version_parts > 4)
return FALSE;
+ /* FIXME: we should set build & revision to -1 (instead of 0)
+ if these are not set in the version string. That way, later on,
+ we can still determine if these were specified. */
aname->major = major;
aname->minor = minor;
- aname->build = build;
- aname->revision = revision;
+ if (version_parts >= 3)
+ aname->build = build;
+ else
+ aname->build = 0;
+ if (version_parts == 4)
+ aname->revision = revision;
+ else
+ aname->revision = 0;
}
aname->name = g_strdup (name);
tmp++;
continue;
}
-
+
+ if (!g_ascii_strncasecmp (value, "ProcessorArchitecture=", 22)) {
+ /* this is ignored for now, until we can change MonoAssemblyName */
+ tmp++;
+ continue;
+ }
+
g_strfreev (parts);
return FALSE;
}
}
/**
-* mono_assembly_name_parse:
-* @name: name to parse
-* @aname: the destination assembly name
-*
-* Parses an assembly qualified type name and assigns the name,
-* version, culture and token to the provided assembly name object.
-*
-* Returns: true if the name could be parsed.
-*/
+ * mono_assembly_name_parse:
+ * @name: name to parse
+ * @aname: the destination assembly name
+ *
+ * Parses an assembly qualified type name and assigns the name,
+ * version, culture and token to the provided assembly name object.
+ *
+ * Returns: true if the name could be parsed.
+ */
gboolean
mono_assembly_name_parse (const char *name, MonoAssemblyName *aname)
{
while ((direntry = g_dir_read_name (dirhandle))) {
gboolean match = TRUE;
- parse_assembly_directory_name (aname->name, direntry, &gac_aname);
+ if(!parse_assembly_directory_name (aname->name, direntry, &gac_aname))
+ continue;
if (aname->culture != NULL && strcmp (aname->culture, gac_aname.culture) != 0)
match = FALSE;
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Unloading assembly %s [%p].", assembly->aname.name, assembly);
+ mono_debug_close_image (assembly->image);
+
mono_assemblies_lock ();
loaded_assemblies = g_list_remove (loaded_assemblies, assembly);
mono_assemblies_unlock ();
- if (assembly->image->references) {
- int i;
-
- for (i = 0; assembly->image->references [i]; i++) {
- if (assembly->image->references [i])
- mono_assembly_close (assembly->image->references [i]);
- }
-
- g_free (assembly->image->references);
- assembly->image->references = NULL;
- }
-
assembly->image->assembly = NULL;
mono_image_close (assembly->image);
projects / mono.git / blobdiff