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 110
  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 #ifdef DISABLE_APPDOMAINS
 868         mono_raise_exception (mono_get_exception_not_supported ("AppDomain creation is not supported on this runtime."));
 869         return NULL;
 870 #else
 871         char *fname = mono_string_to_utf8 (friendly_name);
 872         MonoAppDomain *ad = mono_domain_create_appdomain_internal (fname, setup);
 873
 874         g_free (fname);
 875
 876         return ad;
 877 #endif
 878 }
 879
 880 MonoArray *
 881 ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad, MonoBoolean refonly)
 882 {
 883         MonoDomain *domain = ad->data;
 884         MonoAssembly* ass;
 885         static MonoClass *System_Reflection_Assembly;
 886         MonoArray *res;
 887         GSList *tmp;
 888         int i;
 889         GPtrArray *assemblies;
 890
 891         MONO_ARCH_SAVE_REGS;
 892
 893         if (!System_Reflection_Assembly)
 894                 System_Reflection_Assembly = mono_class_from_name (
 895                         mono_defaults.corlib, "System.Reflection", "Assembly");
 896
 897         /*
 898          * Make a copy of the list of assemblies because we can't hold the assemblies
 899          * lock while creating objects etc.
 900          */
 901         assemblies = g_ptr_array_new ();
 902         /* Need to skip internal assembly builders created by remoting */
 903         mono_domain_assemblies_lock (domain);
 904         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
 905                 ass = tmp->data;
 906                 if (refonly != ass->ref_only)
 907                         continue;
 908                 if (ass->corlib_internal)
 909                         continue;
 910                 g_ptr_array_add (assemblies, ass);
 911         }
 912         mono_domain_assemblies_unlock (domain);
 913
 914         res = mono_array_new (domain, System_Reflection_Assembly, assemblies->len);
 915         for (i = 0; i < assemblies->len; ++i) {
 916                 ass = g_ptr_array_index (assemblies, i);
 917                 mono_array_setref (res, i, mono_assembly_get_object (domain, ass));
 918         }
 919
 920         g_ptr_array_free (assemblies, TRUE);
 921
 922         return res;
 923 }
 924
 925 MonoReflectionAssembly *
 926 mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, gboolean refonly)
 927 {
 928         MonoClass *klass;
 929         MonoMethod *method;
 930         MonoBoolean isrefonly;
 931         gpointer params [2];
 932
 933         if (mono_runtime_get_no_exec ())
 934                 return NULL;
 935
 936         g_assert (domain != NULL && fname != NULL);
 937
 938         klass = domain->domain->mbr.obj.vtable->klass;
 939         g_assert (klass);
 940
 941         method = mono_class_get_method_from_name (klass, "DoAssemblyResolve", -1);
 942         if (method == NULL) {
 943                 g_warning ("Method AppDomain.DoAssemblyResolve not found.\n");
 944                 return NULL;
 945         }
 946
 947         isrefonly = refonly ? 1 : 0;
 948         params [0] = fname;
 949         params [1] = &isrefonly;
 950         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 951 }
 952
 953 static MonoAssembly *
 954 mono_domain_assembly_postload_search (MonoAssemblyName *aname,
 955                                                                           gpointer user_data)
 956 {
 957         gboolean refonly = GPOINTER_TO_UINT (user_data);
 958         MonoReflectionAssembly *assembly;
 959         MonoDomain *domain = mono_domain_get ();
 960         char *aname_str;
 961         MonoString *str;
 962
 963         aname_str = mono_stringify_assembly_name (aname);
 964
 965         /* FIXME: We invoke managed code here, so there is a potential for deadlocks */
 966         str = mono_string_new (domain, aname_str);
 967         if (!str) {
 968                 g_free (aname_str);
 969                 return NULL;
 970         }
 971         assembly = mono_try_assembly_resolve (domain, str, refonly);
 972         g_free (aname_str);
 973
 974         if (assembly)
 975                 return assembly->assembly;
 976         else
 977                 return NULL;
 978 }
 979
 980 /*
 981  * LOCKING: assumes assemblies_lock in the domain is already locked.
 982  */
 983 static void
 984 add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass, GHashTable *ht)
 985 {
 986         gint i;
 987         GSList *tmp;
 988         gboolean destroy_ht = FALSE;
 989
 990         if (!ass->aname.name)
 991                 return;
 992
 993         if (!ht) {
 994                 ht = g_hash_table_new (mono_aligned_addr_hash, NULL);
 995                 destroy_ht = TRUE;
 996         }
 997
 998         /* FIXME: handle lazy loaded assemblies */
 999         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
1000                 g_hash_table_insert (ht, tmp->data, tmp->data);
1001         }
1002         if (!g_hash_table_lookup (ht, ass)) {
1003                 mono_assembly_addref (ass);
1004                 g_hash_table_insert (ht, ass, ass);
1005                 domain->domain_assemblies = g_slist_append (domain->domain_assemblies, ass);
1006                 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);
1007         }
1008
1009         if (ass->image->references) {
1010                 for (i = 0; ass->image->references [i] != NULL; i++) {
1011                         if (ass->image->references [i] != REFERENCE_MISSING)
1012                                 if (!g_hash_table_lookup (ht, ass->image->references [i])) {
1013                                         add_assemblies_to_domain (domain, ass->image->references [i], ht);
1014                                 }
1015                 }
1016         }
1017         if (destroy_ht)
1018                 g_hash_table_destroy (ht);
1019 }
1020
1021 static void
1022 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data)
1023 {
1024         static MonoClassField *assembly_load_field;
1025         static MonoMethod *assembly_load_method;
1026         MonoDomain *domain = mono_domain_get ();
1027         MonoReflectionAssembly *ref_assembly;
1028         MonoClass *klass;
1029         gpointer load_value;
1030         void *params [1];
1031
1032         if (!domain->domain)
1033                 /* This can happen during startup */
1034                 return;
1035 #ifdef ASSEMBLY_LOAD_DEBUG
1036         fprintf (stderr, "Loading %s into domain %s\n", assembly->aname.name, domain->friendly_name);
1037 #endif
1038         klass = domain->domain->mbr.obj.vtable->klass;
1039
1040         mono_domain_assemblies_lock (domain);
1041         add_assemblies_to_domain (domain, assembly, NULL);
1042         mono_domain_assemblies_unlock (domain);
1043
1044         if (assembly_load_field == NULL) {
1045                 assembly_load_field = mono_class_get_field_from_name (klass, "AssemblyLoad");
1046                 g_assert (assembly_load_field);
1047         }
1048
1049         mono_field_get_value ((MonoObject*) domain->domain, assembly_load_field, &load_value);
1050         if (load_value == NULL) {
1051                 /* No events waiting to be triggered */
1052                 return;
1053         }
1054
1055         ref_assembly = mono_assembly_get_object (domain, assembly);
1056         g_assert (ref_assembly);
1057
1058         if (assembly_load_method == NULL) {
1059                 assembly_load_method = mono_class_get_method_from_name (klass, "DoAssemblyLoad", -1);
1060                 g_assert (assembly_load_method);
1061         }
1062
1063         *params = ref_assembly;
1064         mono_runtime_invoke (assembly_load_method, domain->domain, params, NULL);
1065 }
1066
1067 /*
1068  * LOCKING: Acquires the domain assemblies lock.
1069  */
1070 static void
1071 set_domain_search_path (MonoDomain *domain)
1072 {
1073         MonoError error;
1074         MonoAppDomainSetup *setup;
1075         gchar **tmp;
1076         gchar *search_path = NULL;
1077         gint i;
1078         gint npaths = 0;
1079         gchar **pvt_split = NULL;
1080         GError *gerror = NULL;
1081         gint appbaselen = -1;
1082
1083         /*
1084          * We use the low-level domain assemblies lock, since this is called from
1085          * assembly loads hooks, which means this thread might hold the loader lock.
1086          */
1087         mono_domain_assemblies_lock (domain);
1088
1089         if (!domain->setup) {
1090                 mono_domain_assemblies_unlock (domain);
1091                 return;
1092         }
1093
1094         if ((domain->search_path != NULL) && !domain->setup->path_changed) {
1095                 mono_domain_assemblies_unlock (domain);
1096                 return;
1097         }
1098         setup = domain->setup;
1099         if (!setup->application_base) {
1100                 mono_domain_assemblies_unlock (domain);
1101                 return; /* Must set application base to get private path working */
1102         }
1103
1104         npaths++;
1105
1106         if (setup->private_bin_path) {
1107                 search_path = mono_string_to_utf8_checked (setup->private_bin_path, &error);
1108                 if (!mono_error_ok (&error)) { /*FIXME maybe we should bubble up the error.*/
1109                         g_warning ("Could not decode AppDomain search path since it contains invalid characters");
1110                         mono_error_cleanup (&error);
1111                         mono_domain_assemblies_unlock (domain);
1112                         return;
1113                 }
1114         }
1115
1116         if (domain->private_bin_path) {
1117                 if (search_path == NULL)
1118                         search_path = domain->private_bin_path;
1119                 else {
1120                         gchar *tmp2 = search_path;
1121                         search_path = g_strjoin (";", search_path, domain->private_bin_path, NULL);
1122                         g_free (tmp2);
1123                 }
1124         }
1125
1126         if (search_path) {
1127                 /*
1128                  * As per MSDN documentation, AppDomainSetup.PrivateBinPath contains a list of
1129                  * directories relative to ApplicationBase separated by semicolons (see
1130                  * http://msdn2.microsoft.com/en-us/library/system.appdomainsetup.privatebinpath.aspx)
1131                  * The loop below copes with the fact that some Unix applications may use ':' (or
1132                  * System.IO.Path.PathSeparator) as the path search separator. We replace it with
1133                  * ';' for the subsequent split.
1134                  *
1135                  * The issue was reported in bug #81446
1136                  */
1137
1138 #ifndef TARGET_WIN32
1139                 gint slen;
1140
1141                 slen = strlen (search_path);
1142                 for (i = 0; i < slen; i++)
1143                         if (search_path [i] == ':')
1144                                 search_path [i] = ';';
1145 #endif
1146
1147                 pvt_split = g_strsplit (search_path, ";", 1000);
1148                 g_free (search_path);
1149                 for (tmp = pvt_split; *tmp; tmp++, npaths++);
1150         }
1151
1152         if (!npaths) {
1153                 if (pvt_split)
1154                         g_strfreev (pvt_split);
1155                 /*
1156                  * Don't do this because the first time is called, the domain
1157                  * setup is not finished.
1158                  *
1159                  * domain->search_path = g_malloc (sizeof (char *));
1160                  * domain->search_path [0] = NULL;
1161                 */
1162                 mono_domain_assemblies_unlock (domain);
1163                 return;
1164         }
1165
1166         if (domain->search_path)
1167                 g_strfreev (domain->search_path);
1168
1169         tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
1170         tmp [npaths] = NULL;
1171
1172         *tmp = mono_string_to_utf8_checked (setup->application_base, &error);
1173         if (!mono_error_ok (&error)) {
1174                 mono_error_cleanup (&error);
1175                 g_strfreev (pvt_split);
1176                 g_free (tmp);
1177
1178                 mono_domain_assemblies_unlock (domain);
1179                 return;
1180         }
1181
1182         domain->search_path = tmp;
1183
1184         /* FIXME: is this needed? */
1185         if (strncmp (*tmp, "file://", 7) == 0) {
1186                 gchar *file = *tmp;
1187                 gchar *uri = *tmp;
1188                 gchar *tmpuri;
1189
1190                 if (uri [7] != '/')
1191                         uri = g_strdup_printf ("file:///%s", uri + 7);
1192
1193                 tmpuri = uri;
1194                 uri = mono_escape_uri_string (tmpuri);
1195                 *tmp = g_filename_from_uri (uri, NULL, &gerror);
1196                 g_free (uri);
1197
1198                 if (tmpuri != file)
1199                         g_free (tmpuri);
1200
1201                 if (gerror != NULL) {
1202                         g_warning ("%s\n", gerror->message);
1203                         g_error_free (gerror);
1204                         *tmp = file;
1205                 } else {
1206                         g_free (file);
1207                 }
1208         }
1209
1210         for (i = 1; pvt_split && i < npaths; i++) {
1211                 if (g_path_is_absolute (pvt_split [i - 1])) {
1212                         tmp [i] = g_strdup (pvt_split [i - 1]);
1213                 } else {
1214                         tmp [i] = g_build_filename (tmp [0], pvt_split [i - 1], NULL);
1215                 }
1216
1217                 if (strchr (tmp [i], '.')) {
1218                         gchar *reduced;
1219                         gchar *freeme;
1220
1221                         reduced = mono_path_canonicalize (tmp [i]);
1222                         if (appbaselen == -1)
1223                                 appbaselen = strlen (tmp [0]);
1224
1225                         if (strncmp (tmp [0], reduced, appbaselen)) {
1226                                 g_free (reduced);
1227                                 g_free (tmp [i]);
1228                                 tmp [i] = g_strdup ("");
1229                                 continue;
1230                         }
1231
1232                         freeme = tmp [i];
1233                         tmp [i] = reduced;
1234                         g_free (freeme);
1235                 }
1236         }
1237
1238         if (setup->private_bin_path_probe != NULL) {
1239                 g_free (tmp [0]);
1240                 tmp [0] = g_strdup ("");
1241         }
1242
1243         domain->setup->path_changed = FALSE;
1244
1245         g_strfreev (pvt_split);
1246
1247         mono_domain_assemblies_unlock (domain);
1248 }
1249
1250 #ifdef DISABLE_SHADOW_COPY
1251 gboolean
1252 mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name)
1253 {
1254         return FALSE;
1255 }
1256
1257 char *
1258 mono_make_shadow_copy (const char *filename)
1259 {
1260         return (char *) filename;
1261 }
1262 #else
1263 static gboolean
1264 shadow_copy_sibling (gchar *src, gint srclen, const char *extension, gchar *target, gint targetlen, gint tail_len)
1265 {
1266         guint16 *orig, *dest;
1267         gboolean copy_result;
1268
1269         strcpy (src + srclen - tail_len, extension);
1270
1271         if (IS_PORTABILITY_CASE) {
1272                 gchar *file = mono_portability_find_file (src, TRUE);
1273
1274                 if (file == NULL)
1275                         return TRUE;
1276
1277                 g_free (file);
1278         } else if (!g_file_test (src, G_FILE_TEST_IS_REGULAR)) {
1279                 return TRUE;
1280         }
1281
1282         orig = g_utf8_to_utf16 (src, strlen (src), NULL, NULL, NULL);
1283
1284         strcpy (target + targetlen - tail_len, extension);
1285         dest = g_utf8_to_utf16 (target, strlen (target), NULL, NULL, NULL);
1286
1287         DeleteFile (dest);
1288         copy_result = CopyFile (orig, dest, FALSE);
1289
1290         /* Fix for bug #556884 - make sure the files have the correct mode so that they can be
1291          * overwritten when updated in their original locations. */
1292         if (copy_result)
1293                 copy_result = SetFileAttributes (dest, FILE_ATTRIBUTE_NORMAL);
1294
1295         g_free (orig);
1296         g_free (dest);
1297
1298         return copy_result;
1299 }
1300
1301 static gint32
1302 get_cstring_hash (const char *str)
1303 {
1304         int len, i;
1305         const char *p;
1306         gint32 h = 0;
1307
1308         if (!str || !str [0])
1309                 return 0;
1310
1311         len = strlen (str);
1312         p = str;
1313         for (i = 0; i < len; i++) {
1314                 h = (h << 5) - h + *p;
1315                 p++;
1316         }
1317
1318         return h;
1319 }
1320
1321 /*
1322  * Returned memory is malloc'd. Called must free it
1323  */
1324 static char *
1325 get_shadow_assembly_location_base (MonoDomain *domain, MonoError *error)
1326 {
1327         MonoAppDomainSetup *setup;
1328         char *cache_path, *appname;
1329         char *userdir;
1330         char *location;
1331
1332         mono_error_init (error);
1333
1334         setup = domain->setup;
1335         if (setup->cache_path != NULL && setup->application_name != NULL) {
1336                 cache_path = mono_string_to_utf8_checked (setup->cache_path, error);
1337                 if (!mono_error_ok (error))
1338                         return NULL;
1339 #ifndef TARGET_WIN32
1340                 {
1341                         gint i;
1342                         for (i = strlen (cache_path) - 1; i >= 0; i--)
1343                                 if (cache_path [i] == '\\')
1344                                         cache_path [i] = '/';
1345                 }
1346 #endif
1347
1348                 appname = mono_string_to_utf8_checked (setup->application_name, error);
1349                 if (!mono_error_ok (error)) {
1350                         g_free (cache_path);
1351                         return NULL;
1352                 }
1353
1354                 location = g_build_filename (cache_path, appname, "assembly", "shadow", NULL);
1355                 g_free (appname);
1356                 g_free (cache_path);
1357         } else {
1358                 userdir = g_strdup_printf ("%s-mono-cachepath", g_get_user_name ());
1359                 location = g_build_filename (g_get_tmp_dir (), userdir, "assembly", "shadow", NULL);
1360                 g_free (userdir);
1361         }
1362         return location;
1363 }
1364
1365 static char *
1366 get_shadow_assembly_location (const char *filename, MonoError *error)
1367 {
1368         gint32 hash = 0, hash2 = 0;
1369         char name_hash [9];
1370         char path_hash [30];
1371         char *bname = g_path_get_basename (filename);
1372         char *dirname = g_path_get_dirname (filename);
1373         char *location, *tmploc;
1374         MonoDomain *domain = mono_domain_get ();
1375
1376         mono_error_init (error);
1377
1378         hash = get_cstring_hash (bname);
1379         hash2 = get_cstring_hash (dirname);
1380         g_snprintf (name_hash, sizeof (name_hash), "%08x", hash);
1381         g_snprintf (path_hash, sizeof (path_hash), "%08x_%08x_%08x", hash ^ hash2, hash2, domain->shadow_serial);
1382         tmploc = get_shadow_assembly_location_base (domain, error);
1383         if (!mono_error_ok (error)) {
1384                 g_free (bname);
1385                 g_free (dirname);
1386                 return NULL;
1387         }
1388
1389         location = g_build_filename (tmploc, name_hash, path_hash, bname, NULL);
1390         g_free (tmploc);
1391         g_free (bname);
1392         g_free (dirname);
1393         return location;
1394 }
1395
1396 static gboolean
1397 ensure_directory_exists (const char *filename)
1398 {
1399 #ifdef HOST_WIN32
1400         gchar *dir_utf8 = g_path_get_dirname (filename);
1401         gunichar2 *p;
1402         gunichar2 *dir_utf16 = NULL;
1403         int retval;
1404
1405         if (!dir_utf8 || !dir_utf8 [0])
1406                 return FALSE;
1407
1408         dir_utf16 = g_utf8_to_utf16 (dir_utf8, strlen (dir_utf8), NULL, NULL, NULL);
1409         g_free (dir_utf8);
1410
1411         if (!dir_utf16)
1412                 return FALSE;
1413
1414         p = dir_utf16;
1415
1416         /* make life easy and only use one directory seperator */
1417         while (*p != '\0')
1418         {
1419                 if (*p == '/')
1420                         *p = '\\';
1421                 p++;
1422         }
1423
1424         p = dir_utf16;
1425
1426         /* get past C:\ )*/
1427         while (*p++ != '\\')
1428         {
1429         }
1430
1431         while (1) {
1432                 BOOL bRet = FALSE;
1433                 p = wcschr (p, '\\');
1434                 if (p)
1435                         *p = '\0';
1436                 retval = _wmkdir (dir_utf16);
1437                 if (retval != 0 && errno != EEXIST) {
1438                         g_free (dir_utf16);
1439                         return FALSE;
1440                 }
1441                 if (!p)
1442                         break;
1443                 *p++ = '\\';
1444         }
1445
1446         g_free (dir_utf16);
1447         return TRUE;
1448 #else
1449         char *p;
1450         gchar *dir = g_path_get_dirname (filename);
1451         int retval;
1452         struct stat sbuf;
1453
1454         if (!dir || !dir [0]) {
1455                 g_free (dir);
1456                 return FALSE;
1457         }
1458
1459         if (stat (dir, &sbuf) == 0 && S_ISDIR (sbuf.st_mode)) {
1460                 g_free (dir);
1461                 return TRUE;
1462         }
1463
1464         p = dir;
1465         while (*p == '/')
1466                 p++;
1467
1468         while (1) {
1469                 p = strchr (p, '/');
1470                 if (p)
1471                         *p = '\0';
1472                 retval = mkdir (dir, 0777);
1473                 if (retval != 0 && errno != EEXIST) {
1474                         g_free (dir);
1475                         return FALSE;
1476                 }
1477                 if (!p)
1478                         break;
1479                 *p++ = '/';
1480         }
1481
1482         g_free (dir);
1483         return TRUE;
1484 #endif
1485 }
1486
1487 static gboolean
1488 private_file_needs_copying (const char *src, struct stat *sbuf_src, char *dest)
1489 {
1490         struct stat sbuf_dest;
1491         gchar *real_src = mono_portability_find_file (src, TRUE);
1492
1493         if (!real_src)
1494                 real_src = (gchar*)src;
1495
1496         if (stat (real_src, sbuf_src) == -1) {
1497                 time_t tnow = time (NULL);
1498                 memset (sbuf_src, 0, sizeof (*sbuf_src));
1499                 sbuf_src->st_mtime = tnow;
1500                 sbuf_src->st_atime = tnow;
1501                 return TRUE;
1502         }
1503
1504         if (stat (dest, &sbuf_dest) == -1)
1505                 return TRUE;
1506
1507         if (sbuf_src->st_size == sbuf_dest.st_size &&
1508             sbuf_src->st_mtime == sbuf_dest.st_mtime)
1509                 return FALSE;
1510
1511         return TRUE;
1512 }
1513
1514 static gboolean
1515 shadow_copy_create_ini (const char *shadow, const char *filename)
1516 {
1517         char *dir_name;
1518         char *ini_file;
1519         guint16 *u16_ini;
1520         gboolean result;
1521         guint32 n;
1522         HANDLE *handle;
1523         gchar *full_path;
1524
1525         dir_name = g_path_get_dirname (shadow);
1526         ini_file = g_build_filename (dir_name, "__AssemblyInfo__.ini", NULL);
1527         g_free (dir_name);
1528         if (g_file_test (ini_file, G_FILE_TEST_IS_REGULAR)) {
1529                 g_free (ini_file);
1530                 return TRUE;
1531         }
1532
1533         u16_ini = g_utf8_to_utf16 (ini_file, strlen (ini_file), NULL, NULL, NULL);
1534         g_free (ini_file);
1535         if (!u16_ini) {
1536                 return FALSE;
1537         }
1538         handle = CreateFile (u16_ini, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE,
1539                                 NULL, CREATE_NEW, FileAttributes_Normal, NULL);
1540         g_free (u16_ini);
1541         if (handle == INVALID_HANDLE_VALUE) {
1542                 return FALSE;
1543         }
1544
1545         full_path = mono_path_resolve_symlinks (filename);
1546         result = WriteFile (handle, full_path, strlen (full_path), &n, NULL);
1547         g_free (full_path);
1548         CloseHandle (handle);
1549         return result;
1550 }
1551
1552 gboolean
1553 mono_is_shadow_copy_enabled (MonoDomain *domain, const gchar *dir_name)
1554 {
1555         MonoError error;
1556         MonoAppDomainSetup *setup;
1557         gchar *all_dirs;
1558         gchar **dir_ptr;
1559         gchar **directories;
1560         gchar *shadow_status_string;
1561         gchar *base_dir;
1562         gboolean shadow_enabled;
1563         gboolean found = FALSE;
1564
1565         if (domain == NULL)
1566                 return FALSE;
1567
1568         setup = domain->setup;
1569         if (setup == NULL || setup->shadow_copy_files == NULL)
1570                 return FALSE;
1571
1572         shadow_status_string = mono_string_to_utf8_checked (setup->shadow_copy_files, &error);
1573         if (!mono_error_ok (&error)) {
1574                 mono_error_cleanup (&error);
1575                 return FALSE;
1576         }
1577         shadow_enabled = !g_ascii_strncasecmp (shadow_status_string, "true", 4);
1578         g_free (shadow_status_string);
1579
1580         if (!shadow_enabled)
1581                 return FALSE;
1582
1583         if (setup->shadow_copy_directories == NULL)
1584                 return TRUE;
1585
1586         /* Is dir_name a shadow_copy destination already? */
1587         base_dir = get_shadow_assembly_location_base (domain, &error);
1588         if (!mono_error_ok (&error)) {
1589                 mono_error_cleanup (&error);
1590                 return FALSE;
1591         }
1592
1593         if (strstr (dir_name, base_dir)) {
1594                 g_free (base_dir);
1595                 return TRUE;
1596         }
1597         g_free (base_dir);
1598
1599         all_dirs = mono_string_to_utf8_checked (setup->shadow_copy_directories, &error);
1600         if (!mono_error_ok (&error)) {
1601                 mono_error_cleanup (&error);
1602                 return FALSE;
1603         }
1604
1605         directories = g_strsplit (all_dirs, G_SEARCHPATH_SEPARATOR_S, 1000);
1606         dir_ptr = directories;
1607         while (*dir_ptr) {
1608                 if (**dir_ptr != '\0' && !strcmp (*dir_ptr, dir_name)) {
1609                         found = TRUE;
1610                         break;
1611                 }
1612                 dir_ptr++;
1613         }
1614         g_strfreev (directories);
1615         g_free (all_dirs);
1616         return found;
1617 }
1618
1619 /*
1620 This function raises exceptions so it can cause as sorts of nasty stuff if called
1621 while holding a lock.
1622 FIXME bubble up the error instead of raising it here
1623 */
1624 char *
1625 mono_make_shadow_copy (const char *filename)
1626 {
1627         MonoError error;
1628         gchar *sibling_source, *sibling_target;
1629         gint sibling_source_len, sibling_target_len;
1630         guint16 *orig, *dest;
1631         char *shadow;
1632         gboolean copy_result;
1633         MonoException *exc;
1634         struct stat src_sbuf;
1635         struct utimbuf utbuf;
1636         char *dir_name = g_path_get_dirname (filename);
1637         MonoDomain *domain = mono_domain_get ();
1638         char *shadow_dir;
1639
1640         set_domain_search_path (domain);
1641
1642         if (!mono_is_shadow_copy_enabled (domain, dir_name)) {
1643                 g_free (dir_name);
1644                 return (char *) filename;
1645         }
1646
1647         /* Is dir_name a shadow_copy destination already? */
1648         shadow_dir = get_shadow_assembly_location_base (domain, &error);
1649         if (!mono_error_ok (&error)) {
1650                 mono_error_cleanup (&error);
1651                 g_free (dir_name);
1652                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy (invalid characters in shadow directory name).");
1653                 mono_raise_exception (exc);
1654         }
1655
1656         if (strstr (dir_name, shadow_dir)) {
1657                 g_free (shadow_dir);
1658                 g_free (dir_name);
1659                 return (char *) filename;
1660         }
1661         g_free (shadow_dir);
1662         g_free (dir_name);
1663
1664         shadow = get_shadow_assembly_location (filename, &error);
1665         if (!mono_error_ok (&error)) {
1666                 mono_error_cleanup (&error);
1667                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy (invalid characters in file name).");
1668                 mono_raise_exception (exc);
1669         }
1670
1671         if (ensure_directory_exists (shadow) == FALSE) {
1672                 g_free (shadow);
1673                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy (ensure directory exists).");
1674                 mono_raise_exception (exc);
1675         }
1676
1677         if (!private_file_needs_copying (filename, &src_sbuf, shadow))
1678                 return (char*) shadow;
1679
1680         orig = g_utf8_to_utf16 (filename, strlen (filename), NULL, NULL, NULL);
1681         dest = g_utf8_to_utf16 (shadow, strlen (shadow), NULL, NULL, NULL);
1682         DeleteFile (dest);
1683         copy_result = CopyFile (orig, dest, FALSE);
1684
1685         /* Fix for bug #556884 - make sure the files have the correct mode so that they can be
1686          * overwritten when updated in their original locations. */
1687         if (copy_result)
1688                 copy_result = SetFileAttributes (dest, FILE_ATTRIBUTE_NORMAL);
1689
1690         g_free (dest);
1691         g_free (orig);
1692
1693         if (copy_result == FALSE) {
1694                 g_free (shadow);
1695                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy (CopyFile).");
1696                 mono_raise_exception (exc);
1697         }
1698
1699         /* attempt to copy .mdb, .config if they exist */
1700         sibling_source = g_strconcat (filename, ".config", NULL);
1701         sibling_source_len = strlen (sibling_source);
1702         sibling_target = g_strconcat (shadow, ".config", NULL);
1703         sibling_target_len = strlen (sibling_target);
1704
1705         copy_result = shadow_copy_sibling (sibling_source, sibling_source_len, ".mdb", sibling_target, sibling_target_len, 7);
1706         if (copy_result == TRUE)
1707                 copy_result = shadow_copy_sibling (sibling_source, sibling_source_len, ".config", sibling_target, sibling_target_len, 7);
1708
1709         g_free (sibling_source);
1710         g_free (sibling_target);
1711
1712         if (copy_result == FALSE)  {
1713                 g_free (shadow);
1714                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy of sibling data (CopyFile).");
1715                 mono_raise_exception (exc);
1716         }
1717
1718         /* Create a .ini file containing the original assembly location */
1719         if (!shadow_copy_create_ini (shadow, filename)) {
1720                 g_free (shadow);
1721                 exc = mono_get_exception_execution_engine ("Failed to create shadow copy .ini file.");
1722                 mono_raise_exception (exc);
1723         }
1724
1725         utbuf.actime = src_sbuf.st_atime;
1726         utbuf.modtime = src_sbuf.st_mtime;
1727         utime (shadow, &utbuf);
1728
1729         return shadow;
1730 }
1731 #endif /* DISABLE_SHADOW_COPY */
1732
1733 MonoDomain *
1734 mono_domain_from_appdomain (MonoAppDomain *appdomain)
1735 {
1736         if (appdomain == NULL)
1737                 return NULL;
1738
1739         return appdomain->data;
1740 }
1741
1742 static gboolean
1743 try_load_from (MonoAssembly **assembly, const gchar *path1, const gchar *path2,
1744                                         const gchar *path3, const gchar *path4,
1745                                         gboolean refonly, gboolean is_private)
1746 {
1747         gchar *fullpath;
1748         gboolean found = FALSE;
1749
1750         *assembly = NULL;
1751         fullpath = g_build_filename (path1, path2, path3, path4, NULL);
1752
1753         if (IS_PORTABILITY_SET) {
1754                 gchar *new_fullpath = mono_portability_find_file (fullpath, TRUE);
1755                 if (new_fullpath) {
1756                         g_free (fullpath);
1757                         fullpath = new_fullpath;
1758                         found = TRUE;
1759                 }
1760         } else
1761                 found = g_file_test (fullpath, G_FILE_TEST_IS_REGULAR);
1762
1763         if (found)
1764                 *assembly = mono_assembly_open_full (fullpath, NULL, refonly);
1765
1766         g_free (fullpath);
1767         return (*assembly != NULL);
1768 }
1769
1770 static MonoAssembly *
1771 real_load (gchar **search_path, const gchar *culture, const gchar *name, gboolean refonly)
1772 {
1773         MonoAssembly *result = NULL;
1774         gchar **path;
1775         gchar *filename;
1776         const gchar *local_culture;
1777         gint len;
1778         gboolean is_private = FALSE;
1779
1780         if (!culture || *culture == '\0') {
1781                 local_culture = "";
1782         } else {
1783                 local_culture = culture;
1784         }
1785
1786         filename =  g_strconcat (name, ".dll", NULL);
1787         len = strlen (filename);
1788
1789         for (path = search_path; *path; path++) {
1790                 if (**path == '\0') {
1791                         is_private = TRUE;
1792                         continue; /* Ignore empty ApplicationBase */
1793                 }
1794
1795                 /* See test cases in bug #58992 and bug #57710 */
1796                 /* 1st try: [culture]/[name].dll (culture may be empty) */
1797                 strcpy (filename + len - 4, ".dll");
1798                 if (try_load_from (&result, *path, local_culture, "", filename, refonly, is_private))
1799                         break;
1800
1801                 /* 2nd try: [culture]/[name].exe (culture may be empty) */
1802                 strcpy (filename + len - 4, ".exe");
1803                 if (try_load_from (&result, *path, local_culture, "", filename, refonly, is_private))
1804                         break;
1805
1806                 /* 3rd try: [culture]/[name]/[name].dll (culture may be empty) */
1807                 strcpy (filename + len - 4, ".dll");
1808                 if (try_load_from (&result, *path, local_culture, name, filename, refonly, is_private))
1809                         break;
1810
1811                 /* 4th try: [culture]/[name]/[name].exe (culture may be empty) */
1812                 strcpy (filename + len - 4, ".exe");
1813                 if (try_load_from (&result, *path, local_culture, name, filename, refonly, is_private))
1814                         break;
1815         }
1816
1817         g_free (filename);
1818         return result;
1819 }
1820
1821 /*
1822  * Try loading the assembly from ApplicationBase and PrivateBinPath
1823  * and then from assemblies_path if any.
1824  * LOCKING: This is called from the assembly loading code, which means the caller
1825  * might hold the loader lock. Thus, this function must not acquire the domain lock.
1826  */
1827 static MonoAssembly *
1828 mono_domain_assembly_preload (MonoAssemblyName *aname,
1829                               gchar **assemblies_path,
1830                               gpointer user_data)
1831 {
1832         MonoDomain *domain = mono_domain_get ();
1833         MonoAssembly *result = NULL;
1834         gboolean refonly = GPOINTER_TO_UINT (user_data);
1835
1836         set_domain_search_path (domain);
1837
1838         if (domain->search_path && domain->search_path [0] != NULL) {
1839                 result = real_load (domain->search_path, aname->culture, aname->name, refonly);
1840         }
1841
1842         if (result == NULL && assemblies_path && assemblies_path [0] != NULL) {
1843                 result = real_load (assemblies_path, aname->culture, aname->name, refonly);
1844         }
1845
1846         return result;
1847 }
1848
1849 /*
1850  * Check whenever a given assembly was already loaded in the current appdomain.
1851  */
1852 static MonoAssembly *
1853 mono_domain_assembly_search (MonoAssemblyName *aname,
1854                                                          gpointer user_data)
1855 {
1856         MonoDomain *domain = mono_domain_get ();
1857         GSList *tmp;
1858         MonoAssembly *ass;
1859         gboolean refonly = GPOINTER_TO_UINT (user_data);
1860
1861         mono_domain_assemblies_lock (domain);
1862         for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
1863                 ass = tmp->data;
1864                 /* Dynamic assemblies can't match here in MS.NET */
1865                 if (ass->dynamic || refonly != ass->ref_only || !mono_assembly_names_equal (aname, &ass->aname))
1866                         continue;
1867
1868                 mono_domain_assemblies_unlock (domain);
1869                 return ass;
1870         }
1871         mono_domain_assemblies_unlock (domain);
1872
1873         return NULL;
1874 }
1875
1876 MonoReflectionAssembly *
1877 ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname, MonoBoolean refOnly)
1878 {
1879         MonoDomain *domain = mono_domain_get ();
1880         char *name, *filename;
1881         MonoImageOpenStatus status = MONO_IMAGE_OK;
1882         MonoAssembly *ass;
1883
1884         MONO_ARCH_SAVE_REGS;
1885
1886         if (fname == NULL) {
1887                 MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
1888                 mono_raise_exception (exc);
1889         }
1890
1891         name = filename = mono_string_to_utf8 (fname);
1892
1893         ass = mono_assembly_open_full (filename, &status, refOnly);
1894
1895         if (!ass){
1896                 MonoException *exc;
1897
1898                 if (status == MONO_IMAGE_IMAGE_INVALID)
1899                         exc = mono_get_exception_bad_image_format2 (NULL, fname);
1900                 else
1901                         exc = mono_get_exception_file_not_found2 (NULL, fname);
1902                 g_free (name);
1903                 mono_raise_exception (exc);
1904         }
1905
1906         g_free (name);
1907
1908         return mono_assembly_get_object (domain, ass);
1909 }
1910
1911 MonoReflectionAssembly *
1912 ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad,
1913                                             MonoArray *raw_assembly,
1914                                             MonoArray *raw_symbol_store, MonoObject *evidence,
1915                                             MonoBoolean refonly)
1916 {
1917         MonoAssembly *ass;
1918         MonoReflectionAssembly *refass = NULL;
1919         MonoDomain *domain = ad->data;
1920         MonoImageOpenStatus status;
1921         guint32 raw_assembly_len = mono_array_length (raw_assembly);
1922         MonoImage *image = mono_image_open_from_data_full (mono_array_addr (raw_assembly, gchar, 0), raw_assembly_len, TRUE, NULL, refonly);
1923
1924         if (!image) {
1925                 mono_raise_exception (mono_get_exception_bad_image_format (""));
1926                 return NULL;
1927         }
1928
1929         if (raw_symbol_store != NULL)
1930                 mono_debug_open_image_from_memory (image, mono_array_addr (raw_symbol_store, guint8, 0), mono_array_length (raw_symbol_store));
1931
1932         ass = mono_assembly_load_from_full (image, "", &status, refonly);
1933
1934
1935         if (!ass) {
1936                 mono_image_close (image);
1937                 mono_raise_exception (mono_get_exception_bad_image_format (""));
1938                 return NULL;
1939         }
1940
1941         refass = mono_assembly_get_object (domain, ass);
1942         MONO_OBJECT_SETREF (refass, evidence, evidence);
1943         return refass;
1944 }
1945
1946 MonoReflectionAssembly *
1947 ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoString *assRef, MonoObject *evidence, MonoBoolean refOnly)
1948 {
1949         MonoDomain *domain = ad->data;
1950         MonoImageOpenStatus status = MONO_IMAGE_OK;
1951         MonoAssembly *ass;
1952         MonoAssemblyName aname;
1953         MonoReflectionAssembly *refass = NULL;
1954         gchar *name;
1955         gboolean parsed;
1956
1957         MONO_ARCH_SAVE_REGS;
1958
1959         g_assert (assRef != NULL);
1960
1961         name = mono_string_to_utf8 (assRef);
1962         parsed = mono_assembly_name_parse (name, &aname);
1963         g_free (name);
1964
1965         if (!parsed) {
1966                 /* This is a parse error... */
1967                 return NULL;
1968         }
1969
1970         ass = mono_assembly_load_full_nosearch (&aname, NULL, &status, refOnly);
1971         mono_assembly_name_free (&aname);
1972
1973         if (!ass) {
1974                 /* MS.NET doesn't seem to call the assembly resolve handler for refonly assemblies */
1975                 if (!refOnly)
1976                         refass = mono_try_assembly_resolve (domain, assRef, refOnly);
1977                 else
1978                         refass = NULL;
1979                 if (!refass) {
1980                         return NULL;
1981                 }
1982         }
1983
1984         if (refass == NULL)
1985                 refass = mono_assembly_get_object (domain, ass);
1986
1987         MONO_OBJECT_SETREF (refass, evidence, evidence);
1988         return refass;
1989 }
1990
1991 void
1992 ves_icall_System_AppDomain_InternalUnload (gint32 domain_id)
1993 {
1994         MonoDomain * domain = mono_domain_get_by_id (domain_id);
1995
1996         MONO_ARCH_SAVE_REGS;
1997
1998         if (NULL == domain) {
1999                 MonoException *exc = mono_get_exception_execution_engine ("Failed to unload domain, domain id not found");
2000                 mono_raise_exception (exc);
2001         }
2002
2003         if (domain == mono_get_root_domain ()) {
2004                 mono_raise_exception (mono_get_exception_cannot_unload_appdomain ("The default appdomain can not be unloaded."));
2005                 return;
2006         }
2007
2008         /*
2009          * Unloading seems to cause problems when running NUnit/NAnt, hence
2010          * this workaround.
2011          */
2012         if (g_getenv ("MONO_NO_UNLOAD"))
2013                 return;
2014
2015         mono_domain_unload (domain);
2016 }
2017
2018 gboolean
2019 ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id)
2020 {
2021         MonoDomain *domain = mono_domain_get_by_id (domain_id);
2022
2023         if (!domain)
2024                 return TRUE;
2025
2026         return mono_domain_is_unloading (domain);
2027 }
2028
2029 gint32
2030 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad,
2031                                                                                         MonoReflectionAssembly *refass, MonoArray *args)
2032 {
2033         MonoImage *image;
2034         MonoMethod *method;
2035
2036         MONO_ARCH_SAVE_REGS;
2037
2038         g_assert (refass);
2039         image = refass->assembly->image;
2040         g_assert (image);
2041
2042         method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
2043
2044         if (!method)
2045                 g_error ("No entry point method found in %s", image->name);
2046
2047         if (!args)
2048                 args = (MonoArray *) mono_array_new (ad->data, mono_defaults.string_class, 0);
2049
2050         return mono_runtime_exec_main (method, (MonoArray *)args, NULL);
2051 }
2052
2053 gint32
2054 ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad)
2055 {
2056         MONO_ARCH_SAVE_REGS;
2057
2058         return ad->data->domain_id;
2059 }
2060
2061 MonoAppDomain *
2062 ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad)
2063 {
2064         MonoDomain *old_domain = mono_domain_get();
2065
2066         MONO_ARCH_SAVE_REGS;
2067
2068         if (!mono_domain_set (ad->data, FALSE))
2069                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
2070
2071         return old_domain->domain;
2072 }
2073
2074 MonoAppDomain *
2075 ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid)
2076 {
2077         MonoDomain *current_domain = mono_domain_get ();
2078         MonoDomain *domain = mono_domain_get_by_id (domainid);
2079
2080         MONO_ARCH_SAVE_REGS;
2081
2082         if (!domain || !mono_domain_set (domain, FALSE))
2083                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
2084
2085         return current_domain->domain;
2086 }
2087
2088 void
2089 ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad)
2090 {
2091         MONO_ARCH_SAVE_REGS;
2092
2093         mono_thread_push_appdomain_ref (ad->data);
2094 }
2095
2096 void
2097 ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id)
2098 {
2099         MonoDomain *domain = mono_domain_get_by_id (domain_id);
2100
2101         MONO_ARCH_SAVE_REGS;
2102
2103         if (!domain)
2104                 /*
2105                  * Raise an exception to prevent the managed code from executing a pop
2106                  * later.
2107                  */
2108                 mono_raise_exception (mono_get_exception_appdomain_unloaded ());
2109
2110         mono_thread_push_appdomain_ref (domain);
2111 }
2112
2113 void
2114 ves_icall_System_AppDomain_InternalPopDomainRef (void)
2115 {
2116         MONO_ARCH_SAVE_REGS;
2117
2118         mono_thread_pop_appdomain_ref ();
2119 }
2120
2121 MonoAppContext *
2122 ves_icall_System_AppDomain_InternalGetContext ()
2123 {
2124         MONO_ARCH_SAVE_REGS;
2125
2126         return mono_context_get ();
2127 }
2128
2129 MonoAppContext *
2130 ves_icall_System_AppDomain_InternalGetDefaultContext ()
2131 {
2132         MONO_ARCH_SAVE_REGS;
2133
2134         return mono_domain_get ()->default_context;
2135 }
2136
2137 MonoAppContext *
2138 ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc)
2139 {
2140         MonoAppContext *old_context = mono_context_get ();
2141
2142         MONO_ARCH_SAVE_REGS;
2143
2144         mono_context_set (mc);
2145
2146         return old_context;
2147 }
2148
2149 MonoString *
2150 ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid)
2151 {
2152         MonoDomain* mono_root_domain = mono_get_root_domain ();
2153         mono_domain_lock (mono_root_domain);
2154         if (process_guid_set) {
2155                 mono_domain_unlock (mono_root_domain);
2156                 return mono_string_new_utf16 (mono_domain_get (), process_guid, sizeof(process_guid)/2);
2157         }
2158         memcpy (process_guid, mono_string_chars(newguid), sizeof(process_guid));
2159         process_guid_set = TRUE;
2160         mono_domain_unlock (mono_root_domain);
2161         return newguid;
2162 }
2163
2164 gboolean
2165 mono_domain_is_unloading (MonoDomain *domain)
2166 {
2167         if (domain->state == MONO_APPDOMAIN_UNLOADING || domain->state == MONO_APPDOMAIN_UNLOADED)
2168                 return TRUE;
2169         else
2170                 return FALSE;
2171 }
2172
2173 static void
2174 clear_cached_vtable (MonoVTable *vtable)
2175 {
2176         MonoClass *klass = vtable->klass;
2177         MonoDomain *domain = vtable->domain;
2178         MonoClassRuntimeInfo *runtime_info;
2179         void *data;
2180
2181         runtime_info = klass->runtime_info;
2182         if (runtime_info && runtime_info->max_domain >= domain->domain_id)
2183                 runtime_info->domain_vtables [domain->domain_id] = NULL;
2184         if (klass->has_static_refs && (data = mono_vtable_get_static_field_data (vtable)))
2185                 mono_gc_free_fixed (data);
2186 }
2187
2188 static G_GNUC_UNUSED void
2189 zero_static_data (MonoVTable *vtable)
2190 {
2191         MonoClass *klass = vtable->klass;
2192         void *data;
2193
2194         if (klass->has_static_refs && (data = mono_vtable_get_static_field_data (vtable)))
2195                 mono_gc_bzero (data, mono_class_data_size (klass));
2196 }
2197
2198 typedef struct unload_data {
2199         MonoDomain *domain;
2200         char *failure_reason;
2201 } unload_data;
2202
2203 static void
2204 deregister_reflection_info_roots_nspace_table (gpointer key, gpointer value, gpointer image)
2205 {
2206         guint32 index = GPOINTER_TO_UINT (value);
2207         MonoClass *class = mono_class_get (image, MONO_TOKEN_TYPE_DEF | index);
2208
2209         g_assert (class);
2210
2211         mono_class_free_ref_info (class);
2212 }
2213
2214 static void
2215 deregister_reflection_info_roots_name_space (gpointer key, gpointer value, gpointer user_data)
2216 {
2217         g_hash_table_foreach (value, deregister_reflection_info_roots_nspace_table, user_data);
2218 }
2219
2220 static void
2221 deregister_reflection_info_roots_from_list (MonoImage *image)
2222 {
2223         GSList *list = image->reflection_info_unregister_classes;
2224
2225         while (list) {
2226                 MonoClass *class = list->data;
2227
2228                 mono_class_free_ref_info (class);
2229
2230                 list = list->next;
2231         }
2232
2233         g_slist_free (image->reflection_info_unregister_classes);
2234         image->reflection_info_unregister_classes = NULL;
2235 }
2236
2237 static void
2238 deregister_reflection_info_roots (MonoDomain *domain)
2239 {
2240         GSList *list;
2241
2242         mono_loader_lock ();
2243         mono_domain_assemblies_lock (domain);
2244         for (list = domain->domain_assemblies; list; list = list->next) {
2245                 MonoAssembly *assembly = list->data;
2246                 MonoImage *image = assembly->image;
2247                 int i;
2248                 /*No need to take the image lock here since dynamic images are appdomain bound and at this point the mutator is gone.*/
2249                 if (image->dynamic && image->name_cache)
2250                         g_hash_table_foreach (image->name_cache, deregister_reflection_info_roots_name_space, image);
2251                 deregister_reflection_info_roots_from_list (image);
2252                 for (i = 0; i < image->module_count; ++i) {
2253                         MonoImage *module = image->modules [i];
2254                         if (module) {
2255                                 if (module->dynamic && module->name_cache) {
2256                                         g_hash_table_foreach (module->name_cache,
2257                                                         deregister_reflection_info_roots_name_space, module);
2258                                 }
2259                                 deregister_reflection_info_roots_from_list (module);
2260                         }
2261                 }
2262         }
2263         mono_domain_assemblies_unlock (domain);
2264         mono_loader_unlock ();
2265 }
2266
2267 static guint32 WINAPI
2268 unload_thread_main (void *arg)
2269 {
2270         unload_data *data = (unload_data*)arg;
2271         MonoDomain *domain = data->domain;
2272         MonoThread *thread;
2273         int i;
2274
2275         /* Have to attach to the runtime so shutdown can wait for this thread */
2276         thread = mono_thread_attach (mono_get_root_domain ());
2277
2278         /*
2279          * FIXME: Abort our parent thread last, so we can return a failure
2280          * indication if aborting times out.
2281          */
2282         if (!mono_threads_abort_appdomain_threads (domain, -1)) {
2283                 data->failure_reason = g_strdup_printf ("Aborting of threads in domain %s timed out.", domain->friendly_name);
2284                 return 1;
2285         }
2286
2287         if (!mono_thread_pool_remove_domain_jobs (domain, -1)) {
2288                 data->failure_reason = g_strdup_printf ("Cleanup of threadpool jobs of domain %s timed out.", domain->friendly_name);
2289                 return 1;
2290         }
2291
2292         /* Finalize all finalizable objects in the doomed appdomain */
2293         if (!mono_domain_finalize (domain, -1)) {
2294                 data->failure_reason = g_strdup_printf ("Finalization of domain %s timed out.", domain->friendly_name);
2295                 return 1;
2296         }
2297
2298         /* Clear references to our vtables in class->runtime_info.
2299          * We also hold the loader lock because we're going to change
2300          * class->runtime_info.
2301          */
2302
2303         mono_loader_lock ();
2304         mono_domain_lock (domain);
2305 #ifdef HAVE_SGEN_GC
2306         /*
2307          * We need to make sure that we don't have any remsets
2308          * pointing into static data of the to-be-freed domain because
2309          * at the next collections they would be invalid.  So what we
2310          * do is we first zero all static data and then do a minor
2311          * collection.  Because all references in the static data will
2312          * now be null we won't do any unnecessary copies and after
2313          * the collection there won't be any more remsets.
2314          */
2315         for (i = 0; i < domain->class_vtable_array->len; ++i)
2316                 zero_static_data (g_ptr_array_index (domain->class_vtable_array, i));
2317         mono_gc_collect (0);
2318 #endif
2319         for (i = 0; i < domain->class_vtable_array->len; ++i)
2320                 clear_cached_vtable (g_ptr_array_index (domain->class_vtable_array, i));
2321         deregister_reflection_info_roots (domain);
2322
2323         mono_assembly_cleanup_domain_bindings (domain->domain_id);
2324
2325         mono_domain_unlock (domain);
2326         mono_loader_unlock ();
2327
2328         mono_threads_clear_cached_culture (domain);
2329
2330         domain->state = MONO_APPDOMAIN_UNLOADED;
2331
2332         /* printf ("UNLOADED %s.\n", domain->friendly_name); */
2333
2334         /* remove from the handle table the items related to this domain */
2335         mono_gchandle_free_domain (domain);
2336
2337         mono_domain_free (domain, FALSE);
2338
2339         mono_gc_collect (mono_gc_max_generation ());
2340
2341         mono_thread_detach (thread);
2342
2343         return 0;
2344 }
2345
2346 /*
2347  * mono_domain_unload:
2348  * @domain: The domain to unload
2349  *
2350  *  Unloads an appdomain. Follows the process outlined in the comment
2351  *  for mono_domain_try_unload.
2352  */
2353 void
2354 mono_domain_unload (MonoDomain *domain)
2355 {
2356         MonoObject *exc = NULL;
2357         mono_domain_try_unload (domain, &exc);
2358         if (exc)
2359                 mono_raise_exception ((MonoException*)exc);
2360 }
2361
2362 /*
2363  * mono_domain_unload:
2364  * @domain: The domain to unload
2365  * @exc: Exception information
2366  *
2367  *  Unloads an appdomain. Follows the process outlined in:
2368  *  http://blogs.gotdotnet.com/cbrumme
2369  *
2370  *  If doing things the 'right' way is too hard or complex, we do it the
2371  *  'simple' way, which means do everything needed to avoid crashes and
2372  *  memory leaks, but not much else.
2373  *
2374  *  It is required to pass a valid reference to the exc argument, upon return
2375  *  from this function *exc will be set to the exception thrown, if any.
2376  *
2377  *  If this method is not called from an icall (embedded scenario for instance),
2378  *  it must not be called with any managed frames on the stack, since the unload
2379  *  process could end up trying to abort the current thread.
2380  */
2381 void
2382 mono_domain_try_unload (MonoDomain *domain, MonoObject **exc)
2383 {
2384         HANDLE thread_handle;
2385         gsize tid;
2386         guint32 res;
2387         MonoAppDomainState prev_state;
2388         MonoMethod *method;
2389         unload_data thread_data;
2390         MonoDomain *caller_domain = mono_domain_get ();
2391
2392         /* printf ("UNLOAD STARTING FOR %s (%p) IN THREAD 0x%x.\n", domain->friendly_name, domain, GetCurrentThreadId ()); */
2393
2394         /* Atomically change our state to UNLOADING */
2395         prev_state = InterlockedCompareExchange ((gint32*)&domain->state,
2396                                                                                          MONO_APPDOMAIN_UNLOADING_START,
2397                                                                                          MONO_APPDOMAIN_CREATED);
2398         if (prev_state != MONO_APPDOMAIN_CREATED) {
2399                 switch (prev_state) {
2400                 case MONO_APPDOMAIN_UNLOADING_START:
2401                 case MONO_APPDOMAIN_UNLOADING:
2402                         *exc = (MonoObject *) mono_get_exception_cannot_unload_appdomain ("Appdomain is already being unloaded.");
2403                         return;
2404                 case MONO_APPDOMAIN_UNLOADED:
2405                         *exc = (MonoObject *) mono_get_exception_cannot_unload_appdomain ("Appdomain is already unloaded.");
2406                         return;
2407                 default:
2408                         g_warning ("Invalid appdomain state %d", prev_state);
2409                         g_assert_not_reached ();
2410                 }
2411         }
2412
2413         mono_debugger_event_unload_appdomain (domain);
2414
2415         mono_domain_set (domain, FALSE);
2416         /* Notify OnDomainUnload listeners */
2417         method = mono_class_get_method_from_name (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload", -1);
2418         g_assert (method);
2419
2420         mono_runtime_invoke (method, domain->domain, NULL, exc);
2421         if (*exc) {
2422                 /* Roll back the state change */
2423                 domain->state = MONO_APPDOMAIN_CREATED;
2424                 mono_domain_set (caller_domain, FALSE);
2425                 return;
2426         }
2427         mono_domain_set (caller_domain, FALSE);
2428
2429         thread_data.domain = domain;
2430         thread_data.failure_reason = NULL;
2431
2432         /*The managed callback finished successfully, now we start tearing down the appdomain*/
2433         domain->state = MONO_APPDOMAIN_UNLOADING;
2434         /*
2435          * First we create a separate thread for unloading, since
2436          * we might have to abort some threads, including the current one.
2437          */
2438         /*
2439          * If we create a non-suspended thread, the runtime will hang.
2440          * See:
2441          * http://bugzilla.ximian.com/show_bug.cgi?id=27663
2442          */
2443 #if 0
2444         thread_handle = mono_create_thread (NULL, 0, unload_thread_main, &thread_data, 0, &tid);
2445 #else
2446         thread_handle = mono_create_thread (NULL, 0, (LPTHREAD_START_ROUTINE)unload_thread_main, &thread_data, CREATE_SUSPENDED, &tid);
2447         if (thread_handle == NULL) {
2448                 return;
2449         }
2450         ResumeThread (thread_handle);
2451 #endif
2452
2453         /* Wait for the thread */
2454         while ((res = WaitForSingleObjectEx (thread_handle, INFINITE, TRUE) == WAIT_IO_COMPLETION)) {
2455                 if (mono_thread_internal_has_appdomain_ref (mono_thread_internal_current (), domain) && (mono_thread_interruption_requested ())) {
2456                         /* The unload thread tries to abort us */
2457                         /* The icall wrapper will execute the abort */
2458                         CloseHandle (thread_handle);
2459                         return;
2460                 }
2461         }
2462         CloseHandle (thread_handle);
2463
2464         if (thread_data.failure_reason) {
2465                 /* Roll back the state change */
2466                 domain->state = MONO_APPDOMAIN_CREATED;
2467
2468                 g_warning ("%s", thread_data.failure_reason);
2469
2470                 *exc = (MonoObject *) mono_get_exception_cannot_unload_appdomain (thread_data.failure_reason);
2471
2472                 g_free (thread_data.failure_reason);
2473                 thread_data.failure_reason = NULL;
2474         }
2475 }