mono/metadata/appdomain.c

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