mono/metadata/appdomain.c

   1 /*
   2  * appdomain.c: AppDomain functions
   3  *
   4  * Authors:
   5  *      Dietmar Maurer (dietmar@ximian.com)
   6  *      Patrik Torstensson
   7  *      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   8  *
   9  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  10  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  11  */
  12 #undef ASSEMBLY_LOAD_DEBUG
  13 #include <config.h>
  14 #include <glib.h>
  15 #include <string.h>
  16 #ifdef HAVE_UNISTD_H
  17 #include <unistd.h>
  18 #endif
  19 #include <errno.h>
  20 #include <sys/stat.h>
  21 #include <sys/types.h>
  22 #ifdef HAVE_SYS_TIME_H
  23 #include <sys/time.h>
  24 #endif
  25 #ifdef HAVE_UTIME_H
  26 #include <utime.h>
  27 #else
  28 #ifdef HAVE_SYS_UTIME_H
  29 #include <sys/utime.h>
  30 #endif
  31 #endif
  32
  33 #include <mono/metadata/gc-internal.h>
  34 #include <mono/metadata/object.h>
  35 #include <mono/metadata/domain-internals.h>
  36 #include "mono/metadata/metadata-internals.h"
  37 #include <mono/metadata/assembly.h>
  38 #include <mono/metadata/exception.h>
  39 #include <mono/metadata/threads.h>
  40 #include <mono/metadata/socket-io.h>
  41 #include <mono/metadata/tabledefs.h>
  42 #include <mono/metadata/gc-internal.h>
  43 #include <mono/metadata/mono-gc.h>
  44 #include <mono/metadata/marshal.h>
  45 #include <mono/metadata/monitor.h>
  46 #include <mono/metadata/threadpool.h>
  47 #include <mono/metadata/mono-debug.h>
  48 #include <mono/metadata/attach.h>
  49 #include <mono/metadata/file-io.h>
  50 #include <mono/metadata/lock-tracer.h>
  51 #include <mono/utils/mono-uri.h>
  52 #include <mono/utils/mono-logger.h>
  53 #include <mono/utils/mono-path.h>
  54 #include <mono/utils/mono-stdlib.h>
  55 #include <mono/utils/mono-io-portability.h>
  56 #ifdef PLATFORM_WIN32
  57 #include <direct.h>
  58 #endif
  59
  60 /*
  61  * This is the version number of the corlib-runtime interface. When
  62  * making changes to this interface (by changing the layout
  63  * of classes the runtime knows about, changing icall signature or
  64  * semantics etc), increment this variable. Also increment the
  65  * pair of this variable in mscorlib in:
  66  *       mcs/class/mscorlib/System/Environment.cs
  67  *
  68  * Changes which are already detected at runtime, like the addition
  69  * of icalls, do not require an increment.
  70  */
  71 #define MONO_CORLIB_VERSION 74
  72
  73 typedef struct
  74 {
  75         int runtime_count;
  76         int assemblybinding_count;
  77         MonoDomain *domain;
  78 } RuntimeConfig;
  79
  80 CRITICAL_SECTION mono_delegate_section;
  81
  82 #ifdef _EGLIB_MAJOR
  83 /* Need to lock here because EGLIB has locking defined as no-ops, we can not depend on mono_strtod do the right locking */
  84 /* Ideally this will be fixed in eglib */
  85 CRITICAL_SECTION mono_strtod_mutex;
  86 #endif
  87
  88
  89 static gunichar2 process_guid [36];
  90 static gboolean process_guid_set = FALSE;
  91
  92 static gboolean shutting_down = FALSE;
  93
  94 static gboolean no_exec = FALSE;
  95
  96 static MonoAssembly *
  97 mono_domain_assembly_preload (MonoAssemblyName *aname,
  98                               gchar **assemblies_path,
  99                               gpointer user_data);
 100
 101 static MonoAssembly *
 102 mono_domain_assembly_search (MonoAssemblyName *aname,
 103                                                          gpointer user_data);
 104
 105 static MonoAssembly *
 106 mono_domain_assembly_postload_search (MonoAssemblyName *aname,
 107                                                                           gpointer user_data);
 108
 109 static void
 110 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data);
 111
 112 static void
 113 add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass, GHashTable *hash);
 114
 115 static MonoAppDomain *
 116 mono_domain_create_appdomain_internal (char *friendly_name, MonoAppDomainSetup *setup);
 117
 118 static MonoLoadFunc load_function = NULL;
 119
 120 void
 121 mono_install_runtime_load (MonoLoadFunc func)
 122 {
 123         load_function = func;
 124 }
 125
 126 MonoDomain*
 127 mono_runtime_load (const char *filename, const char *runtime_version)
 128 {
 129         g_assert (load_function);
 130         return load_function (filename, runtime_version);
 131 }
 132
 133 /*
 134  * mono_runtime_set_no_exec:
 135  *
 136  *   Instructs the runtime to operate in static mode, i.e. avoid/do not allow managed
 137  * code execution. This is useful for running the AOT compiler on platforms which
 138  * allow full-aot execution only.
 139  * This should be called before mono_runtime_init ().
 140  */
 141 void
 142 mono_runtime_set_no_exec (gboolean val)
 143 {
 144         no_exec = val;
 145 }
 146
 147 gboolean
 148 mono_runtime_get_no_exec (void)
 149 {
 150         return no_exec;
 151 }
 152
 153 /**
 154  * mono_runtime_init:
 155  * @domain: domain returned by mono_init ()
 156  *
 157  * Initialize the core AppDomain: this function will run also some
 158  * IL initialization code, so it needs the execution engine to be fully
 159  * operational.
 160  *
 161  * AppDomain.SetupInformation is set up in mono_runtime_exec_main, where
 162  * we know the entry_assembly.
 163  *
 164  */
 165 void
 166 mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
 167                    MonoThreadAttachCB attach_cb)
 168 {
 169         MonoAppDomainSetup *setup;
 170         MonoAppDomain *ad;
 171         MonoClass *class;
 172         MonoString *arg;
 173
 174         mono_portability_helpers_init ();
 175
 176         mono_gc_base_init ();
 177         mono_monitor_init ();
 178         mono_thread_pool_init ();
 179         mono_marshal_init ();
 180
 181         mono_install_assembly_preload_hook (mono_domain_assembly_preload, GUINT_TO_POINTER (FALSE));
 182         mono_install_assembly_refonly_preload_hook (mono_domain_assembly_preload, GUINT_TO_POINTER (TRUE));
 183         mono_install_assembly_search_hook (mono_domain_assembly_search, GUINT_TO_POINTER (FALSE));
 184         mono_install_assembly_refonly_search_hook (mono_domain_assembly_search, GUINT_TO_POINTER (TRUE));
 185         mono_install_assembly_postload_search_hook (mono_domain_assembly_postload_search, GUINT_TO_POINTER (FALSE));
 186         mono_install_assembly_postload_refonly_search_hook (mono_domain_assembly_postload_search, GUINT_TO_POINTER (TRUE));
 187         mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
 188         mono_install_lookup_dynamic_token (mono_reflection_lookup_dynamic_token);
 189
 190         mono_thread_init (start_cb, attach_cb);
 191
 192         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
 193         setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
 194
 195         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 196         ad = (MonoAppDomain *) mono_object_new (domain, class);
 197         ad->data = domain;
 198         domain->domain = ad;
 199         domain->setup = setup;
 200
 201         InitializeCriticalSection (&mono_delegate_section);
 202
 203 #ifdef _EGLIB_MAJOR
 204         /* Needed until EGLIB is fixed #464316 */
 205         InitializeCriticalSection (&mono_strtod_mutex);
 206 #endif
 207
 208         mono_thread_attach (domain);
 209         mono_context_init (domain);
 210         mono_context_set (domain->default_context);
 211
 212         mono_type_initialization_init ();
 213
 214         if (!mono_runtime_get_no_exec ()) {
 215                 /*
 216                  * Create an instance early since we can't do it when there is no memory.
 217                  */
 218                 arg = mono_string_new (domain, "Out of memory");
 219                 domain->out_of_memory_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "OutOfMemoryException", arg, NULL);
 220
 221                 /*
 222                  * These two are needed because the signal handlers might be executing on
 223                  * an alternate stack, and Boehm GC can't handle that.
 224                  */
 225                 arg = mono_string_new (domain, "A null value was found where an object instance was required");
 226                 domain->null_reference_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "NullReferenceException", arg, NULL);
 227                 arg = mono_string_new (domain, "The requested operation caused a stack overflow.");
 228                 domain->stack_overflow_ex = mono_exception_from_name_two_strings (mono_defaults.corlib, "System", "StackOverflowException", arg, NULL);
 229         }
 230
 231         /* GC init has to happen after thread init */
 232         mono_gc_init ();
 233
 234 #ifndef DISABLE_SOCKETS
 235         mono_network_init ();
 236 #endif
 237
 238         mono_attach_init ();
 239
 240         mono_locks_tracer_init ();
 241
 242         /* mscorlib is loaded before we install the load hook */
 243         mono_domain_fire_assembly_load (mono_defaults.corlib->assembly, NULL);
 244
 245         return;
 246 }
 247
 248 static int
 249 mono_get_corlib_version (void)
 250 {
 251         MonoClass *klass;
 252         MonoClassField *field;
 253         MonoObject *value;
 254
 255         klass = mono_class_from_name (mono_defaults.corlib, "System", "Environment");
 256         mono_class_init (klass);
 257         field = mono_class_get_field_from_name (klass, "mono_corlib_version");
 258         if (!field)
 259                 return -1;
 260         if (! (field->type->attrs & FIELD_ATTRIBUTE_STATIC))
 261                 return -1;
 262         value = mono_field_get_value_object (mono_domain_get (), field, NULL);
 263         return *(gint32*)((gchar*)value + sizeof (MonoObject));
 264 }
 265
 266 const char*
 267 mono_check_corlib_version (void)
 268 {
 269         int version = mono_get_corlib_version ();
 270         if (version != MONO_CORLIB_VERSION)
 271                 return g_strdup_printf ("expected corlib version %d, found %d.", MONO_CORLIB_VERSION, version);
 272         else
 273                 return NULL;
 274 }
 275
 276 void
 277 mono_context_init (MonoDomain *domain)
 278 {
 279         MonoClass *class;
 280         MonoAppContext *context;
 281
 282         class = mono_class_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
 283         context = (MonoAppContext *) mono_object_new (domain, class);
 284         context->domain_id = domain->domain_id;
 285         context->context_id = 0;
 286         domain->default_context = context;
 287 }
 288
 289 /**
 290  * mono_runtime_cleanup:
 291  * @domain: unused.
 292  *
 293  * Internal routine.
 294  *
 295  * This must not be called while there are still running threads executing
 296  * managed code.
 297  */
 298 void
 299 mono_runtime_cleanup (MonoDomain *domain)
 300 {
 301         shutting_down = TRUE;
 302
 303         mono_attach_cleanup ();
 304
 305         /* This ends up calling any pending pending (for at most 2 seconds) */
 306         mono_gc_cleanup ();
 307
 308         mono_thread_cleanup ();
 309
 310 #ifndef DISABLE_SOCKETS
 311         mono_network_cleanup ();
 312 #endif
 313         mono_marshal_cleanup ();
 314
 315         mono_type_initialization_cleanup ();
 316
 317         mono_monitor_cleanup ();
 318
 319 #ifndef PLATFORM_WIN32
 320         _wapi_cleanup ();
 321 #endif
 322 }
 323
 324 static MonoDomainFunc quit_function = NULL;
 325
 326 void
 327 mono_install_runtime_cleanup (MonoDomainFunc func)
 328 {
 329         quit_function = func;
 330 }
 331
 332 void
 333 mono_runtime_quit ()
 334 {
 335         if (quit_function != NULL)
 336                 quit_function (mono_get_root_domain (), NULL);
 337 }
 338
 339 /**
 340  * mono_runtime_set_shutting_down:
 341  *
 342  * Invoked by System.Environment.Exit to flag that the runtime
 343  * is shutting down.
 344  */
 345 void
 346 mono_runtime_set_shutting_down (void)
 347 {
 348         shutting_down = TRUE;
 349 }
 350
 351 /**
 352  * mono_runtime_is_shutting_down:
 353  *
 354  * Returns whether the runtime has been flagged for shutdown.
 355  *
 356  * This is consumed by the P:System.Environment.HasShutdownStarted
 357  * property.
 358  *
 359  */
 360 gboolean
 361 mono_runtime_is_shutting_down (void)
 362 {
 363         return shutting_down;
 364 }
 365
 366 /**
 367  * mono_domain_create_appdomain:
 368  * @friendly_name: The friendly name of the appdomain to create
 369  * @configuration_file: The configuration file to initialize the appdomain with
 370  *
 371  * Returns a MonoDomain initialized with the appdomain
 372  */
 373 MonoDomain *
 374 mono_domain_create_appdomain (char *friendly_name, char *configuration_file)
 375 {
 376         MonoAppDomain *ad;
 377         MonoAppDomainSetup *setup;
 378         MonoClass *class;
 379
 380         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
 381         setup = (MonoAppDomainSetup *) mono_object_new (mono_domain_get (), class);
 382         setup->configuration_file = configuration_file != NULL ? mono_string_new (mono_domain_get (), configuration_file) : NULL;
 383
 384         ad = mono_domain_create_appdomain_internal (friendly_name, setup);
 385
 386         return mono_domain_from_appdomain (ad);
 387 }
 388
 389 static MonoAppDomain *
 390 mono_domain_create_appdomain_internal (char *friendly_name, MonoAppDomainSetup *setup)
 391 {
 392         MonoClass *adclass;
 393         MonoAppDomain *ad;
 394         MonoDomain *data;
 395
 396         MONO_ARCH_SAVE_REGS;
 397
 398         adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 399
 400         /* FIXME: pin all those objects */
 401         data = mono_domain_create();
 402
 403         ad = (MonoAppDomain *) mono_object_new (data, adclass);
 404         ad->data = data;
 405         data->domain = ad;
 406         data->setup = setup;
 407         data->friendly_name = g_strdup (friendly_name);
 408         // FIXME: The ctor runs in the current domain
 409         // FIXME: Initialize null_reference_ex and stack_overflow_ex
 410         data->out_of_memory_ex = mono_exception_from_name_domain (data, mono_defaults.corlib, "System", "OutOfMemoryException");
 411
 412         if (!setup->application_base) {
 413                 /* Inherit from the root domain since MS.NET does this */
 414                 MonoDomain *root = mono_get_root_domain ();
 415                 if (root->setup->application_base)
 416                         MONO_OBJECT_SETREF (setup, application_base, mono_string_new_utf16 (data, mono_string_chars (root->setup->application_base), mono_string_length (root->setup->application_base)));
 417         }
 418
 419         mono_context_init (data);
 420
 421         mono_set_private_bin_path_from_config (data);
 422
 423         add_assemblies_to_domain (data, mono_defaults.corlib->assembly, NULL);
 424
 425         return ad;
 426 }
 427
 428 /**
 429  * mono_domain_has_type_resolve:
 430  * @domain: application domains being looked up
 431  *
 432  * Returns true if the AppDomain.TypeResolve field has been
 433  * set.
 434  */
 435 gboolean
 436 mono_domain_has_type_resolve (MonoDomain *domain)
 437 {
 438         static MonoClassField *field = NULL;
 439         MonoObject *o;
 440
 441         if (field == NULL) {
 442                 field = mono_class_get_field_from_name (mono_defaults.appdomain_class, "TypeResolve");
 443                 g_assert (field);
 444         }
 445
 446         mono_field_get_value ((MonoObject*)(domain->domain), field, &o);
 447         return o != NULL;
 448 }
 449
 450 /**
 451  * mono_domain_try_type_resolve:
 452  * @domain: application domainwhere the name where the type is going to be resolved
 453  * @name: the name of the type to resolve or NULL.
 454  * @tb: A System.Reflection.Emit.TypeBuilder, used if name is NULL.
 455  *
 456  * This routine invokes the internal System.AppDomain.DoTypeResolve and returns
 457  * the assembly that matches name.
 458  *
 459  * If @name is null, the value of ((TypeBuilder)tb).FullName is used instead
 460  *
 461  * Returns: A MonoReflectionAssembly or NULL if not found
 462  */
 463 MonoReflectionAssembly *
 464 mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *tb)
 465 {
 466         MonoClass *klass;
 467         void *params [1];
 468         static MonoMethod *method = NULL;
 469
 470         g_assert (domain != NULL && ((name != NULL) || (tb != NULL)));
 471
 472         if (method == NULL) {
 473                 klass = domain->domain->mbr.obj.vtable->klass;
 474                 g_assert (klass);
 475
 476                 method = mono_class_get_method_from_name (klass, "DoTypeResolve", -1);
 477                 if (method == NULL) {
 478                         g_warning ("Method AppDomain.DoTypeResolve not found.\n");
 479                         return NULL;
 480                 }
 481         }
 482
 483         if (name)
 484                 *params = (MonoObject*)mono_string_new (mono_domain_get (), name);
 485         else
 486                 *params = tb;
 487         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 488 }
 489
 490 /**
 491  * mono_domain_owns_vtable_slot:
 492  *
 493  *  Returns whenever VTABLE_SLOT is inside a vtable which belongs to DOMAIN.
 494  */
 495 gboolean
 496 mono_domain_owns_vtable_slot (MonoDomain *domain, gpointer vtable_slot)
 497 {
 498         gboolean res;
 499
 500         mono_domain_lock (domain);
 501         res = mono_mempool_contains_addr (domain->mp, vtable_slot);
 502         mono_domain_unlock (domain);
 503         return res;
 504 }
 505
 506 /**
 507  * mono_domain_set:
 508  * @domain: domain
 509  * @force: force setting.
 510  *
 511  * Set the current appdomain to @domain. If @force is set, set it even
 512  * if it is being unloaded.
 513  *
 514  * Returns:
 515  *   TRUE on success;
 516  *   FALSE if the domain is unloaded
 517  */
 518 gboolean
 519 mono_domain_set (MonoDomain *domain, gboolean force)
 520 {
 521         if (!force && domain->state == MONO_APPDOMAIN_UNLOADED)
 522                 return FALSE;
 523
 524         mono_domain_set_internal (domain);
 525
 526         return TRUE;
 527 }
 528
 529 MonoObject *
 530 ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
 531 {
 532         MonoDomain *add;
 533         MonoObject *o;
 534         char *str;
 535
 536         MONO_ARCH_SAVE_REGS;
 537
 538         g_assert (ad != NULL);
 539         add = ad->data;
 540         g_assert (add != NULL);
 541
 542         if (name == NULL)
 543                 mono_raise_exception (mono_get_exception_argument_null ("name"));
 544
 545         str = mono_string_to_utf8 (name);
 546
 547         mono_domain_lock (add);
 548
 549         if (!strcmp (str, "APPBASE"))
 550                 o = (MonoObject *)add->setup->application_base;
 551         else if (!strcmp (str, "APP_CONFIG_FILE"))
 552                 o = (MonoObject *)add->setup->configuration_file;
 553         else if (!strcmp (str, "DYNAMIC_BASE"))
 554                 o = (MonoObject *)add->setup->dynamic_base;
 555         else if (!strcmp (str, "APP_NAME"))
 556                 o = (MonoObject *)add->setup->application_name;
 557         else if (!strcmp (str, "CACHE_BASE"))
 558                 o = (MonoObject *)add->setup->cache_path;
 559         else if (!strcmp (str, "PRIVATE_BINPATH"))
 560                 o = (MonoObject *)add->setup->private_bin_path;
 561         else if (!strcmp (str, "BINPATH_PROBE_ONLY"))
 562                 o = (MonoObject *)add->setup->private_bin_path_probe;
 563         else if (!strcmp (str, "SHADOW_COPY_DIRS"))
 564                 o = (MonoObject *)add->setup->shadow_copy_directories;
 565         else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
 566                 o = (MonoObject *)add->setup->shadow_copy_files;
 567         else
 568                 o = mono_g_hash_table_lookup (add->env, name);
 569
 570         mono_domain_unlock (add);
 571         g_free (str);
 572
 573         if (!o)
 574                 return NULL;
 575
 576         return o;
 577 }
 578
 579 void
 580 ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
 581 {
 582         MonoDomain *add;
 583
 584         MONO_ARCH_SAVE_REGS;
 585
 586         g_assert (ad != NULL);
 587         add = ad->data;
 588         g_assert (add != NULL);
 589
 590         if (name == NULL)
 591                 mono_raise_exception (mono_get_exception_argument_null ("name"));
 592
 593         mono_domain_lock (add);
 594
 595         mono_g_hash_table_insert (add->env, name, data);
 596
 597         mono_domain_unlock (add);
 598 }
 599
 600 MonoAppDomainSetup *
 601 ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
 602 {
 603         MONO_ARCH_SAVE_REGS;
 604
 605         g_assert (ad != NULL);
 606         g_assert (ad->data != NULL);
 607
 608         return ad->data->setup;
 609 }
 610
 611 MonoString *
 612 ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
 613 {
 614         MONO_ARCH_SAVE_REGS;
 615
 616         g_assert (ad != NULL);
 617         g_assert (ad->data != NULL);
 618
 619         return mono_string_new (ad->data, ad->data->friendly_name);
 620 }
 621
 622 MonoAppDomain *
 623 ves_icall_System_AppDomain_getCurDomain ()
 624 {
 625         MonoDomain *add = mono_domain_get ();
 626
 627         MONO_ARCH_SAVE_REGS;
 628
 629         return add->domain;
 630 }
 631
 632 MonoAppDomain *
 633 ves_icall_System_AppDomain_getRootDomain ()
 634 {
 635         MonoDomain *root = mono_get_root_domain ();
 636
 637         MONO_ARCH_SAVE_REGS;
 638
 639         return root->domain;
 640 }
 641
 642 static char*
 643 get_attribute_value (const gchar **attribute_names,
 644                      const gchar **attribute_values,
 645                      const char *att_name)
 646 {
 647         int n;
 648         for (n = 0; attribute_names [n] != NULL; n++) {
 649                 if (strcmp (attribute_names [n], att_name) == 0)
 650                         return g_strdup (attribute_values [n]);
 651         }
 652         return NULL;
 653 }
 654
 655 static void
 656 start_element (GMarkupParseContext *context,
 657                const gchar         *element_name,
 658                const gchar        **attribute_names,
 659                const gchar        **attribute_values,
 660                gpointer             user_data,
 661                GError             **error)
 662 {
 663         RuntimeConfig *runtime_config = user_data;
 664
 665         if (strcmp (element_name, "runtime") == 0) {
 666                 runtime_config->runtime_count++;
 667                 return;
 668         }
 669
 670         if (strcmp (element_name, "assemblyBinding") == 0) {
 671                 runtime_config->assemblybinding_count++;
 672                 return;
 673         }
 674
 675         if (runtime_config->runtime_count != 1 || runtime_config->assemblybinding_count != 1)
 676                 return;
 677
 678         if (strcmp (element_name, "probing") != 0)
 679                 return;
 680
 681         g_free (runtime_config->domain->private_bin_path);
 682         runtime_config->domain->private_bin_path = get_attribute_value (attribute_names, attribute_values, "privatePath");
 683         if (runtime_config->domain->private_bin_path && !runtime_config->domain->private_bin_path [0]) {
 684                 g_free (runtime_config->domain->private_bin_path);
 685                 runtime_config->domain->private_bin_path = NULL;
 686                 return;
 687         }
 688 }
 689
 690 static void
 691 end_element (GMarkupParseContext *context,
 692              const gchar         *element_name,
 693              gpointer             user_data,
 694              GError             **error)
 695 {
 696         RuntimeConfig *runtime_config = user_data;
 697         if (strcmp (element_name, "runtime") == 0)
 698                 runtime_config->runtime_count--;
 699         else if (strcmp (element_name, "assemblyBinding") == 0)
 700                 runtime_config->assemblybinding_count--;
 701 }
 702
 703 static const GMarkupParser
 704 mono_parser = {
 705         start_element,
 706         end_element,
 707         NULL,
 708         NULL,
 709         NULL
 710 };
 711
 712 void
 713 mono_set_private_bin_path_from_config (MonoDomain *domain)
 714 {
 715         gchar *config_file, *text;
 716         gsize len;
 717         GMarkupParseContext *context;
 718         RuntimeConfig runtime_config;
 719
 720         if (!domain || !domain->setup || !domain->setup->configuration_file)
 721                 return;
 722
 723         config_file = mono_string_to_utf8 (domain->setup->configuration_file);
 724
 725         if (!g_file_get_contents (config_file, &text, &len, NULL)) {
 726                 g_free (config_file);
 727                 return;
 728         }
 729         g_free (config_file);
 730
 731         runtime_config.runtime_count = 0;
 732         runtime_config.assemblybinding_count = 0;
 733         runtime_config.domain = domain;
 734
 735         context = g_markup_parse_context_new (&mono_parser, 0, &runtime_config, NULL);
 736         if (g_markup_parse_context_parse (context, text, len, NULL))
 737                 g_markup_parse_context_end_parse (context, NULL);
 738         g_markup_parse_context_free (context);
 739         g_free (text);
 740 }
 741
 742 MonoAppDomain *
 743 ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
 744 {
 745         char *fname = mono_string_to_utf8 (friendly_name);
 746         MonoAppDomain *ad = mono_domain_create_appdomain_internal (fname, setup);
 747
 748         g_free (fname);
 749
 750         return ad;
 751 }
 752
 753 MonoArray *
 754 ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad, MonoBoolean refonly)
 755 {
 756         MonoDomain *domain = ad->data;
 757         MonoAssembly* ass;
 758         static MonoClass *System_Reflection_Assembly;
 759         MonoArray *res;
 760         GSList *tmp;
 761         int i;
 762         GPtrArray *assemblies;
 763
 764         MONO_ARCH_SAVE_REGS;
 765
 766         if (!System_Reflection_Assembly)
 767                 System_Reflection_Assembly = mono_class_from_name (
 768                         mono_defaults.corlib, "System.Reflection", "Assembly");
 769
 770         /*
 771          * Make a copy of the list of assemblies because we can't hold the assemblies
 772          * lock while creating objects etc.
 773          */
 774         assemblies = g_ptr_array_new ();
 775         /* Need to skip internal assembly builders created by remoting */
 776         mono_domain_assemblies_lock (domain);
 777         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
 778                 ass = tmp->data;
 779                 if (refonly && !ass->ref_only)
 780                         continue;
 781                 if (ass->corlib_internal)
 782                         continue;
 783                 g_ptr_array_add (assemblies, ass);
 784         }
 785         mono_domain_assemblies_unlock (domain);
 786
 787         res = mono_array_new (domain, System_Reflection_Assembly, assemblies->len);
 788         for (i = 0; i < assemblies->len; ++i) {
 789                 ass = g_ptr_array_index (assemblies, i);
 790                 mono_array_setref (res, i, mono_assembly_get_object (domain, ass));
 791         }
 792
 793         g_ptr_array_free (assemblies, TRUE);
 794
 795         return res;
 796 }
 797
 798 MonoReflectionAssembly *
 799 mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, gboolean refonly)
 800 {
 801         MonoClass *klass;
 802         MonoMethod *method;
 803         MonoBoolean isrefonly;
 804         gpointer params [2];
 805
 806         g_assert (domain != NULL && fname != NULL);
 807
 808         klass = domain->domain->mbr.obj.vtable->klass;
 809         g_assert (klass);
 810
 811         method = mono_class_get_method_from_name (klass, "DoAssemblyResolve", -1);
 812         if (method == NULL) {
 813                 g_warning ("Method AppDomain.DoAssemblyResolve not found.\n");
 814                 return NULL;
 815         }
 816
 817         isrefonly = refonly ? 1 : 0;
 818         params [0] = fname;
 819         params [1] = &isrefonly;
 820         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 821 }
 822
 823 static MonoAssembly *
 824 mono_domain_assembly_postload_search (MonoAssemblyName *aname,
 825                                                                           gpointer user_data)
 826 {
 827         gboolean refonly = GPOINTER_TO_UINT (user_data);
 828         MonoReflectionAssembly *assembly;
 829         MonoDomain *domain = mono_domain_get ();
 830         char *aname_str;
 831
 832         aname_str = mono_stringify_assembly_name (aname);
 833
 834         /* FIXME: We invoke managed code here, so there is a potential for deadlocks */
 835         assembly = mono_try_assembly_resolve (domain, mono_string_new (domain, aname_str), refonly);
 836
 837         g_free (aname_str);
 838
 839         if (assembly)
 840                 return assembly->assembly;
 841         else
 842                 return NULL;
 843 }
 844
 845 /*
 846  * LOCKING: assumes assemblies_lock in the domain is already locked.
 847  */
 848 static void
 849 add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass, GHashTable *ht)
 850 {
 851         gint i;
 852         GSList *tmp;
 853         gboolean destroy_ht = FALSE;
 854
 855         if (!ass->aname.name)
 856                 return;
 857
 858         if (!ht) {
 859                 ht = g_hash_table_new (mono_aligned_addr_hash, NULL);
 860                 destroy_ht = TRUE;
 861         }
 862
 863         /* FIXME: handle lazy loaded assemblies */
 864         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
 865                 g_hash_table_insert (ht, tmp->data, tmp->data);
 866         }
 867         if (!g_hash_table_lookup (ht, ass)) {
 868                 mono_assembly_addref (ass);
 869                 g_hash_table_insert (ht, ass, ass);
 870                 domain->domain_assemblies = g_slist_prepend (domain->domain_assemblies, ass);
 871                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Assembly %s %p added to domain %s, ref_count=%d\n", ass->aname.name, ass, domain->friendly_name, ass->ref_count);
 872         }
 873
 874         if (ass->image->references) {
 875                 for (i = 0; ass->image->references [i] != NULL; i++) {
 876                         if (ass->image->references [i] != REFERENCE_MISSING)
 877                                 if (!g_hash_table_lookup (ht, ass->image->references [i])) {
 878                                         add_assemblies_to_domain (domain, ass->image->references [i], ht);
 879                                 }
 880                 }
 881         }
 882         if (destroy_ht)
 883                 g_hash_table_destroy (ht);
 884 }
 885
 886 static void
 887 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data)
 888 {
 889         static MonoClassField *assembly_load_field;
 890         static MonoMethod *assembly_load_method;
 891         MonoDomain *domain = mono_domain_get ();
 892         MonoReflectionAssembly *ref_assembly;
 893         MonoClass *klass;
 894         gpointer load_value;
 895         void *params [1];
 896
 897         if (!domain->domain)
 898                 /* This can happen during startup */
 899                 return;
 900 #ifdef ASSEMBLY_LOAD_DEBUG
 901         fprintf (stderr, "Loading %s into domain %s\n", assembly->aname.name, domain->friendly_name);
 902 #endif
 903         klass = domain->domain->mbr.obj.vtable->klass;
 904
 905         mono_domain_assemblies_lock (domain);
 906         add_assemblies_to_domain (domain, assembly, NULL);
 907         mono_domain_assemblies_unlock (domain);
 908
 909         if (assembly_load_field == NULL) {
 910                 assembly_load_field = mono_class_get_field_from_name (klass, "AssemblyLoad");
 911                 g_assert (assembly_load_field);
 912         }
 913
 914         mono_field_get_value ((MonoObject*) domain->domain, assembly_load_field, &load_value);
 915         if (load_value == NULL) {
 916                 /* No events waiting to be triggered */
 917                 return;
 918         }
 919
 920         ref_assembly = mono_assembly_get_object (domain, assembly);
 921         g_assert (ref_assembly);
 922
 923         if (assembly_load_method == NULL) {
 924                 assembly_load_method = mono_class_get_method_from_name (klass, "DoAssemblyLoad", -1);
 925                 g_assert (assembly_load_method);
 926         }
 927
 928         *params = ref_assembly;
 929         mono_runtime_invoke (assembly_load_method, domain->domain, params, NULL);
 930 }
 931
 932 /*
 933  * LOCKING: Acquires the domain assemblies lock.
 934  */
 935 static void
 936 set_domain_search_path (MonoDomain *domain)
 937 {
 938         MonoAppDomainSetup *setup;
 939         gchar **tmp;
 940         gchar *search_path = NULL;
 941         gint i;
 942         gint npaths = 0;
 943         gchar **pvt_split = NULL;
 944         GError *error = NULL;
 945         gint appbaselen = -1;
 946
 947         /*
 948          * We use the low-level domain assemblies lock, since this is called from
 949          * assembly loads hooks, which means this thread might hold the loader lock.
 950          */
 951         mono_domain_assemblies_lock (domain);
 952
 953         if (!domain->setup) {
 954                 mono_domain_assemblies_unlock (domain);
 955                 return;
 956         }
 957
 958         if ((domain->search_path != NULL) && !domain->setup->path_changed) {
 959                 mono_domain_assemblies_unlock (domain);
 960                 return;
 961         }
 962         setup = domain->setup;
 963         if (!setup->application_base) {
 964                 mono_domain_assemblies_unlock (domain);
 965                 return; /* Must set application base to get private path working */
 966         }
 967
 968         npaths++;
 969
 970         if (setup->private_bin_path)
 971                 search_path = mono_string_to_utf8 (setup->private_bin_path);
 972
 973         if (domain->private_bin_path) {
 974                 if (search_path == NULL)
 975                         search_path = domain->private_bin_path;
 976                 else {
 977                         gchar *tmp2 = search_path;
 978                         search_path = g_strjoin (";", search_path, domain->private_bin_path, NULL);
 979                         g_free (tmp2);
 980                 }
 981         }
 982
 983         if (search_path) {
 984                 /*
 985                  * As per MSDN documentation, AppDomainSetup.PrivateBinPath contains a list of
 986                  * directories relative to ApplicationBase separated by semicolons (see
 987                  * http://msdn2.microsoft.com/en-us/library/system.appdomainsetup.privatebinpath.aspx)
 988                  * The loop below copes with the fact that some Unix applications may use ':' (or
 989                  * System.IO.Path.PathSeparator) as the path search separator. We replace it with
 990                  * ';' for the subsequent split.
 991                  *
 992                  * The issue was reported in bug #81446
 993                  */
 994
 995 #ifndef PLATFORM_WIN32
 996                 gint slen;
 997
 998                 slen = strlen (search_path);
 999                 for (i = 0; i < slen; i++)
1000                         if (search_path [i] == ':')
1001                                 search_path [i] = ';';
1002 #endif
1003
1004                 pvt_split = g_strsplit (search_path, ";", 1000);
1005                 g_free (search_path);
1006                 for (tmp = pvt_split; *tmp; tmp++, npaths++);
1007         }
1008
1009         if (!npaths) {
1010                 if (pvt_split)
1011                         g_strfreev (pvt_split);
1012                 /*
1013                  * Don't do this because the first time is called, the domain
1014                  * setup is not finished.
1015                  *
1016                  * domain->search_path = g_malloc (sizeof (char *));
1017                  * domain->search_path [0] = NULL;
1018                 */
1019                 mono_domain_assemblies_unlock (domain);
1020                 return;
1021         }
1022
1023         if (domain->search_path)
1024                 g_strfreev (domain->search_path);
1025
1026         domain->search_path = tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
1027         tmp [npaths] = NULL;
1028
1029         *tmp = mono_string_to_utf8 (setup->application_base);
1030
1031         /* FIXME: is this needed? */
1032         if (strncmp (*tmp, "file://", 7) == 0) {
1033                 gchar *file = *tmp;
1034                 gchar *uri = *tmp;
1035                 gchar *tmpuri;
1036
1037                 if (uri [7] != '/')
1038                         uri = g_strdup_printf ("file:///%s", uri + 7);
1039
1040                 tmpuri = uri;
1041                 uri = mono_escape_uri_string (tmpuri);
1042                 *tmp = g_filename_from_uri (uri, NULL, &error);
1043                 g_free (uri);
1044
1045                 if (tmpuri != file)
1046                         g_free (tmpuri);
1047
1048                 if (error != NULL) {
1049                         g_warning ("%s\n", error->message);
1050                         g_error_free (error);
1051                         *tmp = file;
1052                 } else {
1053                         g_free (file);
1054                 }
1055         }
1056
1057         for (i = 1; pvt_split && i < npaths; i++) {
1058                 if (g_path_is_absolute (pvt_split [i - 1])) {
1059                         tmp [i] = g_strdup (pvt_split [i - 1]);
1060                 } else {
1061                         tmp [i] = g_build_filename (tmp [0], pvt_split [i - 1], NULL);
1062                 }
1063
1064                 if (strchr (tmp [i], '.')) {
1065                         gchar *reduced;
1066                         gchar *freeme;
1067
1068                         reduced = mono_path_canonicalize (tmp [i]);
1069                         if (appbaselen == -1)
1070                                 appbaselen = strlen (tmp [0]);
1071
1072                         if (strncmp (tmp [0], reduced, appbaselen)) {
1073                                 g_free (reduced);
1074                                 g_free (tmp [i]);
1075                                 tmp [i] = g_strdup ("");
1076                                 continue;
1077                         }
1078
1079                         freeme = tmp [i];
1080                         tmp [i] = reduced;
1081                         g_free (freeme);
1082                 }
1083         }
1084
1085         if (setup->private_bin_path_probe != NULL) {
1086                 g_free (tmp [0]);
1087                 tmp [0] = g_strdup ("");
1088         }
1089
1090         domain->setup->path_changed = FALSE;
1091
1092         g_strfreev (pvt_split);
1093
1094         mono_domain_assemblies_unlock (domain);
1095 }
1096
1097 #ifdef DISABLE_SHADOW_COPY
1098 gboolean
1099 mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name)
1100 {
1101         return FALSE;
1102 }
1103
1104 char *
1105 mono_make_shadow_copy (const char *filename)
1106 {
1107         return (char *) filename;
1108 }
1109 #else
1110 static gboolean
1111 shadow_copy_sibling (gchar *src, gint srclen, const char *extension, gchar *target, gint targetlen, gint tail_len)
1112 {
1113         guint16 *orig, *dest;
1114         gboolean copy_result;
1115
1116         strcpy (src + srclen - tail_len, extension);
1117         if (!g_file_test (src, G_FILE_TEST_IS_REGULAR))
1118                 return TRUE;
1119         orig = g_utf8_to_utf16 (src, strlen (src), NULL, NULL, NULL);
1120
1121         strcpy (target + targetlen - tail_len, extension);
1122         dest = g_utf8_to_utf16 (target, strlen (target), NULL, NULL, NULL);
1123
1124         DeleteFile (dest);
1125         copy_result = CopyFile (orig, dest, FALSE);
1126         g_free (orig);
1127         g_free (dest);
1128
1129         return copy_result;
1130 }
1131
1132 static gint32
1133 get_cstring_hash (const char *str)
1134 {
1135         int len, i;
1136         const char *p;
1137         gint32 h = 0;
1138
1139         if (!str || !str [0])
1140                 return 0;
1141
1142         len = strlen (str);
1143         p = str;
1144         for (i = 0; i < len; i++) {
1145                 h = (h << 5) - h + *p;
1146                 p++;
1147         }
1148
1149         return h;
1150 }
1151
1152 static char *
1153 get_shadow_assembly_location_base (MonoDomain *domain)
1154 {
1155         MonoAppDomainSetup *setup;
1156         char *cache_path, *appname;
1157         char *userdir;
1158         char *location;
1159
1160         setup = domain->setup;
1161         if (setup->cache_path != NULL && setup->application_name != NULL) {
1162                 cache_path = mono_string_to_utf8 (setup->cache_path);
1163 #ifndef PLATFORM_WIN32
1164                 {
1165                         gint i;
1166                         for (i = strlen (cache_path) - 1; i >= 0; i--)
1167                                 if (cache_path [i] == '\\')
1168                                         cache_path [i] = '/';
1169                 }
1170 #endif
1171
1172                 appname = mono_string_to_utf8 (setup->application_name);
1173                 location = g_build_filename (cache_path, appname, "assembly", "shadow", NULL);
1174                 g_free (appname);
1175                 g_free (cache_path);
1176         } else {
1177                 userdir = g_strdup_printf ("%s-mono-cachepath", g_get_user_name ());
1178                 location = g_build_filename (g_get_tmp_dir (), userdir, "assembly", "shadow", NULL);
1179                 g_free (userdir);
1180         }
1181         return location;
1182 }
1183
1184 static char *
1185 get_shadow_assembly_location (const char *filename)
1186 {
1187         gint32 hash = 0, hash2 = 0;
1188         char name_hash [9];
1189         char path_hash [30];
1190         char *bname = g_path_get_basename (filename);
1191         char *dirname = g_path_get_dirname (filename);
1192         char *location, *tmploc;
1193         MonoDomain *domain = mono_domain_get ();
1194
1195         hash = get_cstring_hash (bname);
1196         hash2 = get_cstring_hash (dirname);
1197         g_snprintf (name_hash, sizeof (name_hash), "%08x", hash);
1198         g_snprintf (path_hash, sizeof (path_hash), "%08x_%08x_%08x", hash ^ hash2, hash2, domain->shadow_serial);
1199         tmploc = get_shadow_assembly_location_base (domain);
1200         location = g_build_filename (tmploc, name_hash, path_hash, bname, NULL);
1201         g_free (tmploc);
1202         g_free (bname);
1203         g_free (dirname);
1204         return location;
1205 }
1206
1207 static gboolean
1208 ensure_directory_exists (const char *filename)
1209 {
1210 #ifdef PLATFORM_WIN32
1211         gchar *dir_utf8 = g_path_get_dirname (filename);
1212         gunichar2 *p;
1213         gunichar2 *dir_utf16 = NULL;
1214         int retval;
1215
1216         if (!dir_utf8 || !dir_utf8 [0])
1217                 return FALSE;
1218
1219         dir_utf16 = g_utf8_to_utf16 (dir_utf8, strlen (dir_utf8), NULL, NULL, NULL);
1220         g_free (dir_utf8);
1221
1222         if (!dir_utf16)
1223                 return FALSE;
1224
1225         p = dir_utf16;
1226
1227         /* make life easy and only use one directory seperator */
1228         while (*p != '\0')
1229         {
1230                 if (*p == '/')
1231                         *p = '\\';
1232                 p++;
1233         }
1234
1235         p = dir_utf16;
1236
1237         /* get past C:\ )*/
1238         while (*p++ != '\\')
1239         {
1240         }
1241
1242         while (1) {
1243                 BOOL bRet = FALSE;
1244                 p = wcschr (p, '\\');
1245                 if (p)
1246                         *p = '\0';
1247                 retval = _wmkdir (dir_utf16);
1248                 if (retval != 0 && errno != EEXIST) {
1249                         g_free (dir_utf16);
1250                         return FALSE;
1251                 }
1252                 if (!p)
1253                         break;
1254                 *p++ = '\\';
1255         }
1256
1257         g_free (dir_utf16);
1258         return TRUE;
1259 #else
1260         char *p;
1261         gchar *dir = g_path_get_dirname (filename);
1262         int retval;
1263         struct stat sbuf;
1264
1265         if (!dir || !dir [0]) {
1266                 g_free (dir);
1267                 return FALSE;
1268         }
1269
1270         if (stat (dir, &sbuf) == 0 && S_ISDIR (sbuf.st_mode)) {
1271                 g_free (dir);
1272                 return TRUE;
1273         }
1274
1275         p = dir;
1276         while (*p == '/')
1277                 p++;
1278
1279         while (1) {
1280                 p = strchr (p, '/');
1281                 if (p)
1282                         *p = '\0';
1283                 retval = mkdir (dir, 0777);
1284                 if (retval != 0 && errno != EEXIST) {
1285                         g_free (dir);
1286                         return FALSE;
1287                 }
1288                 if (!p)
1289                         break;
1290                 *p++ = '/';
1291         }
1292
1293         g_free (dir);
1294         return TRUE;
1295 #endif
1296 }
1297
1298 static gboolean
1299 private_file_needs_copying (const char *src, struct stat *sbuf_src, char *dest)
1300 {
1301         struct stat sbuf_dest;
1302
1303         if (stat (src, sbuf_src) == -1 || stat (dest, &sbuf_dest) == -1)
1304                 return TRUE;
1305
1306         if (sbuf_src->st_mode == sbuf_dest.st_mode &&
1307             sbuf_src->st_size == sbuf_dest.st_size &&
1308             sbuf_src->st_mtime == sbuf_dest.st_mtime)
1309                 return FALSE;
1310
1311         return TRUE;
1312 }
1313
1314 static gboolean
1315 shadow_copy_create_ini (const char *shadow, const char *filename)
1316 {
1317         char *dir_name;
1318         char *ini_file;
1319         guint16 *u16_ini;
1320         gboolean result;
1321         guint32 n;
1322         HANDLE *handle;
1323         gchar *full_path;
1324
1325         dir_name = g_path_get_dirname (shadow);
1326         ini_file = g_build_filename (dir_name, "__AssemblyInfo__.ini", NULL);
1327         g_free (dir_name);
1328         if (g_file_test (ini_file, G_FILE_TEST_IS_REGULAR)) {
1329                 g_free (ini_file);
1330                 return TRUE;
1331         }
1332
1333         u16_ini = g_utf8_to_utf16 (ini_file, strlen (ini_file), NULL, NULL, NULL);
1334         g_free (ini_file);
1335         if (!u16_ini) {
1336                 return FALSE;
1337         }
1338         handle = CreateFile (u16_ini, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
1339                                 NULL, CREATE_NEW, FileAttributes_Normal, NULL);
1340         g_free (u16_ini);
1341         if (handle == INVALID_HANDLE_VALUE) {
1342                 return FALSE;
1343         }
1344
1345         full_path = mono_path_resolve_symlinks (filename);
1346         result = WriteFile (handle, full_path, strlen (full_path), &n, NULL);
1347         g_free (full_path);
1348         CloseHandle (handle);
1349         return result;
1350 }
1351
1352 gboolean
1353 mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name)
1354 {
1355         const char *version;
1356         MonoAppDomainSetup *setup;
1357         gchar *all_dirs;
1358         gchar **dir_ptr;
1359         gchar **directories;
1360         gchar *shadow_status_string;
1361         gchar *base_dir;
1362         gboolean shadow_enabled;
1363         gboolean found = FALSE;
1364
1365         if (domain == NULL)
1366                 return FALSE;
1367
1368         setup = domain->setup;
1369         if (setup == NULL || setup->shadow_copy_files == NULL)
1370                 return FALSE;
1371
1372         version = mono_get_runtime_info ()->framework_version;
1373         shadow_status_string = mono_string_to_utf8 (setup->shadow_copy_files);
1374         /* For 1.x, not NULL is enough. In 2.0 it has to be "true" */
1375         shadow_enabled = (*version <= '1' || !g_ascii_strncasecmp (shadow_status_string, "true", 4));
1376         g_free (shadow_status_string);
1377         if (!shadow_enabled)
1378                 return FALSE;
1379
1380         if (setup->shadow_copy_directories == NULL)
1381                 return TRUE;
1382
1383         /* Is dir_name a shadow_copy destination already? */
1384         base_dir = get_shadow_assembly_location_base (domain);
1385         if (strstr (dir_name, base_dir)) {
1386                 g_free (base_dir);
1387                 return TRUE;
1388         }
1389         g_free (base_dir);
1390
1391         all_dirs = mono_string_to_utf8 (setup->shadow_copy_directories);
1392         directories = g_strsplit (all_dirs, G_SEARCHPATH_SEPARATOR_S, 1000);
1393         dir_ptr = directories;
1394         while (*dir_ptr) {
1395                 if (**dir_ptr != '\0' && !strcmp (*dir_ptr, dir_name)) {
1396                         found = TRUE;
1397                         break;
1398                 }
1399                 dir_ptr++;
1400         }
1401         g_strfreev (directories);
1402         g_free (all_dirs);
1403         return found;
1404 }
1405
1406 char *
1407 mono_make_shadow_copy (const char *filename)
1408 {
1409         gchar *sibling_source, *sibling_target;
1410         gint sibling_source_len, sibling_target_len;
1411         guint16 *orig, *dest;
1412         char *shadow;
1413         gboolean copy_result;
1414         MonoException *exc;
1415         struct stat src_sbuf;
1416         struct utimbuf utbuf;
1417         char *dir_name = g_path_get_dirname (filename);
1418         MonoDomain *domain = mono_domain_get ();
1419         char *shadow_dir;
1420
1421         set_domain_search_path (domain);
1422
1423         if (!mono_is_shadow_copy_enabled (domain, dir_name)) {
1424                 g_free (dir_name);
1425                 return (char *) filename;
1426         }
1427         /* Is dir_name a shadow_copy destination already? */
1428         shadow_dir = get_shadow_assembly_location_base (domain);
1429         if (strstr (dir_name, shadow_dir)) {
1430                 g_free (shadow_dir);
1431                 g_free (dir_name);
1432                 return (char *) filename;
1433         }
1434         g_free (shadow_dir);
1435         g_free (dir_name);
1436
1437         shadow = get_shadow_assembly_location (filename);
1438         if (ensure_directory_exists (shadow) == FALSE) {
1439                 g_free (shadow);
1440                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy (ensure directory exists).");
1441                 mono_raise_exception (exc);
1442         }
1443
1444         if (!private_file_needs_copying (filename, &src_sbuf, shadow))
1445                 return (char*) shadow;
1446
1447         orig = g_utf8_to_utf16 (filename, strlen (filename), NULL, NULL, NULL);
1448         dest = g_utf8_to_utf16 (shadow, strlen (shadow), NULL, NULL, NULL);
1449         DeleteFile (dest);
1450         copy_result = CopyFile (orig, dest, FALSE);
1451         g_free (dest);
1452         g_free (orig);
1453
1454         if (copy_result == FALSE) {
1455                 g_free (shadow);
1456                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy (CopyFile).");
1457                 mono_raise_exception (exc);
1458         }
1459
1460         /* attempt to copy .mdb, .config if they exist */
1461         sibling_source = g_strconcat (filename, ".config", NULL);
1462         sibling_source_len = strlen (sibling_source);
1463         sibling_target = g_strconcat (shadow, ".config", NULL);
1464         sibling_target_len = strlen (sibling_target);
1465
1466         copy_result = shadow_copy_sibling (sibling_source, sibling_source_len, ".mdb", sibling_target, sibling_target_len, 7);
1467         if (copy_result == TRUE)
1468                 copy_result = shadow_copy_sibling (sibling_source, sibling_source_len, ".config", sibling_target, sibling_target_len, 7);
1469
1470         g_free (sibling_source);
1471         g_free (sibling_target);
1472
1473         if (copy_result == FALSE)  {
1474                 g_free (shadow);
1475                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy of sibling data (CopyFile).");
1476                 mono_raise_exception (exc);
1477         }
1478
1479         /* Create a .ini file containing the original assembly location */
1480         if (!shadow_copy_create_ini (shadow, filename)) {
1481                 g_free (shadow);
1482                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy .ini file.");
1483                 mono_raise_exception (exc);
1484         }
1485
1486         utbuf.actime = src_sbuf.st_atime;
1487         utbuf.modtime = src_sbuf.st_mtime;
1488         utime (shadow, &utbuf);
1489
1490         return shadow;
1491 }
1492 #endif /* DISABLE_SHADOW_COPY */
1493
1494 MonoDomain *
1495 mono_domain_from_appdomain (MonoAppDomain *appdomain)
1496 {
1497         if (appdomain == NULL)
1498                 return NULL;
1499
1500         return appdomain->data;
1501 }
1502
1503 static gboolean
1504 try_load_from (MonoAssembly **assembly, const gchar *path1, const gchar *path2,
1505                                         const gchar *path3, const gchar *path4,
1506                                         gboolean refonly, gboolean is_private)
1507 {
1508         gchar *fullpath;
1509         gboolean found = FALSE;
1510
1511         *assembly = NULL;
1512         fullpath = g_build_filename (path1, path2, path3, path4, NULL);
1513
1514         if (IS_PORTABILITY_SET) {
1515                 gchar *new_fullpath = mono_portability_find_file (fullpath, TRUE);
1516                 if (new_fullpath) {
1517                         g_free (fullpath);
1518                         fullpath = new_fullpath;
1519                         found = TRUE;
1520                 }
1521         } else
1522                 found = g_file_test (fullpath, G_FILE_TEST_IS_REGULAR);
1523
1524         if (found)
1525                 *assembly = mono_assembly_open_full (fullpath, NULL, refonly);
1526
1527         g_free (fullpath);
1528         return (*assembly != NULL);
1529 }
1530
1531 static MonoAssembly *
1532 real_load (gchar **search_path, const gchar *culture, const gchar *name, gboolean refonly)
1533 {
1534         MonoAssembly *result = NULL;
1535         gchar **path;
1536         gchar *filename;
1537         const gchar *local_culture;
1538         gint len;
1539         gboolean is_private = FALSE;
1540
1541         if (!culture || *culture == '\0') {
1542                 local_culture = "";
1543         } else {
1544                 local_culture = culture;
1545         }
1546
1547         filename =  g_strconcat (name, ".dll", NULL);
1548         len = strlen (filename);
1549
1550         for (path = search_path; *path; path++) {
1551                 if (**path == '\0') {
1552                         is_private = TRUE;
1553                         continue; /* Ignore empty ApplicationBase */
1554                 }
1555
1556                 /* See test cases in bug #58992 and bug #57710 */
1557                 /* 1st try: [culture]/[name].dll (culture may be empty) */
1558                 strcpy (filename + len - 4, ".dll");
1559                 if (try_load_from (&result, *path, local_culture, "", filename, refonly, is_private))
1560                         break;
1561
1562                 /* 2nd try: [culture]/[name].exe (culture may be empty) */
1563                 strcpy (filename + len - 4, ".exe");
1564                 if (try_load_from (&result, *path, local_culture, "", filename, refonly, is_private))
1565                         break;
1566
1567                 /* 3rd try: [culture]/[name]/[name].dll (culture may be empty) */
1568                 strcpy (filename + len - 4, ".dll");
1569                 if (try_load_from (&result, *path, local_culture, name, filename, refonly, is_private))
1570                         break;
1571
1572                 /* 4th try: [culture]/[name]/[name].exe (culture may be empty) */
1573                 strcpy (filename + len - 4, ".exe");
1574                 if (try_load_from (&result, *path, local_culture, name, filename, refonly, is_private))
1575                         break;
1576         }
1577
1578         g_free (filename);
1579         return result;
1580 }
1581
1582 /*
1583  * Try loading the assembly from ApplicationBase and PrivateBinPath
1584  * and then from assemblies_path if any.
1585  * LOCKING: This is called from the assembly loading code, which means the caller
1586  * might hold the loader lock. Thus, this function must not acquire the domain lock.
1587  */
1588 static MonoAssembly *
1589 mono_domain_assembly_preload (MonoAssemblyName *aname,
1590                               gchar **assemblies_path,
1591                               gpointer user_data)
1592 {
1593         MonoDomain *domain = mono_domain_get ();
1594         MonoAssembly *result = NULL;
1595         gboolean refonly = GPOINTER_TO_UINT (user_data);
1596
1597         set_domain_search_path (domain);
1598
1599         if (domain->search_path && domain->search_path [0] != NULL) {
1600                 result = real_load (domain->search_path, aname->culture, aname->name, refonly);
1601         }
1602
1603         if (result == NULL && assemblies_path && assemblies_path [0] != NULL) {
1604                 result = real_load (assemblies_path, aname->culture, aname->name, refonly);
1605         }
1606
1607         return result;
1608 }
1609
1610 /*
1611  * Check whenever a given assembly was already loaded in the current appdomain.
1612  */
1613 static MonoAssembly *
1614 mono_domain_assembly_search (MonoAssemblyName *aname,
1615                                                          gpointer user_data)
1616 {
1617         MonoDomain *domain = mono_domain_get ();
1618         GSList *tmp;
1619         MonoAssembly *ass;
1620         gboolean refonly = GPOINTER_TO_UINT (user_data);
1621
1622         mono_domain_assemblies_lock (domain);
1623         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
1624                 ass = tmp->data;
1625                 /* Dynamic assemblies can't match here in MS.NET */
1626                 if (ass->dynamic || refonly != ass->ref_only || !mono_assembly_names_equal (aname, &ass->aname))
1627                         continue;
1628
1629                 mono_domain_assemblies_unlock (domain);
1630                 return ass;
1631         }
1632         mono_domain_assemblies_unlock (domain);
1633
1634         return NULL;
1635 }
1636
1637 MonoReflectionAssembly *
1638 ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname, MonoBoolean refOnly)
1639 {
1640         MonoDomain *domain = mono_domain_get ();
1641         char *name, *filename;
1642         MonoImageOpenStatus status = MONO_IMAGE_OK;
1643         MonoAssembly *ass;
1644
1645         MONO_ARCH_SAVE_REGS;
1646
1647         if (fname == NULL) {
1648                 MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
1649                 mono_raise_exception (exc);
1650         }
1651
1652         name = filename = mono_string_to_utf8 (fname);
1653
1654         ass = mono_assembly_open_full (filename, &status, refOnly);
1655
1656         if (!ass){
1657                 MonoException *exc;
1658
1659                 if (status == MONO_IMAGE_IMAGE_INVALID)
1660                         exc = mono_get_exception_bad_image_format2 (NULL, fname);
1661                 else
1662                         exc = mono_get_exception_file_not_found2 (NULL, fname);
1663                 g_free (name);
1664                 mono_raise_exception (exc);
1665         }
1666
1667         g_free (name);
1668
1669         return mono_assembly_get_object (domain, ass);
1670 }
1671
1672 MonoReflectionAssembly *
1673 ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad,
1674                                             MonoArray *raw_assembly,
1675                                             MonoArray *raw_symbol_store, MonoObject *evidence,
1676                                             MonoBoolean refonly)
1677 {
1678         MonoAssembly *ass;
1679         MonoReflectionAssembly *refass = NULL;
1680         MonoDomain *domain = ad->data;
1681         MonoImageOpenStatus status;
1682         guint32 raw_assembly_len = mono_array_length (raw_assembly);
1683         MonoImage *image = mono_image_open_from_data_full (mono_array_addr (raw_assembly, gchar, 0), raw_assembly_len, TRUE, NULL, refonly);
1684
1685         if (!image) {
1686                 mono_raise_exception (mono_get_exception_bad_image_format (""));
1687                 return NULL;
1688         }
1689
1690         if (raw_symbol_store != NULL)
1691                 mono_debug_open_image_from_memory (image, mono_array_addr (raw_symbol_store, guint8, 0), mono_array_length (raw_symbol_store));
1692
1693         ass = mono_assembly_load_from_full (image, "", &status, refonly);
1694
1695
1696         if (!ass) {
1697                 mono_image_close (image);
1698                 mono_raise_exception (mono_get_exception_bad_image_format (""));
1699                 return NULL;
1700         }
1701
1702         refass = mono_assembly_get_object (domain, ass);
1703         MONO_OBJECT_SETREF (refass, evidence, evidence);
1704         return refass;
1705 }
1706
1707 MonoReflectionAssembly *
1708 ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoString *assRef, MonoObject *evidence, MonoBoolean refOnly)
1709 {
1710         MonoDomain *domain = ad->data;
1711         MonoImageOpenStatus status = MONO_IMAGE_OK;
1712         MonoAssembly *ass;
1713         MonoAssemblyName aname;
1714         MonoReflectionAssembly *refass = NULL;
1715         gchar *name;
1716         gboolean parsed;
1717
1718         MONO_ARCH_SAVE_REGS;
1719
1720         g_assert (assRef != NULL);
1721
1722         name = mono_string_to_utf8 (assRef);
1723         parsed = mono_assembly_name_parse (name, &aname);
1724         g_free (name);
1725
1726         if (!parsed) {
1727                 /* This is a parse error... */
1728                 return NULL;
1729         }
1730
1731         ass = mono_assembly_load_full_nosearch (&aname, NULL, &status, refOnly);
1732         mono_assembly_name_free (&aname);
1733
1734         if (!ass) {
1735                 /* MS.NET doesn't seem to call the assembly resolve handler for refonly assemblies */
1736                 if (!refOnly)
1737                         refass = mono_try_assembly_resolve (domain, assRef, refOnly);
1738                 else
1739                         refass = NULL;
1740                 if (!refass) {
1741                         return NULL;
1742                 }
1743         }
1744
1745         if (refass == NULL)
1746                 refass = mono_assembly_get_object (domain, ass);
1747
1748         MONO_OBJECT_SETREF (refass, evidence, evidence);
1749         return refass;
1750 }
1751
1752 void
1753 ves_icall_System_AppDomain_InternalUnload (gint32 domain_id)
1754 {
1755         MonoDomain * domain = mono_domain_get_by_id (domain_id);
1756
1757         MONO_ARCH_SAVE_REGS;
1758
1759         if (NULL == domain) {
1760                 MonoException *exc = mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
1761                 mono_raise_exception (exc);
1762         }
1763
1764         if (domain == mono_get_root_domain ()) {
1765                 mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("The default appdomain can not be unloaded."));
1766                 return;
1767         }
1768
1769         /*
1770          * Unloading seems to cause problems when running NUnit/NAnt, hence
1771          * this workaround.
1772          */
1773         if (g_getenv ("MONO_NO_UNLOAD"))
1774                 return;
1775
1776         mono_domain_unload (domain);
1777 }
1778
1779 gboolean
1780 ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id)
1781 {
1782         MonoDomain *domain = mono_domain_get_by_id (domain_id);
1783
1784         if (!domain)
1785                 return TRUE;
1786
1787         return mono_domain_is_unloading (domain);
1788 }
1789
1790 gint32
1791 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad,
1792                                                                                         MonoReflectionAssembly *refass, MonoArray *args)
1793 {
1794         MonoImage *image;
1795         MonoMethod *method;
1796
1797         MONO_ARCH_SAVE_REGS;
1798
1799         g_assert (refass);
1800         image = refass->assembly->image;
1801         g_assert (image);
1802
1803         method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
1804
1805         if (!method)
1806                 g_error ("No entry point method found in %s", image->name);
1807
1808         if (!args)
1809                 args = (MonoArray *) mono_array_new (ad->data, mono_defaults.string_class, 0);
1810
1811         return mono_runtime_exec_main (method, (MonoArray *)args, NULL);
1812 }
1813
1814 gint32
1815 ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad)
1816 {
1817         MONO_ARCH_SAVE_REGS;
1818
1819         return ad->data->domain_id;
1820 }
1821
1822 MonoAppDomain *
1823 ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad)
1824 {
1825         MonoDomain *old_domain = mono_domain_get();
1826
1827         MONO_ARCH_SAVE_REGS;
1828
1829         if (!mono_domain_set (ad->data, FALSE))
1830                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1831
1832         return old_domain->domain;
1833 }
1834
1835 MonoAppDomain *
1836 ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid)
1837 {
1838         MonoDomain *current_domain = mono_domain_get ();
1839         MonoDomain *domain = mono_domain_get_by_id (domainid);
1840
1841         MONO_ARCH_SAVE_REGS;
1842
1843         if (!domain || !mono_domain_set (domain, FALSE))
1844                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1845
1846         return current_domain->domain;
1847 }
1848
1849 void
1850 ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad)
1851 {
1852         MONO_ARCH_SAVE_REGS;
1853
1854         mono_thread_push_appdomain_ref (ad->data);
1855 }
1856
1857 void
1858 ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id)
1859 {
1860         MonoDomain *domain = mono_domain_get_by_id (domain_id);
1861
1862         MONO_ARCH_SAVE_REGS;
1863
1864         if (!domain)
1865                 /*
1866                  * Raise an exception to prevent the managed code from executing a pop
1867                  * later.
1868                  */
1869                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
1870
1871         mono_thread_push_appdomain_ref (domain);
1872 }
1873
1874 void
1875 ves_icall_System_AppDomain_InternalPopDomainRef (void)
1876 {
1877         MONO_ARCH_SAVE_REGS;
1878
1879         mono_thread_pop_appdomain_ref ();
1880 }
1881
1882 MonoAppContext *
1883 ves_icall_System_AppDomain_InternalGetContext ()
1884 {
1885         MONO_ARCH_SAVE_REGS;
1886
1887         return mono_context_get ();
1888 }
1889
1890 MonoAppContext *
1891 ves_icall_System_AppDomain_InternalGetDefaultContext ()
1892 {
1893         MONO_ARCH_SAVE_REGS;
1894
1895         return mono_domain_get ()->default_context;
1896 }
1897
1898 MonoAppContext *
1899 ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc)
1900 {
1901         MonoAppContext *old_context = mono_context_get ();
1902
1903         MONO_ARCH_SAVE_REGS;
1904
1905         mono_context_set (mc);
1906
1907         return old_context;
1908 }
1909
1910 MonoString *
1911 ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid)
1912 {
1913         MonoDomain* mono_root_domain = mono_get_root_domain ();
1914         mono_domain_lock (mono_root_domain);
1915         if (process_guid_set) {
1916                 mono_domain_unlock (mono_root_domain);
1917                 return mono_string_new_utf16 (mono_domain_get (), process_guid, sizeof(process_guid)/2);
1918         }
1919         memcpy (process_guid, mono_string_chars(newguid), sizeof(process_guid));
1920         process_guid_set = TRUE;
1921         mono_domain_unlock (mono_root_domain);
1922         return newguid;
1923 }
1924
1925 gboolean
1926 mono_domain_is_unloading (MonoDomain *domain)
1927 {
1928         if (domain->state == MONO_APPDOMAIN_UNLOADING || domain->state == MONO_APPDOMAIN_UNLOADED)
1929                 return TRUE;
1930         else
1931                 return FALSE;
1932 }
1933
1934 static void
1935 clear_cached_vtable (gpointer key, gpointer value, gpointer user_data)
1936 {
1937         MonoClass *klass = (MonoClass*)key;
1938         MonoDomain *domain = (MonoDomain*)user_data;
1939         MonoClassRuntimeInfo *runtime_info;
1940
1941         runtime_info = klass->runtime_info;
1942         if (runtime_info && runtime_info->max_domain >= domain->domain_id)
1943                 runtime_info->domain_vtables [domain->domain_id] = NULL;
1944 }
1945
1946 typedef struct unload_data {
1947         MonoDomain *domain;
1948         char *failure_reason;
1949 } unload_data;
1950
1951
1952 static guint32 WINAPI
1953 unload_thread_main (void *arg)
1954 {
1955         unload_data *data = (unload_data*)arg;
1956         MonoDomain *domain = data->domain;
1957
1958         /* Have to attach to the runtime so shutdown can wait for this thread */
1959         mono_thread_attach (mono_get_root_domain ());
1960
1961         /*
1962          * FIXME: Abort our parent thread last, so we can return a failure
1963          * indication if aborting times out.
1964          */
1965         if (!mono_threads_abort_appdomain_threads (domain, -1)) {
1966                 data->failure_reason = g_strdup_printf ("Aborting of threads in domain %s timed out.", domain->friendly_name);
1967                 return 1;
1968         }
1969
1970         if (!mono_thread_pool_remove_domain_jobs (domain, -1)) {
1971                 data->failure_reason = g_strdup_printf ("Cleanup of threadpool jobs of domain %s timed out.", domain->friendly_name);
1972                 return 1;
1973         }
1974
1975         /* Finalize all finalizable objects in the doomed appdomain */
1976         if (!mono_domain_finalize (domain, -1)) {
1977                 data->failure_reason = g_strdup_printf ("Finalization of domain %s timed out.", domain->friendly_name);
1978                 return 1;
1979         }
1980
1981         /* Clear references to our vtables in class->runtime_info.
1982          * We also hold the loader lock because we're going to change
1983          * class->runtime_info.
1984          */
1985
1986         mono_loader_lock ();
1987         mono_domain_lock (domain);
1988         g_hash_table_foreach (domain->class_vtable_hash, clear_cached_vtable, domain);
1989         mono_domain_unlock (domain);
1990         mono_loader_unlock ();
1991
1992         mono_threads_clear_cached_culture (domain);
1993
1994         domain->state = MONO_APPDOMAIN_UNLOADED;
1995
1996         /* printf ("UNLOADED %s.\n", domain->friendly_name); */
1997
1998         /* remove from the handle table the items related to this domain */
1999         mono_gchandle_free_domain (domain);
2000
2001         mono_domain_free (domain, FALSE);
2002
2003         mono_gc_collect (mono_gc_max_generation ());
2004
2005         return 0;
2006 }
2007
2008 /*
2009  * mono_domain_unload:
2010  * @domain: The domain to unload
2011  *
2012  *  Unloads an appdomain. Follows the process outlined in:
2013  *  http://blogs.gotdotnet.com/cbrumme
2014  *
2015  *  If doing things the 'right' way is too hard or complex, we do it the
2016  *  'simple' way, which means do everything needed to avoid crashes and
2017  *  memory leaks, but not much else.
2018  */
2019 void
2020 mono_domain_unload (MonoDomain *domain)
2021 {
2022         HANDLE thread_handle;
2023         gsize tid;
2024         guint32 res;
2025         MonoAppDomainState prev_state;
2026         MonoMethod *method;
2027         MonoObject *exc;
2028         unload_data thread_data;
2029         MonoDomain *caller_domain = mono_domain_get ();
2030
2031         /* printf ("UNLOAD STARTING FOR %s (%p) IN THREAD 0x%x.\n", domain->friendly_name, domain, GetCurrentThreadId ()); */
2032
2033         /* Atomically change our state to UNLOADING */
2034         prev_state = InterlockedCompareExchange ((gint32*)&domain->state,
2035                                                                                          MONO_APPDOMAIN_UNLOADING_START,
2036                                                                                          MONO_APPDOMAIN_CREATED);
2037         if (prev_state != MONO_APPDOMAIN_CREATED) {
2038                 switch (prev_state) {
2039                 case MONO_APPDOMAIN_UNLOADING_START:
2040                 case MONO_APPDOMAIN_UNLOADING:
2041                         mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("Appdomain is already being unloaded."));
2042                         break;
2043                 case MONO_APPDOMAIN_UNLOADED:
2044                         mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("Appdomain is already unloaded."));
2045                         break;
2046                 default:
2047                         g_warning ("Incalid appdomain state %d", prev_state);
2048                         g_assert_not_reached ();
2049                 }
2050         }
2051
2052         mono_domain_set (domain, FALSE);
2053         /* Notify OnDomainUnload listeners */
2054         method = mono_class_get_method_from_name (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload", -1);
2055         g_assert (method);
2056
2057         exc = NULL;
2058         mono_runtime_invoke (method, domain->domain, NULL, &exc);
2059         if (exc) {
2060                 /* Roll back the state change */
2061                 domain->state = MONO_APPDOMAIN_CREATED;
2062                 mono_domain_set (caller_domain, FALSE);
2063                 mono_raise_exception ((MonoException*)exc);
2064         }
2065
2066         thread_data.domain = domain;
2067         thread_data.failure_reason = NULL;
2068
2069         /*The managed callback finished successfully, now we start tearing down the appdomain*/
2070         domain->state = MONO_APPDOMAIN_UNLOADING;
2071         /*
2072          * First we create a separate thread for unloading, since
2073          * we might have to abort some threads, including the current one.
2074          */
2075         /*
2076          * If we create a non-suspended thread, the runtime will hang.
2077          * See:
2078          * http://bugzilla.ximian.com/show_bug.cgi?id=27663
2079          */
2080 #if 0
2081         thread_handle = CreateThread (NULL, 0, unload_thread_main, &thread_data, 0, &tid);
2082 #else
2083         thread_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE)unload_thread_main, &thread_data, CREATE_SUSPENDED, &tid);
2084         if (thread_handle == NULL) {
2085                 return;
2086         }
2087         ResumeThread (thread_handle);
2088 #endif
2089
2090         /* Wait for the thread */
2091         while ((res = WaitForSingleObjectEx (thread_handle, INFINITE, TRUE) == WAIT_IO_COMPLETION)) {
2092                 if (mono_thread_has_appdomain_ref (mono_thread_current (), domain) && (mono_thread_interruption_requested ()))
2093                         /* The unload thread tries to abort us */
2094                         /* The icall wrapper will execute the abort */
2095                         CloseHandle (thread_handle);
2096                         return;
2097         }
2098         CloseHandle (thread_handle);
2099
2100         mono_domain_set (caller_domain, FALSE);
2101
2102         if (thread_data.failure_reason) {
2103                 MonoException *ex;
2104
2105                 /* Roll back the state change */
2106                 domain->state = MONO_APPDOMAIN_CREATED;
2107
2108                 g_warning (thread_data.failure_reason);
2109
2110                 ex = mono_get_exception_cannot_unload_appdomain (thread_data.failure_reason);
2111
2112                 g_free (thread_data.failure_reason);
2113                 thread_data.failure_reason = NULL;
2114
2115                 mono_raise_exception (ex);
2116         }
2117 }