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