mono/metadata/assembly.c

   1 /*
   2  * assembly.c: Routines for loading assemblies.
   3  *
   4  * Author:
   5  *   Miguel de Icaza (miguel@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.  http://www.ximian.com
   8  *
   9  */
  10 #include <config.h>
  11 #include <stdio.h>
  12 #include <glib.h>
  13 #include <errno.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16 #include "assembly.h"
  17 #include "image.h"
  18 #include "rawbuffer.h"
  19 #include "object-internals.h"
  20 #include <mono/metadata/loader.h>
  21 #include <mono/metadata/tabledefs.h>
  22 #include <mono/metadata/metadata-internals.h>
  23 #include <mono/metadata/profiler-private.h>
  24 #include <mono/metadata/class-internals.h>
  25 #include <mono/metadata/domain-internals.h>
  26 #include <mono/metadata/mono-endian.h>
  27 #include <mono/metadata/mono-debug.h>
  28 #include <mono/io-layer/io-layer.h>
  29 #include <mono/utils/mono-uri.h>
  30 #include <mono/metadata/mono-config.h>
  31 #include <mono/utils/mono-digest.h>
  32 #include <mono/utils/mono-logger.h>
  33 #include <mono/metadata/reflection.h>
  34 #include <mono/metadata/coree.h>
  35
  36 #ifndef PLATFORM_WIN32
  37 #include <sys/types.h>
  38 #include <unistd.h>
  39 #include <sys/stat.h>
  40 #endif
  41
  42 /* AssemblyVersionMap: an assembly name and the assembly version set on which it is based */
  43 typedef struct  {
  44         const char* assembly_name;
  45         guint8 version_set_index;
  46 } AssemblyVersionMap;
  47
  48 /* the default search path is empty, the first slot is replaced with the computed value */
  49 static const char*
  50 default_path [] = {
  51         NULL,
  52         NULL
  53 };
  54
  55 /* Contains the list of directories to be searched for assemblies (MONO_PATH) */
  56 static char **assemblies_path = NULL;
  57
  58 /* Contains the list of directories that point to auxiliary GACs */
  59 static char **extra_gac_paths = NULL;
  60
  61 /* The list of system assemblies what will be remapped to the running
  62  * runtime version. WARNING: this list must be sorted.
  63  */
  64 static const AssemblyVersionMap framework_assemblies [] = {
  65         {"Accessibility", 0},
  66         {"Commons.Xml.Relaxng", 0},
  67         {"I18N", 0},
  68         {"I18N.CJK", 0},
  69         {"I18N.MidEast", 0},
  70         {"I18N.Other", 0},
  71         {"I18N.Rare", 0},
  72         {"I18N.West", 0},
  73         {"Microsoft.VisualBasic", 1},
  74         {"Microsoft.VisualC", 1},
  75         {"Mono.Cairo", 0},
  76         {"Mono.CompilerServices.SymbolWriter", 0},
  77         {"Mono.Data", 0},
  78         {"Mono.Data.SybaseClient", 0},
  79         {"Mono.Data.Tds", 0},
  80         {"Mono.Data.TdsClient", 0},
  81         {"Mono.GetOptions", 0},
  82         {"Mono.Http", 0},
  83         {"Mono.Posix", 0},
  84         {"Mono.Security", 0},
  85         {"Mono.Security.Win32", 0},
  86         {"Mono.Xml.Ext", 0},
  87         {"Novell.Directory.Ldap", 0},
  88         {"Npgsql", 0},
  89         {"PEAPI", 0},
  90         {"System", 0},
  91         {"System.Configuration.Install", 0},
  92         {"System.Data", 0},
  93         {"System.Data.OracleClient", 0},
  94         {"System.Data.SqlXml", 0},
  95         {"System.Design", 0},
  96         {"System.DirectoryServices", 0},
  97         {"System.Drawing", 0},
  98         {"System.Drawing.Design", 0},
  99         {"System.EnterpriseServices", 0},
 100         {"System.Management", 0},
 101         {"System.Messaging", 0},
 102         {"System.Runtime.Remoting", 0},
 103         {"System.Runtime.Serialization.Formatters.Soap", 0},
 104         {"System.Security", 0},
 105         {"System.ServiceProcess", 0},
 106         {"System.Web", 0},
 107         {"System.Web.Mobile", 0},
 108         {"System.Web.Services", 0},
 109         {"System.Windows.Forms", 0},
 110         {"System.Xml", 0},
 111         {"mscorlib", 0}
 112 };
 113
 114 /*
 115  * keeps track of loaded assemblies
 116  */
 117 static GList *loaded_assemblies = NULL;
 118 static MonoAssembly *corlib;
 119
 120 /* This protects loaded_assemblies and image->references */
 121 #define mono_assemblies_lock() EnterCriticalSection (&assemblies_mutex)
 122 #define mono_assemblies_unlock() LeaveCriticalSection (&assemblies_mutex)
 123 static CRITICAL_SECTION assemblies_mutex;
 124
 125 /* If defined, points to the bundled assembly information */
 126 const MonoBundledAssembly **bundles;
 127
 128 /* Loaded assembly binding info */
 129 static GSList *loaded_assembly_bindings = NULL;
 130
 131 static MonoAssembly*
 132 mono_assembly_invoke_search_hook_internal (MonoAssemblyName *aname, gboolean refonly, gboolean postload);
 133
 134 static gchar*
 135 encode_public_tok (const guchar *token, gint32 len)
 136 {
 137         const static gchar allowed [] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
 138         gchar *res;
 139         int i;
 140
 141         res = g_malloc (len * 2 + 1);
 142         for (i = 0; i < len; i++) {
 143                 res [i * 2] = allowed [token [i] >> 4];
 144                 res [i * 2 + 1] = allowed [token [i] & 0xF];
 145         }
 146         res [len * 2] = 0;
 147         return res;
 148 }
 149
 150 /**
 151  * mono_public_tokens_are_equal:
 152  * @pubt1: first public key token
 153  * @pubt2: second public key token
 154  *
 155  * Compare two public key tokens and return #TRUE is they are equal and #FALSE
 156  * otherwise.
 157  */
 158 gboolean
 159 mono_public_tokens_are_equal (const unsigned char *pubt1, const unsigned char *pubt2)
 160 {
 161         return g_strcasecmp ((char*)pubt1, (char*)pubt2) == 0;
 162 }
 163
 164 static void
 165 check_path_env (void)
 166 {
 167         const char *path;
 168         char **splitted, **dest;
 169
 170         path = g_getenv ("MONO_PATH");
 171         if (!path)
 172                 return;
 173
 174         splitted = g_strsplit (path, G_SEARCHPATH_SEPARATOR_S, 1000);
 175         if (assemblies_path)
 176                 g_strfreev (assemblies_path);
 177         assemblies_path = dest = splitted;
 178         while (*splitted){
 179                 if (**splitted)
 180                         *dest++ = *splitted;
 181                 splitted++;
 182         }
 183         *dest = *splitted;
 184
 185         if (g_getenv ("MONO_DEBUG") == NULL)
 186                 return;
 187
 188         while (*splitted) {
 189                 if (**splitted && !g_file_test (*splitted, G_FILE_TEST_IS_DIR))
 190                         g_warning ("'%s' in MONO_PATH doesn't exist or has wrong permissions.", *splitted);
 191
 192                 splitted++;
 193         }
 194 }
 195
 196 static void
 197 check_extra_gac_path_env (void) {
 198         const char *path;
 199         char **splitted, **dest;
 200
 201         path = g_getenv ("MONO_GAC_PREFIX");
 202         if (!path)
 203                 return;
 204
 205         splitted = g_strsplit (path, G_SEARCHPATH_SEPARATOR_S, 1000);
 206         if (extra_gac_paths)
 207                 g_strfreev (extra_gac_paths);
 208         extra_gac_paths = dest = splitted;
 209         while (*splitted){
 210                 if (**splitted)
 211                         *dest++ = *splitted;
 212                 splitted++;
 213         }
 214         *dest = *splitted;
 215
 216         if (g_getenv ("MONO_DEBUG") == NULL)
 217                 return;
 218
 219         while (*splitted) {
 220                 if (**splitted && !g_file_test (*splitted, G_FILE_TEST_IS_DIR))
 221                         g_warning ("'%s' in MONO_GAC_PATH doesn't exist or has wrong permissions.", *splitted);
 222
 223                 splitted++;
 224         }
 225 }
 226
 227 static gboolean
 228 assembly_binding_maps_name (MonoAssemblyBindingInfo *info, MonoAssemblyName *aname)
 229 {
 230         if (strcmp (info->name, aname->name))
 231                 return FALSE;
 232
 233         if (info->major != aname->major || info->minor != aname->minor)
 234                 return FALSE;
 235
 236         if ((info->culture != NULL) != (aname->culture != NULL))
 237                 return FALSE;
 238
 239         if (info->culture && strcmp (info->culture, aname->culture))
 240                 return FALSE;
 241
 242         if (!mono_public_tokens_are_equal (info->public_key_token, aname->public_key_token))
 243                 return FALSE;
 244
 245         return TRUE;
 246 }
 247
 248 static void
 249 mono_assembly_binding_info_free (MonoAssemblyBindingInfo *info)
 250 {
 251         g_free (info->name);
 252         g_free (info->culture);
 253 }
 254
 255 static void
 256 get_publisher_policy_info (MonoImage *image, MonoAssemblyName *aname, MonoAssemblyBindingInfo *binding_info)
 257 {
 258         MonoTableInfo *t;
 259         guint32 cols [MONO_MANIFEST_SIZE];
 260         const gchar *filename;
 261         gchar *subpath, *fullpath;
 262
 263         t = &image->tables [MONO_TABLE_MANIFESTRESOURCE];
 264         /* MS Impl. accepts policy assemblies with more than
 265          * one manifest resource, and only takes the first one */
 266         if (t->rows < 1) {
 267                 binding_info->is_valid = FALSE;
 268                 return;
 269         }
 270
 271         mono_metadata_decode_row (t, 0, cols, MONO_MANIFEST_SIZE);
 272         if ((cols [MONO_MANIFEST_IMPLEMENTATION] & MONO_IMPLEMENTATION_MASK) != MONO_IMPLEMENTATION_FILE) {
 273                 binding_info->is_valid = FALSE;
 274                 return;
 275         }
 276
 277         filename = mono_metadata_string_heap (image, cols [MONO_MANIFEST_NAME]);
 278         g_assert (filename != NULL);
 279
 280         subpath = g_path_get_dirname (image->name);
 281         fullpath = g_build_path (G_DIR_SEPARATOR_S, subpath, filename, NULL);
 282         mono_config_parse_publisher_policy (fullpath, binding_info);
 283         g_free (subpath);
 284         g_free (fullpath);
 285
 286         /* Define the optional elements/attributes before checking */
 287         if (!binding_info->culture)
 288                 binding_info->culture = g_strdup ("");
 289
 290         /* Check that the most important elements/attributes exist */
 291         if (!binding_info->name || !binding_info->public_key_token [0] || !binding_info->has_old_version_bottom ||
 292                         !binding_info->has_new_version || !assembly_binding_maps_name (binding_info, aname)) {
 293                 mono_assembly_binding_info_free (binding_info);
 294                 binding_info->is_valid = FALSE;
 295                 return;
 296         }
 297
 298         binding_info->is_valid = TRUE;
 299 }
 300
 301 static int
 302 compare_versions (AssemblyVersionSet *v, MonoAssemblyName *aname)
 303 {
 304         if (v->major > aname->major)
 305                 return 1;
 306         else if (v->major < aname->major)
 307                 return -1;
 308
 309         if (v->minor > aname->minor)
 310                 return 1;
 311         else if (v->minor < aname->minor)
 312                 return -1;
 313
 314         if (v->build > aname->build)
 315                 return 1;
 316         else if (v->build < aname->build)
 317                 return -1;
 318
 319         if (v->revision > aname->revision)
 320                 return 1;
 321         else if (v->revision < aname->revision)
 322                 return -1;
 323
 324         return 0;
 325 }
 326
 327 static gboolean
 328 check_policy_versions (MonoAssemblyBindingInfo *info, MonoAssemblyName *name)
 329 {
 330         if (!info->is_valid)
 331                 return FALSE;
 332
 333         /* If has_old_version_top doesn't exist, we don't have an interval */
 334         if (!info->has_old_version_top) {
 335                 if (compare_versions (&info->old_version_bottom, name) == 0)
 336                         return TRUE;
 337
 338                 return FALSE;
 339         }
 340
 341         /* Check that the version defined by name is valid for the interval */
 342         if (compare_versions (&info->old_version_top, name) < 0)
 343                 return FALSE;
 344
 345         /* We should be greater or equal than the small version */
 346         if (compare_versions (&info->old_version_bottom, name) > 0)
 347                 return FALSE;
 348
 349         return TRUE;
 350 }
 351
 352 /**
 353  * mono_assembly_names_equal:
 354  * @l: first assembly
 355  * @r: second assembly.
 356  *
 357  * Compares two MonoAssemblyNames and returns whether they are equal.
 358  *
 359  * This compares the names, the cultures, the release version and their
 360  * public tokens.
 361  *
 362  * Returns: TRUE if both assembly names are equal.
 363  */
 364 gboolean
 365 mono_assembly_names_equal (MonoAssemblyName *l, MonoAssemblyName *r)
 366 {
 367         if (!l->name || !r->name)
 368                 return FALSE;
 369
 370         if (strcmp (l->name, r->name))
 371                 return FALSE;
 372
 373         if (l->culture && r->culture && strcmp (l->culture, r->culture))
 374                 return FALSE;
 375
 376         if (l->major != r->major || l->minor != r->minor ||
 377                         l->build != r->build || l->revision != r->revision)
 378                 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)))
 379                         return FALSE;
 380
 381         if (!l->public_key_token [0] || !r->public_key_token [0])
 382                 return TRUE;
 383
 384         if (!mono_public_tokens_are_equal (l->public_key_token, r->public_key_token))
 385                 return FALSE;
 386
 387         return TRUE;
 388 }
 389
 390 static MonoAssembly *
 391 load_in_path (const char *basename, const char** search_path, MonoImageOpenStatus *status, MonoBoolean refonly)
 392 {
 393         int i;
 394         char *fullpath;
 395         MonoAssembly *result;
 396
 397         for (i = 0; search_path [i]; ++i) {
 398                 fullpath = g_build_filename (search_path [i], basename, NULL);
 399                 result = mono_assembly_open_full (fullpath, status, refonly);
 400                 g_free (fullpath);
 401                 if (result)
 402                         return result;
 403         }
 404         return NULL;
 405 }
 406
 407 /**
 408  * mono_assembly_setrootdir:
 409  * @root_dir: The pathname of the root directory where we will locate assemblies
 410  *
 411  * This routine sets the internal default root directory for looking up
 412  * assemblies.
 413  *
 414  * This is used by Windows installations to compute dynamically the
 415  * place where the Mono assemblies are located.
 416  *
 417  */
 418 void
 419 mono_assembly_setrootdir (const char *root_dir)
 420 {
 421         /*
 422          * Override the MONO_ASSEMBLIES directory configured at compile time.
 423          */
 424         /* Leak if called more than once */
 425         default_path [0] = g_strdup (root_dir);
 426 }
 427
 428 /**
 429  * mono_assembly_getrootdir:
 430  *
 431  * Obtains the root directory used for looking up assemblies.
 432  *
 433  * Returns: a string with the directory, this string should not be freed.
 434  */
 435 G_CONST_RETURN gchar *
 436 mono_assembly_getrootdir (void)
 437 {
 438         return default_path [0];
 439 }
 440
 441 /**
 442  * mono_set_dirs:
 443  * @assembly_dir: the base directory for assemblies
 444  * @config_dir: the base directory for configuration files
 445  *
 446  * This routine is used internally and by developers embedding
 447  * the runtime into their own applications.
 448  *
 449  * There are a number of cases to consider: Mono as a system-installed
 450  * package that is available on the location preconfigured or Mono in
 451  * a relocated location.
 452  *
 453  * If you are using a system-installed Mono, you can pass NULL
 454  * to both parameters.  If you are not, you should compute both
 455  * directory values and call this routine.
 456  *
 457  * The values for a given PREFIX are:
 458  *
 459  *    assembly_dir: PREFIX/lib
 460  *    config_dir:   PREFIX/etc
 461  *
 462  * Notice that embedders that use Mono in a relocated way must
 463  * compute the location at runtime, as they will be in control
 464  * of where Mono is installed.
 465  */
 466 void
 467 mono_set_dirs (const char *assembly_dir, const char *config_dir)
 468 {
 469 #if defined (MONO_ASSEMBLIES)
 470         if (assembly_dir == NULL)
 471                 assembly_dir = MONO_ASSEMBLIES;
 472 #endif
 473 #if defined (MONO_CFG_DIR)
 474         if (config_dir == NULL)
 475                 config_dir = MONO_CFG_DIR;
 476 #endif
 477         mono_assembly_setrootdir (assembly_dir);
 478         mono_set_config_dir (config_dir);
 479 }
 480
 481 #ifndef PLATFORM_WIN32
 482
 483 static char *
 484 compute_base (char *path)
 485 {
 486         char *p = rindex (path, '/');
 487         if (p == NULL)
 488                 return NULL;
 489
 490         /* Not a well known Mono executable, we are embedded, cant guess the base  */
 491         if (strcmp (p, "/mono") && strcmp (p, "/monodis") && strcmp (p, "/mint") && strcmp (p, "/monodiet"))
 492                 return NULL;
 493
 494         *p = 0;
 495         p = rindex (path, '/');
 496         if (p == NULL)
 497                 return NULL;
 498
 499         if (strcmp (p, "/bin") != 0)
 500                 return NULL;
 501         *p = 0;
 502         return path;
 503 }
 504
 505 static void
 506 fallback (void)
 507 {
 508         mono_set_dirs (MONO_ASSEMBLIES, MONO_CFG_DIR);
 509 }
 510
 511 static void
 512 set_dirs (char *exe)
 513 {
 514         char *base;
 515         char *config, *lib, *mono;
 516         struct stat buf;
 517
 518         /*
 519          * Only /usr prefix is treated specially
 520          */
 521         if (strncmp (exe, MONO_BINDIR, strlen (MONO_BINDIR)) == 0 || (base = compute_base (exe)) == NULL){
 522                 fallback ();
 523                 return;
 524         }
 525
 526         config = g_build_filename (base, "etc", NULL);
 527         lib = g_build_filename (base, "lib", NULL);
 528         mono = g_build_filename (lib, "mono/1.0", NULL);
 529         if (stat (mono, &buf) == -1)
 530                 fallback ();
 531         else {
 532                 mono_set_dirs (lib, config);
 533         }
 534
 535         g_free (config);
 536         g_free (lib);
 537         g_free (mono);
 538 }
 539
 540 #endif /* PLATFORM_WIN32 */
 541
 542 /**
 543  * mono_set_rootdir:
 544  *
 545  * Registers the root directory for the Mono runtime, for Linux and Solaris 10,
 546  * this auto-detects the prefix where Mono was installed.
 547  */
 548 void
 549 mono_set_rootdir (void)
 550 {
 551 #ifdef PLATFORM_WIN32
 552         gchar *bindir, *installdir, *root, *name, *config;
 553
 554         name = mono_get_module_file_name ((HMODULE) &__ImageBase);
 555         bindir = g_path_get_dirname (name);
 556         installdir = g_path_get_dirname (bindir);
 557         root = g_build_path (G_DIR_SEPARATOR_S, installdir, "lib", NULL);
 558
 559         config = g_build_filename (root, "..", "etc", NULL);
 560         mono_set_dirs (root, config);
 561
 562         g_free (config);
 563         g_free (root);
 564         g_free (installdir);
 565         g_free (bindir);
 566         g_free (name);
 567 #else
 568         char buf [4096];
 569         int  s;
 570         char *str;
 571
 572         /* Linux style */
 573         s = readlink ("/proc/self/exe", buf, sizeof (buf)-1);
 574
 575         if (s != -1){
 576                 buf [s] = 0;
 577                 set_dirs (buf);
 578                 return;
 579         }
 580
 581         /* Solaris 10 style */
 582         str = g_strdup_printf ("/proc/%d/path/a.out", getpid ());
 583         s = readlink (str, buf, sizeof (buf)-1);
 584         g_free (str);
 585         if (s != -1){
 586                 buf [s] = 0;
 587                 set_dirs (buf);
 588                 return;
 589         }
 590         fallback ();
 591 #endif
 592 }
 593
 594 /**
 595  * mono_assemblies_init:
 596  *
 597  *  Initialize global variables used by this module.
 598  */
 599 void
 600 mono_assemblies_init (void)
 601 {
 602         /*
 603          * Initialize our internal paths if we have not been initialized yet.
 604          * This happens when embedders use Mono.
 605          */
 606         if (mono_assembly_getrootdir () == NULL)
 607                 mono_set_rootdir ();
 608
 609         check_path_env ();
 610         check_extra_gac_path_env ();
 611
 612         InitializeCriticalSection (&assemblies_mutex);
 613 }
 614
 615 gboolean
 616 mono_assembly_fill_assembly_name (MonoImage *image, MonoAssemblyName *aname)
 617 {
 618         MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLY];
 619         guint32 cols [MONO_ASSEMBLY_SIZE];
 620
 621         if (!t->rows)
 622                 return FALSE;
 623
 624         mono_metadata_decode_row (t, 0, cols, MONO_ASSEMBLY_SIZE);
 625
 626         aname->hash_len = 0;
 627         aname->hash_value = NULL;
 628         aname->name = mono_metadata_string_heap (image, cols [MONO_ASSEMBLY_NAME]);
 629         aname->culture = mono_metadata_string_heap (image, cols [MONO_ASSEMBLY_CULTURE]);
 630         aname->flags = cols [MONO_ASSEMBLY_FLAGS];
 631         aname->major = cols [MONO_ASSEMBLY_MAJOR_VERSION];
 632         aname->minor = cols [MONO_ASSEMBLY_MINOR_VERSION];
 633         aname->build = cols [MONO_ASSEMBLY_BUILD_NUMBER];
 634         aname->revision = cols [MONO_ASSEMBLY_REV_NUMBER];
 635         aname->hash_alg = cols [MONO_ASSEMBLY_HASH_ALG];
 636         if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
 637                 guchar* token = g_malloc (8);
 638                 gchar* encoded;
 639                 const gchar* pkey;
 640                 int len;
 641
 642                 pkey = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
 643                 len = mono_metadata_decode_blob_size (pkey, &pkey);
 644                 aname->public_key = (guchar*)pkey;
 645
 646                 mono_digest_get_public_token (token, aname->public_key, len);
 647                 encoded = encode_public_tok (token, 8);
 648                 g_strlcpy ((char*)aname->public_key_token, encoded, MONO_PUBLIC_KEY_TOKEN_LENGTH);
 649
 650                 g_free (encoded);
 651                 g_free (token);
 652         }
 653         else {
 654                 aname->public_key = NULL;
 655                 memset (aname->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
 656         }
 657
 658         if (cols [MONO_ASSEMBLY_PUBLIC_KEY]) {
 659                 aname->public_key = (guchar*)mono_metadata_blob_heap (image, cols [MONO_ASSEMBLY_PUBLIC_KEY]);
 660         }
 661         else
 662                 aname->public_key = 0;
 663
 664         return TRUE;
 665 }
 666
 667 /**
 668  * mono_stringify_assembly_name:
 669  * @aname: the assembly name.
 670  *
 671  * Convert @aname into its string format. The returned string is dynamically
 672  * allocated and should be freed by the caller.
 673  *
 674  * Returns: a newly allocated string with a string representation of
 675  * the assembly name.
 676  */
 677 char*
 678 mono_stringify_assembly_name (MonoAssemblyName *aname)
 679 {
 680         return g_strdup_printf (
 681                 "%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s",
 682                 aname->name,
 683                 aname->major, aname->minor, aname->build, aname->revision,
 684                 aname->culture && *aname->culture? aname->culture: "neutral",
 685                 aname->public_key_token [0] ? (char *)aname->public_key_token : "null",
 686                 (aname->flags & ASSEMBLYREF_RETARGETABLE_FLAG) ? ", Retargetable=Yes" : "");
 687 }
 688
 689 static gchar*
 690 assemblyref_public_tok (MonoImage *image, guint32 key_index, guint32 flags)
 691 {
 692         const gchar *public_tok;
 693         int len;
 694
 695         public_tok = mono_metadata_blob_heap (image, key_index);
 696         len = mono_metadata_decode_blob_size (public_tok, &public_tok);
 697
 698         if (flags & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG) {
 699                 guchar token [8];
 700                 mono_digest_get_public_token (token, (guchar*)public_tok, len);
 701                 return encode_public_tok (token, 8);
 702         }
 703
 704         return encode_public_tok ((guchar*)public_tok, len);
 705 }
 706
 707 /**
 708  * mono_assembly_addref:
 709  * @assemnly: the assembly to reference
 710  *
 711  * This routine increments the reference count on a MonoAssembly.
 712  * The reference count is reduced every time the method mono_assembly_close() is
 713  * invoked.
 714  */
 715 void
 716 mono_assembly_addref (MonoAssembly *assembly)
 717 {
 718         InterlockedIncrement (&assembly->ref_count);
 719 }
 720
 721 static MonoAssemblyName *
 722 mono_assembly_remap_version (MonoAssemblyName *aname, MonoAssemblyName *dest_aname)
 723 {
 724         const MonoRuntimeInfo *current_runtime;
 725         int pos, first, last;
 726
 727         if (aname->name == NULL) return aname;
 728         current_runtime = mono_get_runtime_info ();
 729
 730         first = 0;
 731         last = G_N_ELEMENTS (framework_assemblies) - 1;
 732
 733         while (first <= last) {
 734                 int res;
 735                 pos = first + (last - first) / 2;
 736                 res = strcmp (aname->name, framework_assemblies[pos].assembly_name);
 737                 if (res == 0) {
 738                         const AssemblyVersionSet* vset;
 739                         int index = framework_assemblies[pos].version_set_index;
 740                         g_assert (index < G_N_ELEMENTS (current_runtime->version_sets));
 741                         vset = &current_runtime->version_sets [index];
 742
 743                         if (aname->major == vset->major && aname->minor == vset->minor &&
 744                                 aname->build == vset->build && aname->revision == vset->revision)
 745                                 return aname;
 746
 747                         if ((aname->major | aname->minor | aname->build | aname->revision) != 0)
 748                                 mono_trace (G_LOG_LEVEL_WARNING, MONO_TRACE_ASSEMBLY,
 749                                         "The request to load the assembly %s v%d.%d.%d.%d was remapped to v%d.%d.%d.%d",
 750                                                         aname->name,
 751                                                         aname->major, aname->minor, aname->build, aname->revision,
 752                                                         vset->major, vset->minor, vset->build, vset->revision
 753                                                         );
 754
 755                         memcpy (dest_aname, aname, sizeof(MonoAssemblyName));
 756                         dest_aname->major = vset->major;
 757                         dest_aname->minor = vset->minor;
 758                         dest_aname->build = vset->build;
 759                         dest_aname->revision = vset->revision;
 760                         return dest_aname;
 761                 } else if (res < 0) {
 762                         last = pos - 1;
 763                 } else {
 764                         first = pos + 1;
 765                 }
 766         }
 767         return aname;
 768 }
 769
 770 /*
 771  * mono_assembly_get_assemblyref:
 772  *
 773  *   Fill out ANAME with the assembly name of the INDEXth assembly reference in IMAGE.
 774  */
 775 void
 776 mono_assembly_get_assemblyref (MonoImage *image, int index, MonoAssemblyName *aname)
 777 {
 778         MonoTableInfo *t;
 779         guint32 cols [MONO_ASSEMBLYREF_SIZE];
 780         const char *hash;
 781
 782         t = &image->tables [MONO_TABLE_ASSEMBLYREF];
 783
 784         mono_metadata_decode_row (t, index, cols, MONO_ASSEMBLYREF_SIZE);
 785
 786         hash = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLYREF_HASH_VALUE]);
 787         aname->hash_len = mono_metadata_decode_blob_size (hash, &hash);
 788         aname->hash_value = hash;
 789         aname->name = mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME]);
 790         aname->culture = mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE]);
 791         aname->flags = cols [MONO_ASSEMBLYREF_FLAGS];
 792         aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION];
 793         aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION];
 794         aname->build = cols [MONO_ASSEMBLYREF_BUILD_NUMBER];
 795         aname->revision = cols [MONO_ASSEMBLYREF_REV_NUMBER];
 796
 797         if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) {
 798                 gchar *token = assemblyref_public_tok (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY], aname->flags);
 799                 g_strlcpy ((char*)aname->public_key_token, token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
 800                 g_free (token);
 801         } else {
 802                 memset (aname->public_key_token, 0, MONO_PUBLIC_KEY_TOKEN_LENGTH);
 803         }
 804 }
 805
 806 void
 807 mono_assembly_load_reference (MonoImage *image, int index)
 808 {
 809         MonoAssembly *reference;
 810         MonoAssemblyName aname;
 811         MonoImageOpenStatus status;
 812
 813         /*
 814          * image->references is shared between threads, so we need to access
 815          * it inside a critical section.
 816          */
 817         mono_assemblies_lock ();
 818         if (!image->references) {
 819                 MonoTableInfo *t = &image->tables [MONO_TABLE_ASSEMBLYREF];
 820
 821                 image->references = g_new0 (MonoAssembly *, t->rows + 1);
 822         }
 823         reference = image->references [index];
 824         mono_assemblies_unlock ();
 825         if (reference)
 826                 return;
 827
 828         mono_assembly_get_assemblyref (image, index, &aname);
 829
 830         if (image->assembly && image->assembly->ref_only) {
 831                 /* We use the loaded corlib */
 832                 if (!strcmp (aname.name, "mscorlib"))
 833                         reference = mono_assembly_load_full (&aname, image->assembly->basedir, &status, FALSE);
 834                 else {
 835                         reference = mono_assembly_loaded_full (&aname, TRUE);
 836                         if (!reference)
 837                                 /* Try a postload search hook */
 838                                 reference = mono_assembly_invoke_search_hook_internal (&aname, TRUE, TRUE);
 839                 }
 840
 841                 /*
 842                  * Here we must advice that the error was due to
 843                  * a non loaded reference using the ReflectionOnly api
 844                 */
 845                 if (!reference)
 846                         reference = REFERENCE_MISSING;
 847         } else
 848                 reference = mono_assembly_load (&aname, image->assembly? image->assembly->basedir: NULL, &status);
 849
 850         if (reference == NULL){
 851                 char *extra_msg = g_strdup ("");
 852
 853                 if (status == MONO_IMAGE_ERROR_ERRNO && errno == ENOENT) {
 854                         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 != NULL ? image->assembly->basedir : "" );
 855                 } else if (status == MONO_IMAGE_ERROR_ERRNO) {
 856                         extra_msg = g_strdup_printf ("System error: %s\n", strerror (errno));
 857                 } else if (status == MONO_IMAGE_MISSING_ASSEMBLYREF) {
 858                         extra_msg = g_strdup ("Cannot find an assembly referenced from this one.\n");
 859                 } else if (status == MONO_IMAGE_IMAGE_INVALID) {
 860                         extra_msg = g_strdup ("The file exists but is not a valid assembly.\n");
 861                 }
 862
 863                 g_warning ("The following assembly referenced from %s could not be loaded:\n"
 864                                    "     Assembly:   %s    (assemblyref_index=%d)\n"
 865                                    "     Version:    %d.%d.%d.%d\n"
 866                                    "     Public Key: %s\n%s",
 867                                    image->name, aname.name, index,
 868                                    aname.major, aname.minor, aname.build, aname.revision,
 869                                    strlen ((char*)aname.public_key_token) == 0 ? "(none)" : (char*)aname.public_key_token, extra_msg);
 870                 g_free (extra_msg);
 871         }
 872
 873         mono_assemblies_lock ();
 874         if (reference == NULL) {
 875                 /* Flag as not found */
 876                 reference = REFERENCE_MISSING;
 877         }
 878
 879         if (!image->references [index]) {
 880                 if (reference != REFERENCE_MISSING){
 881                         mono_assembly_addref (reference);
 882                         if (image->assembly)
 883                                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Assembly Ref addref %s %p -> %s %p: %d\n",
 884                                     image->assembly->aname.name, image->assembly, reference->aname.name, reference, reference->ref_count);
 885                 } else {
 886                         if (image->assembly)
 887                                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Failed to load assembly %s %p\n",
 888                                     image->assembly->aname.name, image->assembly);
 889                 }
 890
 891                 image->references [index] = reference;
 892         }
 893         mono_assemblies_unlock ();
 894
 895         if (image->references [index] != reference) {
 896                 /* Somebody loaded it before us */
 897                 mono_assembly_close (reference);
 898         }
 899 }
 900
 901 void
 902 mono_assembly_load_references (MonoImage *image, MonoImageOpenStatus *status)
 903 {
 904         /* This is a no-op now but it is part of the embedding API so we can't remove it */
 905         *status = MONO_IMAGE_OK;
 906 }
 907
 908 typedef struct AssemblyLoadHook AssemblyLoadHook;
 909 struct AssemblyLoadHook {
 910         AssemblyLoadHook *next;
 911         MonoAssemblyLoadFunc func;
 912         gpointer user_data;
 913 };
 914
 915 AssemblyLoadHook *assembly_load_hook = NULL;
 916
 917 void
 918 mono_assembly_invoke_load_hook (MonoAssembly *ass)
 919 {
 920         AssemblyLoadHook *hook;
 921
 922         for (hook = assembly_load_hook; hook; hook = hook->next) {
 923                 hook->func (ass, hook->user_data);
 924         }
 925 }
 926
 927 void
 928 mono_install_assembly_load_hook (MonoAssemblyLoadFunc func, gpointer user_data)
 929 {
 930         AssemblyLoadHook *hook;
 931
 932         g_return_if_fail (func != NULL);
 933
 934         hook = g_new0 (AssemblyLoadHook, 1);
 935         hook->func = func;
 936         hook->user_data = user_data;
 937         hook->next = assembly_load_hook;
 938         assembly_load_hook = hook;
 939 }
 940
 941 static void
 942 free_assembly_load_hooks (void)
 943 {
 944         AssemblyLoadHook *hook, *next;
 945
 946         for (hook = assembly_load_hook; hook; hook = next) {
 947                 next = hook->next;
 948                 g_free (hook);
 949         }
 950 }
 951
 952 typedef struct AssemblySearchHook AssemblySearchHook;
 953 struct AssemblySearchHook {
 954         AssemblySearchHook *next;
 955         MonoAssemblySearchFunc func;
 956         gboolean refonly;
 957         gboolean postload;
 958         gpointer user_data;
 959 };
 960
 961 AssemblySearchHook *assembly_search_hook = NULL;
 962
 963 static MonoAssembly*
 964 mono_assembly_invoke_search_hook_internal (MonoAssemblyName *aname, gboolean refonly, gboolean postload)
 965 {
 966         AssemblySearchHook *hook;
 967
 968         for (hook = assembly_search_hook; hook; hook = hook->next) {
 969                 if ((hook->refonly == refonly) && (hook->postload == postload)) {
 970                         MonoAssembly *ass = hook->func (aname, hook->user_data);
 971                         if (ass)
 972                                 return ass;
 973                 }
 974         }
 975
 976         return NULL;
 977 }
 978
 979 MonoAssembly*
 980 mono_assembly_invoke_search_hook (MonoAssemblyName *aname)
 981 {
 982         return mono_assembly_invoke_search_hook_internal (aname, FALSE, FALSE);
 983 }
 984
 985 static void
 986 mono_install_assembly_search_hook_internal (MonoAssemblySearchFunc func, gpointer user_data, gboolean refonly, gboolean postload)
 987 {
 988         AssemblySearchHook *hook;
 989
 990         g_return_if_fail (func != NULL);
 991
 992         hook = g_new0 (AssemblySearchHook, 1);
 993         hook->func = func;
 994         hook->user_data = user_data;
 995         hook->refonly = refonly;
 996         hook->postload = postload;
 997         hook->next = assembly_search_hook;
 998         assembly_search_hook = hook;
 999 }
