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