1000
1001 void
1002 mono_install_assembly_search_hook (MonoAssemblySearchFunc func, gpointer user_data)
1003 {
1004         mono_install_assembly_search_hook_internal (func, user_data, FALSE, FALSE);
1005 }
1006
1007 static void
1008 free_assembly_search_hooks (void)
1009 {
1010         AssemblySearchHook *hook, *next;
1011
1012         for (hook = assembly_search_hook; hook; hook = next) {
1013                 next = hook->next;
1014                 g_free (hook);
1015         }
1016 }
1017
1018 void
1019 mono_install_assembly_refonly_search_hook (MonoAssemblySearchFunc func, gpointer user_data)
1020 {
1021         mono_install_assembly_search_hook_internal (func, user_data, TRUE, FALSE);
1022 }
1023
1024 void
1025 mono_install_assembly_postload_search_hook (MonoAssemblySearchFunc func, gpointer user_data)
1026 {
1027         mono_install_assembly_search_hook_internal (func, user_data, FALSE, TRUE);
1028 }
1029
1030 void
1031 mono_install_assembly_postload_refonly_search_hook (MonoAssemblySearchFunc func, gpointer user_data)
1032 {
1033         mono_install_assembly_search_hook_internal (func, user_data, TRUE, TRUE);
1034 }
1035
1036 typedef struct AssemblyPreLoadHook AssemblyPreLoadHook;
1037 struct AssemblyPreLoadHook {
1038         AssemblyPreLoadHook *next;
1039         MonoAssemblyPreLoadFunc func;
1040         gpointer user_data;
1041 };
1042
1043 static AssemblyPreLoadHook *assembly_preload_hook = NULL;
1044 static AssemblyPreLoadHook *assembly_refonly_preload_hook = NULL;
1045
1046 static MonoAssembly *
1047 invoke_assembly_preload_hook (MonoAssemblyName *aname, gchar **assemblies_path)
1048 {
1049         AssemblyPreLoadHook *hook;
1050         MonoAssembly *assembly;
1051
1052         for (hook = assembly_preload_hook; hook; hook = hook->next) {
1053                 assembly = hook->func (aname, assemblies_path, hook->user_data);
1054                 if (assembly != NULL)
1055                         return assembly;
1056         }
1057
1058         return NULL;
1059 }
1060
1061 static MonoAssembly *
1062 invoke_assembly_refonly_preload_hook (MonoAssemblyName *aname, gchar **assemblies_path)
1063 {
1064         AssemblyPreLoadHook *hook;
1065         MonoAssembly *assembly;
1066
1067         for (hook = assembly_refonly_preload_hook; hook; hook = hook->next) {
1068                 assembly = hook->func (aname, assemblies_path, hook->user_data);
1069                 if (assembly != NULL)
1070                         return assembly;
1071         }
1072
1073         return NULL;
1074 }
1075
1076 void
1077 mono_install_assembly_preload_hook (MonoAssemblyPreLoadFunc func, gpointer user_data)
1078 {
1079         AssemblyPreLoadHook *hook;
1080
1081         g_return_if_fail (func != NULL);
1082
1083         hook = g_new0 (AssemblyPreLoadHook, 1);
1084         hook->func = func;
1085         hook->user_data = user_data;
1086         hook->next = assembly_preload_hook;
1087         assembly_preload_hook = hook;
1088 }
1089
1090 void
1091 mono_install_assembly_refonly_preload_hook (MonoAssemblyPreLoadFunc func, gpointer user_data)
1092 {
1093         AssemblyPreLoadHook *hook;
1094
1095         g_return_if_fail (func != NULL);
1096
1097         hook = g_new0 (AssemblyPreLoadHook, 1);
1098         hook->func = func;
1099         hook->user_data = user_data;
1100         hook->next = assembly_refonly_preload_hook;
1101         assembly_refonly_preload_hook = hook;
1102 }
1103
1104 static void
1105 free_assembly_preload_hooks (void)
1106 {
1107         AssemblyPreLoadHook *hook, *next;
1108
1109         for (hook = assembly_preload_hook; hook; hook = next) {
1110                 next = hook->next;
1111                 g_free (hook);
1112         }
1113
1114         for (hook = assembly_refonly_preload_hook; hook; hook = next) {
1115                 next = hook->next;
1116                 g_free (hook);
1117         }
1118 }
1119
1120 static gchar *
1121 absolute_dir (const gchar *filename)
1122 {
1123         gchar *cwd;
1124         gchar *mixed;
1125         gchar **parts;
1126         gchar *part;
1127         GList *list, *tmp;
1128         GString *result;
1129         gchar *res;
1130         gint i;
1131
1132         if (g_path_is_absolute (filename))
1133                 return g_path_get_dirname (filename);
1134
1135         cwd = g_get_current_dir ();
1136         mixed = g_build_filename (cwd, filename, NULL);
1137         parts = g_strsplit (mixed, G_DIR_SEPARATOR_S, 0);
1138         g_free (mixed);
1139         g_free (cwd);
1140
1141         list = NULL;
1142         for (i = 0; (part = parts [i]) != NULL; i++) {
1143                 if (!strcmp (part, "."))
1144                         continue;
1145
1146                 if (!strcmp (part, "..")) {
1147                         if (list && list->next) /* Don't remove root */
1148                                 list = g_list_delete_link (list, list);
1149                 } else {
1150                         list = g_list_prepend (list, part);
1151                 }
1152         }
1153
1154         result = g_string_new ("");
1155         list = g_list_reverse (list);
1156
1157         /* Ignores last data pointer, which should be the filename */
1158         for (tmp = list; tmp && tmp->next != NULL; tmp = tmp->next){
1159                 if (tmp->data)
1160                         g_string_append_printf (result, "%s%c", (char *) tmp->data,
1161                                                                 G_DIR_SEPARATOR);
1162         }
1163
1164         res = result->str;
1165         g_string_free (result, FALSE);
1166         g_list_free (list);
1167         g_strfreev (parts);
1168         if (*res == '\0') {
1169                 g_free (res);
1170                 return g_strdup (".");
1171         }
1172
1173         return res;
1174 }
1175
1176 /**
1177  * mono_assembly_open_from_bundle:
1178  * @filename: Filename requested
1179  * @status: return value
1180  *
1181  * This routine tries to open the assembly specified by `filename' from the
1182  * defined bundles, if found, returns the MonoImage for it, if not found
1183  * returns NULL
1184  */
1185 MonoImage *
1186 mono_assembly_open_from_bundle (const char *filename, MonoImageOpenStatus *status, gboolean refonly)
1187 {
1188         int i;
1189         char *name;
1190         MonoImage *image = NULL;
1191
1192         /*
1193          * we do a very simple search for bundled assemblies: it's not a general
1194          * purpose assembly loading mechanism.
1195          */
1196
1197         if (!bundles)
1198                 return NULL;
1199
1200         name = g_path_get_basename (filename);
1201
1202         mono_assemblies_lock ();
1203         for (i = 0; !image && bundles [i]; ++i) {
1204                 if (strcmp (bundles [i]->name, name) == 0) {
1205                         image = mono_image_open_from_data_full ((char*)bundles [i]->data, bundles [i]->size, FALSE, status, refonly);
1206                         break;
1207                 }
1208         }
1209         mono_assemblies_unlock ();
1210         g_free (name);
1211         if (image) {
1212                 mono_image_addref (image);
1213                 return image;
1214         }
1215         return NULL;
1216 }
1217
1218 MonoAssembly *
1219 mono_assembly_open_full (const char *filename, MonoImageOpenStatus *status, gboolean refonly)
1220 {
1221         MonoImage *image;
1222         MonoAssembly *ass;
1223         MonoImageOpenStatus def_status;
1224         gchar *fname;
1225         gchar *new_fname;
1226
1227         g_return_val_if_fail (filename != NULL, NULL);
1228
1229         if (!status)
1230                 status = &def_status;
1231         *status = MONO_IMAGE_OK;
1232
1233         if (strncmp (filename, "file://", 7) == 0) {
1234                 GError *error = NULL;
1235                 gchar *uri = (gchar *) filename;
1236                 gchar *tmpuri;
1237
1238                 /*
1239                  * MS allows file://c:/... and fails on file://localhost/c:/...
1240                  * They also throw an IndexOutOfRangeException if "file://"
1241                  */
1242                 if (uri [7] != '/')
1243                         uri = g_strdup_printf ("file:///%s", uri + 7);
1244
1245                 tmpuri = uri;
1246                 uri = mono_escape_uri_string (tmpuri);
1247                 fname = g_filename_from_uri (uri, NULL, &error);
1248                 g_free (uri);
1249
1250                 if (tmpuri != filename)
1251                         g_free (tmpuri);
1252
1253                 if (error != NULL) {
1254                         g_warning ("%s\n", error->message);
1255                         g_error_free (error);
1256                         fname = g_strdup (filename);
1257                 }
1258         } else {
1259                 fname = g_strdup (filename);
1260         }
1261
1262         mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY,
1263                         "Assembly Loader probing location: '%s'.", fname);
1264         new_fname = mono_make_shadow_copy (fname);
1265         if (new_fname && new_fname != fname) {
1266                 g_free (fname);
1267                 fname = new_fname;
1268                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY,
1269                             "Assembly Loader shadow-copied assembly to: '%s'.", fname);
1270         }
1271
1272         image = NULL;
1273
1274         if (bundles != NULL)
1275                 image = mono_assembly_open_from_bundle (fname, status, refonly);
1276
1277         if (!image) {
1278                 mono_assemblies_lock ();
1279                 image = mono_image_open_full (fname, status, refonly);
1280                 mono_assemblies_unlock ();
1281         }
1282
1283         if (!image){
1284                 if (*status == MONO_IMAGE_OK)
1285                         *status = MONO_IMAGE_ERROR_ERRNO;
1286                 g_free (fname);
1287                 return NULL;
1288         }
1289
1290         if (image->assembly) {
1291                 /* Already loaded by another appdomain */
1292                 mono_assembly_invoke_load_hook (image->assembly);
1293                 mono_image_close (image);
1294                 g_free (fname);
1295                 return image->assembly;
1296         }
1297
1298         ass = mono_assembly_load_from_full (image, fname, status, refonly);
1299
1300         if (ass) {
1301                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY,
1302                                 "Assembly Loader loaded assembly from location: '%s'.", filename);
1303                 if (!refonly)
1304                         mono_config_for_assembly (ass->image);
1305         }
1306
1307         /* Clear the reference added by mono_image_open */
1308         mono_image_close (image);
1309
1310         g_free (fname);
1311
1312         return ass;
1313 }
1314
1315 /*
1316  * mono_load_friend_assemblies:
1317  * @ass: an assembly
1318  *
1319  * Load the list of friend assemblies that are allowed to access
1320  * the assembly's internal types and members. They are stored as assembly
1321  * names in custom attributes.
1322  *
1323  * This is an internal method, we need this because when we load mscorlib
1324  * we do not have the mono_defaults.internals_visible_class loaded yet,
1325  * so we need to load these after we initialize the runtime.
1326  *
1327  * LOCKING: Acquires the assemblies lock plus the loader lock.
1328  */
1329 void
1330 mono_assembly_load_friends (MonoAssembly* ass)
1331 {
1332         int i;
1333         MonoCustomAttrInfo* attrs = mono_custom_attrs_from_assembly (ass);
1334         if (!attrs)
1335                 return;
1336         for (i = 0; i < attrs->num_attrs; ++i) {
1337                 MonoCustomAttrEntry *attr = &attrs->attrs [i];
1338                 MonoAssemblyName *aname;
1339                 const gchar *data;
1340                 guint slen;
1341                 /* Do some sanity checking */
1342                 if (!attr->ctor || attr->ctor->klass != mono_defaults.internals_visible_class)
1343                         continue;
1344                 if (attr->data_size < 4)
1345                         continue;
1346                 data = (const char*)attr->data;
1347                 /* 0xFF means null string, see custom attr format */
1348                 if (data [0] != 1 || data [1] != 0 || (data [2] & 0xFF) == 0xFF)
1349                         continue;
1350                 slen = mono_metadata_decode_value (data + 2, &data);
1351                 aname = g_new0 (MonoAssemblyName, 1);
1352                 /*g_print ("friend ass: %s\n", data);*/
1353                 if (mono_assembly_name_parse_full (data, aname, TRUE, NULL, NULL)) {
1354                         mono_assemblies_lock ();
1355                         ass->friend_assembly_names = g_slist_prepend (ass->friend_assembly_names, aname);
1356                         mono_assemblies_unlock ();
1357                 } else {
1358                         g_free (aname);
1359                 }
1360         }
1361         mono_custom_attrs_free (attrs);
1362 }
1363
1364 /**
1365  * mono_assembly_open:
1366  * @filename: Opens the assembly pointed out by this name
1367  * @status: where a status code can be returned
1368  *
1369  * mono_assembly_open opens the PE-image pointed by @filename, and
1370  * loads any external assemblies referenced by it.
1371  *
1372  * Return: a pointer to the MonoAssembly if @filename contains a valid
1373  * assembly or NULL on error.  Details about the error are stored in the
1374  * @status variable.
1375  */
1376 MonoAssembly *
1377 mono_assembly_open (const char *filename, MonoImageOpenStatus *status)
1378 {
1379         return mono_assembly_open_full (filename, status, FALSE);
1380 }
1381
1382 MonoAssembly *
1383 mono_assembly_load_from_full (MonoImage *image, const char*fname,
1384                               MonoImageOpenStatus *status, gboolean refonly)
1385 {
1386         MonoAssembly *ass, *ass2;
1387         char *base_dir;
1388
1389         if (!image->tables [MONO_TABLE_ASSEMBLY].rows) {
1390                 /* 'image' doesn't have a manifest -- maybe someone is trying to Assembly.Load a .netmodule */
1391                 *status = MONO_IMAGE_IMAGE_INVALID;
1392                 return NULL;
1393         }
1394
1395 #if defined (PLATFORM_WIN32)
1396         {
1397                 gchar *tmp_fn;
1398                 int i;
1399
1400                 tmp_fn = g_strdup (fname);
1401                 for (i = strlen (tmp_fn) - 1; i >= 0; i--) {
1402                         if (tmp_fn [i] == '/')
1403                                 tmp_fn [i] = '\\';
1404                 }
1405
1406                 base_dir = absolute_dir (tmp_fn);
1407                 g_free (tmp_fn);
1408         }
1409 #else
1410         base_dir = absolute_dir (fname);
1411 #endif
1412
1413         /*
1414          * Create assembly struct, and enter it into the assembly cache
1415          */
1416         ass = g_new0 (MonoAssembly, 1);
1417         ass->basedir = base_dir;
1418         ass->ref_only = refonly;
1419         ass->image = image;
1420
1421         mono_profiler_assembly_event (ass, MONO_PROFILE_START_LOAD);
1422
1423         mono_assembly_fill_assembly_name (image, &ass->aname);
1424
1425         if (mono_defaults.corlib && strcmp (ass->aname.name, "mscorlib") == 0) {
1426                 // MS.NET doesn't support loading other mscorlibs
1427                 g_free (ass);
1428                 g_free (base_dir);
1429                 mono_image_addref (mono_defaults.corlib);
1430                 *status = MONO_IMAGE_OK;
1431                 return mono_defaults.corlib->assembly;
1432         }
1433
1434         /* Add a non-temporary reference because of ass->image */
1435         mono_image_addref (image);
1436
1437         mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Image addref %s %p -> %s %p: %d\n", ass->aname.name, ass, image->name, image, image->ref_count);
1438
1439         /*
1440          * The load hooks might take locks so we can't call them while holding the
1441          * assemblies lock.
1442          */
1443         if (ass->aname.name) {
1444                 ass2 = mono_assembly_invoke_search_hook_internal (&ass->aname, refonly, FALSE);
1445                 if (ass2) {
1446                         g_free (ass);
1447                         g_free (base_dir);
1448                         mono_image_close (image);
1449                         *status = MONO_IMAGE_OK;
1450                         return ass2;
1451                 }
1452         }
1453
1454         mono_assemblies_lock ();
1455
1456         if (image->assembly) {
1457                 /*
1458                  * This means another thread has already loaded the assembly, but not yet
1459                  * called the load hooks so the search hook can't find the assembly.
1460                  */
1461                 mono_assemblies_unlock ();
1462                 ass2 = image->assembly;
1463                 g_free (ass);
1464                 g_free (base_dir);
1465                 mono_image_close (image);
1466                 *status = MONO_IMAGE_OK;
1467                 return ass2;
1468         }
1469
1470         image->assembly = ass;
1471
1472         loaded_assemblies = g_list_prepend (loaded_assemblies, ass);
1473         mono_assemblies_unlock ();
1474
1475         if (mono_defaults.internals_visible_class)
1476                 mono_assembly_load_friends (ass);
1477 #ifdef PLATFORM_WIN32
1478         if (image->is_module_handle)
1479                 mono_image_fixup_vtable (image);
1480 #endif
1481
1482         mono_assembly_invoke_load_hook (ass);
1483
1484         mono_profiler_assembly_loaded (ass, MONO_PROFILE_OK);
1485
1486         return ass;
1487 }
1488
1489 MonoAssembly *
1490 mono_assembly_load_from (MonoImage *image, const char *fname,
1491                          MonoImageOpenStatus *status)
1492 {
1493         return mono_assembly_load_from_full (image, fname, status, FALSE);
1494 }
1495
1496 /**
1497  * mono_assembly_name_free:
1498  * @aname: assembly name to free
1499  *
1500  * Frees the provided assembly name object.
1501  * (it does not frees the object itself, only the name members).
1502  */
1503 void
1504 mono_assembly_name_free (MonoAssemblyName *aname)
1505 {
1506         if (aname == NULL)
1507                 return;
1508
1509         g_free ((void *) aname->name);
1510         g_free ((void *) aname->culture);
1511         g_free ((void *) aname->hash_value);
1512 }
1513
1514 static gboolean
1515 parse_public_key (const gchar *key, gchar** pubkey)
1516 {
1517         const gchar *pkey;
1518         gchar header [16], val, *arr;
1519         gint i, j, offset, bitlen, keylen, pkeylen;
1520
1521         keylen = strlen (key) >> 1;
1522         if (keylen < 1)
1523                 return FALSE;
1524
1525         val = g_ascii_xdigit_value (key [0]) << 4;
1526         val |= g_ascii_xdigit_value (key [1]);
1527         switch (val) {
1528                 case 0x00:
1529                         if (keylen < 13)
1530                                 return FALSE;
1531                         val = g_ascii_xdigit_value (key [24]);
1532                         val |= g_ascii_xdigit_value (key [25]);
1533                         if (val != 0x06)
1534                                 return FALSE;
1535                         pkey = key + 24;
1536                         break;
1537                 case 0x06:
1538                         pkey = key;
1539                         break;
1540                 default:
1541                         return FALSE;
1542         }
1543
1544         /* We need the first 16 bytes
1545         * to check whether this key is valid or not */
1546         pkeylen = strlen (pkey) >> 1;
1547         if (pkeylen < 16)
1548                 return FALSE;
1549
1550         for (i = 0, j = 0; i < 16; i++) {
1551                 header [i] = g_ascii_xdigit_value (pkey [j++]) << 4;
1552                 header [i] |= g_ascii_xdigit_value (pkey [j++]);
1553         }
1554
1555         if (header [0] != 0x06 || /* PUBLICKEYBLOB (0x06) */
1556                         header [1] != 0x02 || /* Version (0x02) */
1557                         header [2] != 0x00 || /* Reserved (word) */
1558                         header [3] != 0x00 ||
1559                         (guint)(read32 (header + 8)) != 0x31415352) /* DWORD magic = RSA1 */
1560                 return FALSE;
1561
1562         /* Based on this length, we _should_ be able to know if the length is right */
1563         bitlen = read32 (header + 12) >> 3;
1564         if ((bitlen + 16 + 4) != pkeylen)
1565                 return FALSE;
1566
1567         /* Encode the size of the blob */
1568         offset = 0;
1569         if (keylen <= 127) {
1570                 arr = g_malloc (keylen + 1);
1571                 arr [offset++] = keylen;
1572         } else {
1573                 arr = g_malloc (keylen + 2);
1574                 arr [offset++] = 0x80; /* 10bs */
1575                 arr [offset++] = keylen;
1576         }
1577
1578         for (i = offset, j = 0; i < keylen + offset; i++) {
1579                 arr [i] = g_ascii_xdigit_value (key [j++]) << 4;
1580                 arr [i] |= g_ascii_xdigit_value (key [j++]);
1581         }
1582         if (pubkey)
1583                 *pubkey = arr;
1584
1585         return TRUE;
1586 }
1587
1588 static gboolean
1589 build_assembly_name (const char *name, const char *version, const char *culture, const char *token, const char *key, guint32 flags, MonoAssemblyName *aname, gboolean save_public_key)
1590 {
1591         gint major, minor, build, revision;
1592         gint len;
1593         gint version_parts;
1594         gchar *pkey, *pkeyptr, *encoded, tok [8];
1595
1596         memset (aname, 0, sizeof (MonoAssemblyName));
1597
1598         if (version) {
1599                 version_parts = sscanf (version, "%u.%u.%u.%u", &major, &minor, &build, &revision);
1600                 if (version_parts < 2 || version_parts > 4)
1601                         return FALSE;
1602
1603                 /* FIXME: we should set build & revision to -1 (instead of 0)
1604                 if these are not set in the version string. That way, later on,
1605                 we can still determine if these were specified. */
1606                 aname->major = major;
1607                 aname->minor = minor;
1608                 if (version_parts >= 3)
1609                         aname->build = build;
1610                 else
1611                         aname->build = 0;
1612                 if (version_parts == 4)
1613                         aname->revision = revision;
1614                 else
1615                         aname->revision = 0;
1616         }
1617
1618         aname->flags = flags;
1619         aname->name = g_strdup (name);
1620
1621         if (culture) {
1622                 if (g_ascii_strcasecmp (culture, "neutral") == 0)
1623                         aname->culture = g_strdup ("");
1624                 else
1625                         aname->culture = g_strdup (culture);
1626         }
1627
1628         if (token && strncmp (token, "null", 4) != 0) {
1629                 char *lower;
1630
1631                 /* the constant includes the ending NULL, hence the -1 */
1632                 if (strlen (token) != (MONO_PUBLIC_KEY_TOKEN_LENGTH - 1)) {
1633                         mono_assembly_name_free (aname);
1634                         return FALSE;
1635                 }
1636                 lower = g_ascii_strdown (token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
1637                 g_strlcpy ((char*)aname->public_key_token, lower, MONO_PUBLIC_KEY_TOKEN_LENGTH);
1638                 g_free (lower);
1639         }
1640
1641         if (key) {
1642                 if (strcmp (key, "null") == 0 || !parse_public_key (key, &pkey)) {
1643                         mono_assembly_name_free (aname);
1644                         return FALSE;
1645                 }
1646
1647                 len = mono_metadata_decode_blob_size ((const gchar *) pkey, (const gchar **) &pkeyptr);
1648                 // We also need to generate the key token
1649                 mono_digest_get_public_token ((guchar*) tok, (guint8*) pkeyptr, len);
1650                 encoded = encode_public_tok ((guchar*) tok, 8);
1651                 g_strlcpy ((gchar*)aname->public_key_token, encoded, MONO_PUBLIC_KEY_TOKEN_LENGTH);
1652                 g_free (encoded);
1653
1654                 if (save_public_key)
1655                         aname->public_key = (guint8*) pkey;
1656                 else
1657                         g_free (pkey);
1658         }
1659
1660         return TRUE;
1661 }
1662
1663 static gboolean
1664 parse_assembly_directory_name (const char *name, const char *dirname, MonoAssemblyName *aname)
1665 {
1666         gchar **parts;
1667         gboolean res;
1668
1669         parts = g_strsplit (dirname, "_", 3);
1670         if (!parts || !parts[0] || !parts[1] || !parts[2]) {
1671                 g_strfreev (parts);
1672                 return FALSE;
1673         }
1674
1675         res = build_assembly_name (name, parts[0], parts[1], parts[2], NULL, 0, aname, FALSE);
1676         g_strfreev (parts);
1677         return res;
1678 }
1679
1680 gboolean
1681 mono_assembly_name_parse_full (const char *name, MonoAssemblyName *aname, gboolean save_public_key, gboolean *is_version_defined, gboolean *is_token_defined)
1682 {
1683         gchar *dllname;
1684         gchar *version = NULL;
1685         gchar *culture = NULL;
1686         gchar *token = NULL;
1687         gchar *key = NULL;
1688         gchar *retargetable = NULL;
1689         gboolean res;
1690         gchar *value;
1691         gchar **parts;
1692         gchar **tmp;
1693         gboolean version_defined;
1694         gboolean token_defined;
1695         guint32 flags = 0;
1696
1697         if (!is_version_defined)
1698                 is_version_defined = &version_defined;
1699         *is_version_defined = FALSE;
1700         if (!is_token_defined)
1701                 is_token_defined = &token_defined;
1702         *is_token_defined = FALSE;
1703
1704         parts = tmp = g_strsplit (name, ",", 6);
1705         if (!tmp || !*tmp) {
1706                 g_strfreev (tmp);
1707                 return FALSE;
1708         }
1709
1710         dllname = g_strstrip (*tmp);
1711
1712         tmp++;
1713
1714         while (*tmp) {
1715                 value = g_strstrip (*tmp);
1716                 if (!g_ascii_strncasecmp (value, "Version=", 8)) {
1717                         *is_version_defined = TRUE;
1718                         version = g_strstrip (value + 8);
1719                         if (strlen (version) == 0) {
1720                                 goto cleanup_and_fail;
1721                         }
1722                         tmp++;
1723                         continue;
1724                 }
1725
1726                 if (!g_ascii_strncasecmp (value, "Culture=", 8)) {
1727                         culture = g_strstrip (value + 8);
1728                         if (strlen (culture) == 0) {
1729                                 goto cleanup_and_fail;
1730                         }
1731                         tmp++;
1732                         continue;
1733                 }
1734
1735                 if (!g_ascii_strncasecmp (value, "PublicKeyToken=", 15)) {
1736                         *is_token_defined = TRUE;
1737                         token = g_strstrip (value + 15);
1738                         if (strlen (token) == 0) {
1739                                 goto cleanup_and_fail;
1740                         }
1741                         tmp++;
1742                         continue;
1743                 }
1744
1745                 if (!g_ascii_strncasecmp (value, "PublicKey=", 10)) {
1746                         key = g_strstrip (value + 10);
1747                         if (strlen (key) == 0) {
1748                                 goto cleanup_and_fail;
1749                         }
1750                         tmp++;
1751                         continue;
1752                 }
1753
1754                 if (!g_ascii_strncasecmp (value, "Retargetable=", 13)) {
1755                         retargetable = g_strstrip (value + 13);
1756                         if (strlen (retargetable) == 0) {
1757                                 goto cleanup_and_fail;
1758                         }
1759                         if (!g_ascii_strcasecmp (retargetable, "yes")) {
1760                                 flags |= ASSEMBLYREF_RETARGETABLE_FLAG;
1761                         } else if (g_ascii_strcasecmp (retargetable, "no")) {
1762                                 goto cleanup_and_fail;
1763                         }
1764                         tmp++;
1765                         continue;
1766                 }
1767
1768                 if (!g_ascii_strncasecmp (value, "ProcessorArchitecture=", 22)) {
1769                         /* this is ignored for now, until we can change MonoAssemblyName */
1770                         tmp++;
1771                         continue;
1772                 }
1773
1774                 g_strfreev (parts);
1775                 return FALSE;
1776         }
1777
1778         /* if retargetable flag is set, then we must have a fully qualified name */
1779         if (retargetable != NULL && (version == NULL || culture == NULL || (key == NULL && token == NULL))) {
1780                 goto cleanup_and_fail;
1781         }
1782
1783         res = build_assembly_name (dllname, version, culture, token, key, flags,
1784                 aname, save_public_key);
1785         g_strfreev (parts);
1786         return res;
1787
1788 cleanup_and_fail:
1789         g_strfreev (parts);
1790         return FALSE;
1791 }
1792
1793 /**
1794  * mono_assembly_name_parse:
1795  * @name: name to parse
1796  * @aname: the destination assembly name
1797  *
1798  * Parses an assembly qualified type name and assigns the name,
1799  * version, culture and token to the provided assembly name object.
1800  *
1801  * Returns: true if the name could be parsed.
1802  */
1803 gboolean
1804 mono_assembly_name_parse (const char *name, MonoAssemblyName *aname)
1805 {
1806         return mono_assembly_name_parse_full (name, aname, FALSE, NULL, NULL);
1807 }
1808
1809 static MonoAssembly*
1810 probe_for_partial_name (const char *basepath, const char *fullname, MonoAssemblyName *aname, MonoImageOpenStatus *status)
1811 {
1812         gchar *fullpath = NULL;
1813         GDir *dirhandle;
1814         const char* direntry;
1815         MonoAssemblyName gac_aname;
1816         gint major=-1, minor=0, build=0, revision=0;
1817         gboolean exact_version;
1818
1819         dirhandle = g_dir_open (basepath, 0, NULL);
1820         if (!dirhandle)
1821                 return NULL;
1822
1823         exact_version = (aname->major | aname->minor | aname->build | aname->revision) != 0;
1824
1825         while ((direntry = g_dir_read_name (dirhandle))) {
1826                 gboolean match = TRUE;
1827
1828                 if(!parse_assembly_directory_name (aname->name, direntry, &gac_aname))
1829                         continue;
1830
1831                 if (aname->culture != NULL && strcmp (aname->culture, gac_aname.culture) != 0)
1832                         match = FALSE;
1833
1834                 if (match && strlen ((char*)aname->public_key_token) > 0 &&
1835                                 !mono_public_tokens_are_equal (aname->public_key_token, gac_aname.public_key_token))
1836                         match = FALSE;
1837
1838                 if (match) {
1839                         if (exact_version) {
1840                                 match = (aname->major == gac_aname.major && aname->minor == gac_aname.minor &&
1841                                                  aname->build == gac_aname.build && aname->revision == gac_aname.revision);
1842                         }
1843                         else if (gac_aname.major < major)
1844                                 match = FALSE;
1845                         else if (gac_aname.major == major) {
1846                                 if (gac_aname.minor < minor)
1847                                         match = FALSE;
1848                                 else if (gac_aname.minor == minor) {
1849                                         if (gac_aname.build < build)
1850                                                 match = FALSE;
1851                                         else if (gac_aname.build == build && gac_aname.revision <= revision)
1852                                                 match = FALSE;
1853                                 }
1854                         }
1855                 }
1856
1857                 if (match) {
1858                         major = gac_aname.major;
1859                         minor = gac_aname.minor;
1860                         build = gac_aname.build;
1861                         revision = gac_aname.revision;
1862                         g_free (fullpath);
1863                         fullpath = g_build_path (G_DIR_SEPARATOR_S, basepath, direntry, fullname, NULL);
1864                 }
1865
1866                 mono_assembly_name_free (&gac_aname);
1867         }
1868
1869         g_dir_close (dirhandle);
1870
1871         if (fullpath == NULL)
1872                 return NULL;
1873         else {
1874                 MonoAssembly *res = mono_assembly_open (fullpath, status);
1875                 g_free (fullpath);
1876                 return res;
1877         }
1878 }
1879
1880 MonoAssembly*
1881 mono_assembly_load_with_partial_name (const char *name, MonoImageOpenStatus *status)
1882 {
1883         MonoAssembly *res;
1884         MonoAssemblyName *aname, base_name, maped_aname;
1885         gchar *fullname, *gacpath;
1886         gchar **paths;
1887
1888         memset (&base_name, 0, sizeof (MonoAssemblyName));
1889         aname = &base_name;
1890
1891         if (!mono_assembly_name_parse (name, aname))
1892                 return NULL;
1893
1894         /*
1895          * If no specific version has been requested, make sure we load the
1896          * correct version for system assemblies.
1897          */
1898         if ((aname->major | aname->minor | aname->build | aname->revision) == 0)
1899                 aname = mono_assembly_remap_version (aname, &maped_aname);
1900
1901         res = mono_assembly_loaded (aname);
1902         if (res) {
1903                 mono_assembly_name_free (aname);
1904                 return res;
1905         }
1906
1907         res = invoke_assembly_preload_hook (aname, assemblies_path);
1908         if (res) {
1909                 res->in_gac = FALSE;
1910                 mono_assembly_name_free (aname);
1911                 return res;
1912         }
1913
1914         fullname = g_strdup_printf ("%s.dll", aname->name);
1915
1916         if (extra_gac_paths) {
1917                 paths = extra_gac_paths;
1918                 while (!res && *paths) {
1919                         gacpath = g_build_path (G_DIR_SEPARATOR_S, *paths, "lib", "mono", "gac", aname->name, NULL);
1920                         res = probe_for_partial_name (gacpath, fullname, aname, status);
1921                         g_free (gacpath);
1922                         paths++;
1923                 }
1924         }
1925
1926         if (res) {
1927                 res->in_gac = TRUE;
1928                 g_free (fullname);
1929                 mono_assembly_name_free (aname);
1930                 return res;
1931         }
1932
1933         gacpath = g_build_path (G_DIR_SEPARATOR_S, mono_assembly_getrootdir (), "mono", "gac", aname->name, NULL);
1934         res = probe_for_partial_name (gacpath, fullname, aname, status);
1935         g_free (gacpath);
1936
1937         if (res)
1938                 res->in_gac = TRUE;
1939         else {
1940                 MonoDomain *domain = mono_domain_get ();
1941                 MonoReflectionAssembly *refasm = mono_try_assembly_resolve (domain, mono_string_new (domain, name), FALSE);
1942                 if (refasm)
1943                         res = refasm->assembly;
1944         }
1945
1946         g_free (fullname);
1947         mono_assembly_name_free (aname);
1948
1949         return res;
1950 }
1951
1952 static MonoImage*
1953 mono_assembly_load_publisher_policy (MonoAssemblyName *aname)
1954 {
1955         MonoImage *image;
1956         gchar *filename, *pname, *name, *culture, *version, *fullpath, *subpath;
1957         gchar **paths;
1958         gint32 len;
1959
1960         if (strstr (aname->name, ".dll")) {
1961                 len = strlen (aname->name) - 4;
1962                 name = g_malloc (len);
1963                 strncpy (name, aname->name, len);
1964         } else
1965                 name = g_strdup (aname->name);
1966
1967         if (aname->culture) {
1968                 culture = g_strdup (aname->culture);
1969                 g_strdown (culture);
1970         } else
1971                 culture = g_strdup ("");
1972
1973         pname = g_strdup_printf ("policy.%d.%d.%s", aname->major, aname->minor, name);
1974         version = g_strdup_printf ("0.0.0.0_%s_%s", culture, aname->public_key_token);
1975         g_free (name);
1976         g_free (culture);
1977
1978         filename = g_strconcat (pname, ".dll", NULL);
1979         subpath = g_build_path (G_DIR_SEPARATOR_S, pname, version, filename, NULL);
1980         g_free (pname);
1981         g_free (version);
1982         g_free (filename);
1983
1984         image = NULL;
1985         if (extra_gac_paths) {
1986                 paths = extra_gac_paths;
1987                 while (!image && *paths) {
1988                         fullpath = g_build_path (G_DIR_SEPARATOR_S, *paths,
1989                                         "lib", "mono", "gac", subpath, NULL);
1990                         image = mono_image_open (fullpath, NULL);
1991                         g_free (fullpath);
1992                         paths++;
1993                 }
1994         }
1995
1996         if (image) {
1997                 g_free (subpath);
1998                 return image;
1999         }
2000
2001         fullpath = g_build_path (G_DIR_SEPARATOR_S, mono_assembly_getrootdir (),
2002                         "mono", "gac", subpath, NULL);
2003         image = mono_image_open (fullpath, NULL);
2004         g_free (subpath);
2005         g_free (fullpath);
2006
2007         return image;
2008 }
2009
2010 static MonoAssemblyName*
2011 mono_assembly_bind_version (MonoAssemblyBindingInfo *info, MonoAssemblyName *aname, MonoAssemblyName *dest_name)
2012 {
2013         memcpy (dest_name, aname, sizeof (MonoAssemblyName));
2014         dest_name->major = info->new_version.major;
2015         dest_name->minor = info->new_version.minor;
2016         dest_name->build = info->new_version.build;
2017         dest_name->revision = info->new_version.revision;
2018
2019         return dest_name;
2020 }
2021
2022 /* LOCKING: Assumes that we are already locked */
2023 static MonoAssemblyBindingInfo*
2024 search_binding_loaded (MonoAssemblyName *aname)
2025 {
2026         GSList *tmp;
2027
2028         for (tmp = loaded_assembly_bindings; tmp; tmp = tmp->next) {
2029                 MonoAssemblyBindingInfo *info = tmp->data;
2030                 if (assembly_binding_maps_name (info, aname))
2031                         return info;
2032         }
2033
2034         return NULL;
2035 }
2036
2037 static MonoAssemblyName*
2038 mono_assembly_apply_binding (MonoAssemblyName *aname, MonoAssemblyName *dest_name)
2039 {
2040         MonoAssemblyBindingInfo *info, *info2;
2041         MonoImage *ppimage;
2042
2043         if (aname->public_key_token [0] == 0)
2044                 return aname;
2045
2046         mono_loader_lock ();
2047         info = search_binding_loaded (aname);
2048         mono_loader_unlock ();
2049         if (info) {
2050                 if (!check_policy_versions (info, aname))
2051                         return aname;
2052
2053                 mono_assembly_bind_version (info, aname, dest_name);
2054                 return dest_name;
2055         }
2056
2057         info = g_new0 (MonoAssemblyBindingInfo, 1);
2058         info->major = aname->major;
2059         info->minor = aname->minor;
2060
2061         ppimage = mono_assembly_load_publisher_policy (aname);
2062         if (ppimage) {
2063                 get_publisher_policy_info (ppimage, aname, info);
2064                 mono_image_close (ppimage);
2065         }
2066
2067         /* Define default error value if needed */
2068         if (!info->is_valid) {
2069                 info->name = g_strdup (aname->name);
2070                 info->culture = g_strdup (aname->culture);
2071                 g_strlcpy ((char *)info->public_key_token, (const char *)aname->public_key_token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
2072         }
2073
2074         mono_loader_lock ();
2075         info2 = search_binding_loaded (aname);
2076         if (info2) {
2077                 /* This binding was added by another thread
2078                  * before us */
2079                 mono_assembly_binding_info_free (info);
2080                 g_free (info);
2081
2082                 info = info2;
2083         } else
2084                 loaded_assembly_bindings = g_slist_prepend (loaded_assembly_bindings, info);
2085
2086         mono_loader_unlock ();
2087
2088         if (!info->is_valid || !check_policy_versions (info, aname))
2089                 return aname;
2090
2091         mono_assembly_bind_version (info, aname, dest_name);
2092         return dest_name;
2093 }
2094
2095 /**
2096  * mono_assembly_load_from_gac
2097  *
2098  * @aname: The assembly name object
2099  */
2100 static MonoAssembly*
2101 mono_assembly_load_from_gac (MonoAssemblyName *aname,  gchar *filename, MonoImageOpenStatus *status, MonoBoolean refonly)
2102 {
2103         MonoAssembly *result = NULL;
2104         gchar *name, *version, *culture, *fullpath, *subpath;
2105         gint32 len;
2106         gchar **paths;
2107         char *pubtok;
2108
2109         if (aname->public_key_token [0] == 0) {
2110                 return NULL;
2111         }
2112
2113         if (strstr (aname->name, ".dll")) {
2114                 len = strlen (filename) - 4;
2115                 name = g_malloc (len);
2116                 strncpy (name, aname->name, len);
2117         } else {
2118                 name = g_strdup (aname->name);
2119         }
2120
2121         if (aname->culture) {
2122                 culture = g_strdup (aname->culture);
2123                 g_strdown (culture);
2124         } else {
2125                 culture = g_strdup ("");
2126         }
2127
2128         pubtok = g_ascii_strdown ((char*)aname->public_key_token, MONO_PUBLIC_KEY_TOKEN_LENGTH);
2129         version = g_strdup_printf ("%d.%d.%d.%d_%s_%s", aname->major,
2130                         aname->minor, aname->build, aname->revision,
2131                         culture, pubtok);
2132         g_free (pubtok);
2133
2134         subpath = g_build_path (G_DIR_SEPARATOR_S, name, version, filename, NULL);
2135         g_free (name);
2136         g_free (version);
2137         g_free (culture);
2138
2139         if (extra_gac_paths) {
2140                 paths = extra_gac_paths;
2141                 while (!result && *paths) {
2142                         fullpath = g_build_path (G_DIR_SEPARATOR_S, *paths, "lib", "mono", "gac", subpath, NULL);
2143                         result = mono_assembly_open_full (fullpath, status, refonly);
2144                         g_free (fullpath);
2145                         paths++;
2146                 }
2147         }
2148
2149         if (result) {
2150                 result->in_gac = TRUE;
2151                 g_free (subpath);
2152                 return result;
2153         }
2154
2155         fullpath = g_build_path (G_DIR_SEPARATOR_S, mono_assembly_getrootdir (),
2156                         "mono", "gac", subpath, NULL);
2157         result = mono_assembly_open_full (fullpath, status, refonly);
2158         g_free (fullpath);
2159
2160         if (result)
2161                 result->in_gac = TRUE;
2162
2163         g_free (subpath);
2164
2165         return result;
2166 }
2167
2168
2169 MonoAssembly*
2170 mono_assembly_load_corlib (const MonoRuntimeInfo *runtime, MonoImageOpenStatus *status)
2171 {
2172         char *corlib_file;
2173
2174         if (corlib) {
2175                 /* g_print ("corlib already loaded\n"); */
2176                 return corlib;
2177         }
2178
2179         if (assemblies_path) {
2180                 corlib = load_in_path ("mscorlib.dll", (const char**)assemblies_path, status, FALSE);
2181                 if (corlib)
2182                         return corlib;
2183         }
2184
2185         /* Load corlib from mono/<version> */
2186
2187         corlib_file = g_build_filename ("mono", runtime->framework_version, "mscorlib.dll", NULL);
2188         if (assemblies_path) {
2189                 corlib = load_in_path (corlib_file, (const char**)assemblies_path, status, FALSE);
2190                 if (corlib) {
2191                         g_free (corlib_file);
2192                         return corlib;
2193                 }
2194         }
2195         corlib = load_in_path (corlib_file, default_path, status, FALSE);
2196         g_free (corlib_file);
2197
2198         return corlib;
2199 }
2200
2201 MonoAssembly*
2202 mono_assembly_load_full_nosearch (MonoAssemblyName *aname,
2203                                                                   const char       *basedir,
2204                                                                   MonoImageOpenStatus *status,
2205                                                                   gboolean refonly)
2206 {
2207         MonoAssembly *result;
2208         char *fullpath, *filename;
2209         MonoAssemblyName maped_aname, maped_name_pp;
2210         int ext_index;
2211         const char *ext;
2212         int len;
2213
2214         aname = mono_assembly_remap_version (aname, &maped_aname);
2215
2216         /* Reflection only assemblies don't get assembly binding */
2217         if (!refonly)
2218                 aname = mono_assembly_apply_binding (aname, &maped_name_pp);
2219
2220         result = mono_assembly_loaded_full (aname, refonly);
2221         if (result)
2222                 return result;
2223
2224         result = refonly ? invoke_assembly_refonly_preload_hook (aname, assemblies_path) : invoke_assembly_preload_hook (aname, assemblies_path);
2225         if (result) {
2226                 result->in_gac = FALSE;
2227                 return result;
2228         }
2229
2230         /* Currently we retrieve the loaded corlib for reflection
2231          * only requests, like a common reflection only assembly
2232          */
2233         if (strcmp (aname->name, "mscorlib") == 0 || strcmp (aname->name, "mscorlib.dll") == 0) {
2234                 return mono_assembly_load_corlib (mono_get_runtime_info (), status);
2235         }
2236
2237         len = strlen (aname->name);
2238         for (ext_index = 0; ext_index < 2; ext_index ++) {
2239                 ext = ext_index == 0 ? ".dll" : ".exe";
2240                 if (len > 4 && (!strcmp (aname->name + len - 4, ".dll") || !strcmp (aname->name + len - 4, ".exe"))) {
2241                         filename = g_strdup (aname->name);
2242                         /* Don't try appending .dll/.exe if it already has one of those extensions */
2243                         ext_index++;
2244                 } else {
2245                         filename = g_strconcat (aname->name, ext, NULL);
2246                 }
2247
2248                 result = mono_assembly_load_from_gac (aname, filename, status, refonly);
2249                 if (result) {
2250                         g_free (filename);
2251                         return result;
2252                 }
2253
2254                 if (basedir) {
2255                         fullpath = g_build_filename (basedir, filename, NULL);
2256                         result = mono_assembly_open_full (fullpath, status, refonly);
2257                         g_free (fullpath);
2258                         if (result) {
2259                                 result->in_gac = FALSE;
2260                                 g_free (filename);
2261                                 return result;
2262                         }
2263                 }
2264
2265                 result = load_in_path (filename, default_path, status, refonly);
2266                 if (result)
2267                         result->in_gac = FALSE;
2268                 g_free (filename);
2269                 if (result)
2270                         return result;
2271         }
2272
2273         return result;
2274 }
2275
2276 /**
2277  * mono_assembly_load_full:
2278  * @aname: A MonoAssemblyName with the assembly name to load.
2279  * @basedir: A directory to look up the assembly at.
2280  * @status: a pointer to a MonoImageOpenStatus to return the status of the load operation
2281  * @refonly: Whether this assembly is being opened in "reflection-only" mode.
2282  *
2283  * Loads the assembly referenced by @aname, if the value of @basedir is not NULL, it
2284  * attempts to load the assembly from that directory before probing the standard locations.
2285  *
2286  * If the assembly is being opened in reflection-only mode (@refonly set to TRUE) then no
2287  * assembly binding takes place.
2288  *
2289  * Returns: the assembly referenced by @aname loaded or NULL on error.   On error the
2290  * value pointed by status is updated with an error code.
2291  */
2292 MonoAssembly*
2293 mono_assembly_load_full (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status, gboolean refonly)
2294 {
2295         MonoAssembly *result = mono_assembly_load_full_nosearch (aname, basedir, status, refonly);
2296
2297         if (!result)
2298                 /* Try a postload search hook */
2299                 result = mono_assembly_invoke_search_hook_internal (aname, refonly, TRUE);
2300         return result;
2301 }
2302
2303 /**
2304  * mono_assembly_load:
2305  * @aname: A MonoAssemblyName with the assembly name to load.
2306  * @basedir: A directory to look up the assembly at.
2307  * @status: a pointer to a MonoImageOpenStatus to return the status of the load operation
2308  *
2309  * Loads the assembly referenced by @aname, if the value of @basedir is not NULL, it
2310  * attempts to load the assembly from that directory before probing the standard locations.
2311  *
2312  * Returns: the assembly referenced by @aname loaded or NULL on error.   On error the
2313  * value pointed by status is updated with an error code.
2314  */
2315 MonoAssembly*
2316 mono_assembly_load (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status)
2317 {
2318         return mono_assembly_load_full (aname, basedir, status, FALSE);
2319 }
2320
2321 MonoAssembly*
2322 mono_assembly_loaded_full (MonoAssemblyName *aname, gboolean refonly)
2323 {
2324         MonoAssembly *res;
2325         MonoAssemblyName maped_aname;
2326
2327         aname = mono_assembly_remap_version (aname, &maped_aname);
2328
2329         res = mono_assembly_invoke_search_hook_internal (aname, refonly, FALSE);
2330
2331         return res;
2332 }
2333
2334 /**
2335  * mono_assembly_loaded:
2336  * @aname: an assembly to look for.
2337  *
2338  * Returns: NULL If the given @aname assembly has not been loaded, or a pointer to
2339  * a MonoAssembly that matches the MonoAssemblyName specified.
2340  */
2341 MonoAssembly*
2342 mono_assembly_loaded (MonoAssemblyName *aname)
2343 {
2344         return mono_assembly_loaded_full (aname, FALSE);
2345 }
2346
2347 /**
2348  * mono_assembly_close:
2349  * @assembly: the assembly to release.
2350  *
2351  * This method releases a reference to the @assembly.  The assembly is
2352  * only released when all the outstanding references to it are released.
2353  */
2354 void
2355 mono_assembly_close (MonoAssembly *assembly)
2356 {
2357         GSList *tmp;
2358         g_return_if_fail (assembly != NULL);
2359
2360         if (assembly == REFERENCE_MISSING)
2361                 return;
2362
2363         /* Might be 0 already */
2364         if (InterlockedDecrement (&assembly->ref_count) > 0)
2365                 return;
2366
2367         mono_profiler_assembly_event (assembly, MONO_PROFILE_START_UNLOAD);
2368
2369         mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Unloading assembly %s [%p].", assembly->aname.name, assembly);
2370
2371         mono_debug_close_image (assembly->image);
2372
2373         mono_assemblies_lock ();
2374         loaded_assemblies = g_list_remove (loaded_assemblies, assembly);
2375         mono_assemblies_unlock ();
2376
2377         assembly->image->assembly = NULL;
2378
2379         mono_image_close (assembly->image);
2380
2381         for (tmp = assembly->friend_assembly_names; tmp; tmp = tmp->next) {
2382                 MonoAssemblyName *fname = tmp->data;
2383                 mono_assembly_name_free (fname);
2384                 g_free (fname);
2385         }
2386         g_slist_free (assembly->friend_assembly_names);
2387         g_free (assembly->basedir);
2388         if (assembly->dynamic) {
2389                 g_free ((char*)assembly->aname.culture);
2390         } else {
2391                 g_free (assembly);
2392         }
2393
2394         mono_profiler_assembly_event (assembly, MONO_PROFILE_END_UNLOAD);
2395 }
2396
2397 MonoImage*
2398 mono_assembly_load_module (MonoAssembly *assembly, guint32 idx)
2399 {
2400         return mono_image_load_file_for_image (assembly->image, idx);
2401 }
2402
2403 void
2404 mono_assembly_foreach (GFunc func, gpointer user_data)
2405 {
2406         GList *copy;
2407
2408         /*
2409          * We make a copy of the list to avoid calling the callback inside the
2410          * lock, which could lead to deadlocks.
2411          */
2412         mono_assemblies_lock ();
2413         copy = g_list_copy (loaded_assemblies);
2414         mono_assemblies_unlock ();
2415
2416         g_list_foreach (loaded_assemblies, func, user_data);
2417
2418         g_list_free (copy);
2419 }
2420
2421 /**
2422  * mono_assemblies_cleanup:
2423  *
2424  * Free all resources used by this module.
2425  */
2426 void
2427 mono_assemblies_cleanup (void)
2428 {
2429         GSList *l;
2430
2431         DeleteCriticalSection (&assemblies_mutex);
2432
2433         for (l = loaded_assembly_bindings; l; l = l->next) {
2434                 MonoAssemblyBindingInfo *info = l->data;
2435
2436                 mono_assembly_binding_info_free (info);
2437                 g_free (info);
2438         }
2439         g_slist_free (loaded_assembly_bindings);
2440
2441         free_assembly_load_hooks ();
2442         free_assembly_search_hooks ();
2443         free_assembly_preload_hooks ();
2444 }
2445
2446 /*
2447  * Holds the assembly of the application, for
2448  * System.Diagnostics.Process::MainModule
2449  */
2450 static MonoAssembly *main_assembly=NULL;
2451
2452 void
2453 mono_assembly_set_main (MonoAssembly *assembly)
2454 {
2455         main_assembly = assembly;
2456 }
2457
2458 /**
2459  * mono_assembly_get_main:
2460  *
2461  * Returns: the assembly for the application, the first assembly that is loaded by the VM
2462  */
2463 MonoAssembly *
2464 mono_assembly_get_main (void)
2465 {
2466         return (main_assembly);
2467 }
2468
2469 /**
2470  * mono_assembly_get_image:
2471  * @assembly: The assembly to retrieve the image from
2472  *
2473  * Returns: the MonoImage associated with this assembly.
2474  */
2475 MonoImage*
2476 mono_assembly_get_image (MonoAssembly *assembly)
2477 {
2478         return assembly->image;
2479 }
2480
2481 void
2482 mono_register_bundled_assemblies (const MonoBundledAssembly **assemblies)
2483 {
2484         bundles = assemblies;
2485 }
2486
2487 #define MONO_DECLSEC_FORMAT_20          0x2E
2488 #define MONO_DECLSEC_FIELD              0x53
2489 #define MONO_DECLSEC_PROPERTY           0x54
2490
2491 #define SKIP_VISIBILITY_ATTRIBUTE_NAME ("System.Security.Permissions.SecurityPermissionAttribute")
2492 #define SKIP_VISIBILITY_ATTRIBUTE_SIZE (sizeof (SKIP_VISIBILITY_ATTRIBUTE_NAME) - 1)
2493 #define SKIP_VISIBILITY_PROPERTY_NAME ("SkipVerification")
2494 #define SKIP_VISIBILITY_PROPERTY_SIZE (sizeof (SKIP_VISIBILITY_PROPERTY_NAME) - 1)
2495
2496 static gboolean
2497 mono_assembly_try_decode_skip_verification_param (const char *p, const char **resp, gboolean *abort_decoding)
2498 {
2499         int len;
2500         switch (*p++) {
2501         case MONO_DECLSEC_PROPERTY:
2502                 break;
2503         case MONO_DECLSEC_FIELD:
2504         default:
2505                 *abort_decoding = TRUE;
2506                 return FALSE;
2507                 break;
2508         }
2509
2510         if (*p++ != MONO_TYPE_BOOLEAN) {
2511                 *abort_decoding = TRUE;
2512                 return FALSE;
2513         }
2514
2515         /* property name length */
2516         len = mono_metadata_decode_value (p, &p);
2517
2518         if (len >= SKIP_VISIBILITY_PROPERTY_SIZE && !memcmp (p, SKIP_VISIBILITY_PROPERTY_NAME, SKIP_VISIBILITY_PROPERTY_SIZE)) {
2519                 p += len;
2520                 return *p;
2521         }
2522         p += len + 1;
2523
2524         *resp = p;
2525         return FALSE;
2526 }
2527
2528 static gboolean
2529 mono_assembly_try_decode_skip_verification (const char *p, const char *endn)
2530 {
2531         int i, j, num, len, params_len;
2532
2533         if (*p++ != MONO_DECLSEC_FORMAT_20)
2534                 return FALSE;
2535
2536         /* number of encoded permission attributes */
2537         num = mono_metadata_decode_value (p, &p);
2538         for (i = 0; i < num; ++i) {
2539                 gboolean is_valid = FALSE;
2540                 gboolean abort_decoding = FALSE;
2541
2542                 /* attribute name length */
2543                 len =  mono_metadata_decode_value (p, &p);
2544
2545                 /* We don't really need to fully decode the type. Comparing the name is enough */
2546                 is_valid = len >= SKIP_VISIBILITY_ATTRIBUTE_SIZE && !memcmp (p, SKIP_VISIBILITY_ATTRIBUTE_NAME, SKIP_VISIBILITY_ATTRIBUTE_SIZE);
2547
2548                 p += len;
2549
2550                 /*size of the params table*/
2551                 params_len =  mono_metadata_decode_value (p, &p);
2552                 if (is_valid) {
2553                         const char *params_end = p + params_len;
2554
2555                         /* number of parameters */
2556                         len = mono_metadata_decode_value (p, &p);
2557
2558                         for (j = 0; j < len; ++j) {
2559                                 if (mono_assembly_try_decode_skip_verification_param (p, &p, &abort_decoding))
2560                                         return TRUE;
2561                                 if (abort_decoding)
2562                                         break;
2563                         }
2564                         p = params_end;
2565                 } else {
2566                         p += params_len;
2567                 }
2568         }
2569
2570         return FALSE;
2571 }
2572
2573
2574 gboolean
2575 mono_assembly_has_skip_verification (MonoAssembly *assembly)
2576 {
2577         MonoTableInfo *t;
2578         guint32 cols [MONO_DECL_SECURITY_SIZE];
2579         const char *blob;
2580         int i, len;
2581
2582         if (MONO_SECMAN_FLAG_INIT (assembly->skipverification))
2583                 return MONO_SECMAN_FLAG_GET_VALUE (assembly->skipverification);
2584
2585         t = &assembly->image->tables [MONO_TABLE_DECLSECURITY];
2586
2587         for (i = 0; i < t->rows; ++i) {
2588                 mono_metadata_decode_row (t, i, cols, MONO_DECL_SECURITY_SIZE);
2589                 if ((cols [MONO_DECL_SECURITY_PARENT] & MONO_HAS_DECL_SECURITY_MASK) != MONO_HAS_DECL_SECURITY_ASSEMBLY)
2590                         continue;
2591                 if (cols [MONO_DECL_SECURITY_ACTION] != SECURITY_ACTION_REQMIN)
2592                         continue;
2593
2594                 blob = mono_metadata_blob_heap (assembly->image, cols [MONO_DECL_SECURITY_PERMISSIONSET]);
2595                 len = mono_metadata_decode_blob_size (blob, &blob);
2596                 if (!len)
2597                         continue;
2598
2599                 if (mono_assembly_try_decode_skip_verification (blob, blob + len)) {
2600                         MONO_SECMAN_FLAG_SET_VALUE (assembly->skipverification, TRUE);
2601                         return TRUE;
2602                 }
2603         }
2604
2605         MONO_SECMAN_FLAG_SET_VALUE (assembly->skipverification, FALSE);
2606         return FALSE;
2607 }