mono/metadata/appdomain.c

   1 /*
   2  * appdomain.c: AppDomain functions
   3  *
   4  * Author:
   5  *      Dietmar Maurer (dietmar@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <string.h>
  13
  14 #include <mono/os/gc_wrapper.h>
  15
  16 #include <mono/metadata/object.h>
  17 #include <mono/metadata/appdomain.h>
  18 #include <mono/metadata/assembly.h>
  19 #include <mono/metadata/exception.h>
  20 #include <mono/metadata/threads.h>
  21 #include <mono/metadata/socket-io.h>
  22 #include <mono/metadata/tabledefs.h>
  23 #include <mono/metadata/gc-internal.h>
  24
  25 HANDLE mono_delegate_semaphore = NULL;
  26 CRITICAL_SECTION mono_delegate_section;
  27
  28 static MonoObject *
  29 mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj);
  30
  31 static MonoAssembly *
  32 mono_domain_assembly_preload (MonoAssemblyName *aname,
  33                               gchar **assemblies_path,
  34                               gpointer user_data);
  35
  36 static void
  37 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data);
  38
  39 /*
  40  * mono_runtime_init:
  41  * @domain: domain returned by mono_init ()
  42  *
  43  * Initialize the core AppDomain: this function will run also some
  44  * IL initialization code, so it needs the execution engine to be fully
  45  * operational.
  46  *
  47  * AppDomain.SetupInformation is set up in mono_runtime_exec_main, where
  48  * we know the entry_assembly.
  49  *
  50  */
  51 void
  52 mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
  53                    MonoThreadAttachCB attach_cb)
  54 {
  55         MonoAppDomainSetup *setup;
  56         MonoAppDomain *ad;
  57         MonoClass *class;
  58
  59         mono_install_assembly_preload_hook (mono_domain_assembly_preload, NULL);
  60         mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
  61         mono_install_lookup_dynamic_token (mono_reflection_lookup_dynamic_token);
  62
  63         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
  64         setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
  65
  66         class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
  67         ad = (MonoAppDomain *) mono_object_new (domain, class);
  68         ad->data = domain;
  69         domain->domain = ad;
  70         domain->setup = setup;
  71
  72         mono_delegate_semaphore = CreateSemaphore (NULL, 0, 0x7fffffff, NULL);
  73         g_assert (mono_delegate_semaphore != INVALID_HANDLE_VALUE);
  74         InitializeCriticalSection (&mono_delegate_section);
  75
  76         mono_thread_init (start_cb, attach_cb);
  77
  78         /* GC init has to happen after thread init */
  79         mono_gc_init ();
  80
  81         mono_network_init ();
  82
  83         return;
  84 }
  85
  86 /* This must not be called while there are still running threads executing
  87  * managed code.
  88  */
  89 void
  90 mono_runtime_cleanup (MonoDomain *domain)
  91 {
  92         /* Not really needed, but do it anyway */
  93         mono_gc_cleanup ();
  94
  95         mono_network_cleanup ();
  96 }
  97
  98 MonoReflectionAssembly *
  99 mono_domain_try_type_resolve (MonoDomain *domain, MonoObject *name_or_tb)
 100 {
 101         MonoClass *klass;
 102         void *params [1];
 103         static MonoMethod *method = NULL;
 104
 105         g_assert (domain != NULL && name_or_tb != NULL);
 106
 107         if (method == NULL) {
 108                 klass = domain->domain->mbr.obj.vtable->klass;
 109                 g_assert (klass);
 110
 111                 method = look_for_method_by_name (klass, "DoTypeResolve");
 112                 if (method == NULL) {
 113                         g_warning ("Method AppDomain.DoTypeResolve not found.\n");
 114                         return NULL;
 115                 }
 116         }
 117
 118         *params = name_or_tb;
 119         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 120 }
 121
 122 void
 123 ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
 124 {
 125         MonoDomain* domain = mono_domain_get ();
 126         MonoAssembly *assembly;
 127         gchar *str;
 128         gchar *config_suffix;
 129
 130         MONO_ARCH_SAVE_REGS;
 131
 132         assembly = domain->entry_assembly;
 133         g_assert (assembly);
 134
 135         setup->application_base = mono_string_new (domain, assembly->basedir);
 136
 137         config_suffix = g_strconcat (assembly->aname.name, ".exe.config", NULL);
 138         str = g_build_filename (assembly->basedir, config_suffix, NULL);
 139         g_free (config_suffix);
 140         setup->configuration_file = mono_string_new (domain, str);
 141         g_free (str);
 142 }
 143
 144 /*
 145  * invokes a method in a specific domain.
 146  */
 147 static MonoObject*
 148 mono_runtime_invoke_in_domain (MonoDomain *domain, MonoMethod *method, void *obj,
 149                                void **params, MonoObject **exc)
 150 {
 151         MonoDomain *cur = mono_domain_get ();
 152         MonoObject **real_exc, *default_exc;
 153         MonoObject *res;
 154
 155         if (domain == cur)
 156                 return mono_runtime_invoke (method, obj, params, exc);
 157
 158         if (!exc)
 159                 real_exc = &default_exc;
 160         else
 161                 real_exc = exc;
 162
 163         *real_exc = NULL;
 164         mono_domain_set (domain);
 165         res = mono_runtime_invoke (method, obj, params, real_exc);
 166         mono_domain_set (cur);
 167
 168         if (*real_exc) {
 169                 /* transfer Exception to the right domain */
 170                 *real_exc = mono_domain_transfer_object (domain, cur, *real_exc);
 171
 172                 if (!exc)
 173                         mono_raise_exception ((MonoException *)*real_exc);
 174
 175         }
 176
 177         return res;
 178 }
 179
 180 static MonoObject *
 181 mono_domain_transfer_array (MonoDomain *src, MonoDomain *dst, MonoArray *ao)
 182 {
 183         MonoObject *res = NULL;
 184         MonoClass *klass;
 185         int esize, ecount, i;
 186         guint32 *sizes;
 187
 188         klass = ao->obj.vtable->klass;
 189
 190         esize = mono_array_element_size (klass);
 191         if (ao->bounds == NULL) {
 192                 ecount = mono_array_length (ao);
 193                 res = (MonoObject *)mono_array_new_full (dst, klass, &ecount, NULL);
 194         } else {
 195                 sizes = alloca (klass->rank * sizeof(guint32) * 2);
 196                 ecount = 1;
 197                 for (i = 0; i < klass->rank; ++i) {
 198                         sizes [i] = ao->bounds [i].length;
 199                         ecount *= ao->bounds [i].length;
 200                         sizes [i + klass->rank] = ao->bounds [i].lower_bound;
 201                 }
 202                 res = (MonoObject *)mono_array_new_full (dst, klass, sizes, sizes + klass->rank);
 203         }
 204         if (klass->element_class->valuetype) {
 205                 if (klass->element_class->blittable) {
 206                         memcpy (((MonoArray *)res)->vector, ao->vector, esize * ecount);
 207                 } else {
 208                         for (i = 0; i < ecount; i++) {
 209                                 MonoObject *s, *d;
 210                                 gpointer *src_ea = (gpointer *)mono_array_addr_with_size (ao, esize, i);
 211                                 gpointer *dst_ea = (gpointer *)mono_array_addr_with_size ((MonoArray *)res, esize, i);
 212                                 s = mono_value_box (src, klass->element_class, src_ea);
 213                                 d = mono_domain_transfer_object (src, dst, s);
 214                                 memcpy (dst_ea, (char *)d + sizeof(MonoObject), esize);
 215                         }
 216                 }
 217         } else {
 218                 g_assert (esize == sizeof (gpointer));
 219                 for (i = 0; i < ecount; i++) {
 220                         gpointer *src_ea = (gpointer *)mono_array_addr_with_size (ao, esize, i);
 221                         gpointer *dst_ea = (gpointer *)mono_array_addr_with_size ((MonoArray *)res, esize, i);
 222                         *dst_ea = mono_domain_transfer_object (src, dst, *src_ea);
 223                 }
 224         }
 225         return res;
 226 }
 227
 228 /**
 229  * mono_domain_transfer_object:
 230  * @src: the source domain
 231  * @dst: the destination domain
 232  * @obj: the object to transfer
 233  *
 234  * This function is used to transfer objects between domains. This is done by
 235  * marshalling or serialisation.
 236  */
 237 static MonoObject *
 238 mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj)
 239 {
 240         MonoClass *sic = mono_defaults.serializationinfo_class;
 241         MonoClass *klass;
 242         MonoObject *res = NULL;
 243         int i;
 244
 245         if (!obj)
 246                 return NULL;
 247
 248         g_assert (obj->vtable->domain == src);
 249
 250         klass = obj->vtable->klass;
 251
 252         /* some special cases */
 253         if (klass == mono_defaults.string_class) {
 254                 MonoString *str = (MonoString *)obj;
 255                 return (MonoObject *)mono_string_new_utf16 (dst,
 256                         (const guint16 *)mono_string_chars (str), str->length);
 257         }
 258
 259         if (klass == mono_defaults.monotype_class)
 260                 return (MonoObject *) mono_type_get_object (dst, ((MonoReflectionType *)obj)->type);
 261
 262         if (MONO_CLASS_IS_ARRAY (klass))
 263                 return mono_domain_transfer_array (src, dst, (MonoArray *)obj);
 264
 265         if (mono_object_isinst (obj, mono_defaults.iserializeable_class)) {
 266                 static MonoMethod *serinfo_ctor1 = NULL, *serinfo_ctor2 = NULL, *get_entries = NULL;
 267                 MonoMethod *get_object_data, *ser_ctor;
 268                 MonoObject *src_serinfo, *dst_serinfo;
 269                 void *pa [2];
 270                 MonoStreamingContext ctx;
 271                 MonoArray *entries, *trans_entries;
 272                 int len;
 273
 274                 /* get a pointer to the GetObjectData method */
 275                 get_object_data = klass->vtable [klass->interface_offsets [mono_defaults.iserializeable_class->interface_id]];
 276                 g_assert (get_object_data);
 277
 278                 src_serinfo = mono_object_new (src, sic);
 279
 280                 if (!serinfo_ctor1) {
 281                         for (i = 0; i < sic->method.count; ++i) {
 282                                 if (!strcmp (".ctor", sic->methods [i]->name) &&
 283                                     sic->methods [i]->signature->param_count == 1) {
 284                                         serinfo_ctor1 = sic->methods [i];
 285                                         break;
 286                                 }
 287                         }
 288                         g_assert (serinfo_ctor1);
 289                 }
 290
 291                 if (!serinfo_ctor2) {
 292                         for (i = 0; i < sic->method.count; ++i) {
 293                                 if (!strcmp (".ctor", sic->methods [i]->name) &&
 294                                     sic->methods [i]->signature->param_count == 2 &&
 295                                     sic->methods [i]->signature->params [1]->type == MONO_TYPE_SZARRAY) {
 296                                         serinfo_ctor2 = sic->methods [i];
 297                                         break;
 298                                 }
 299                         }
 300                         g_assert (serinfo_ctor2);
 301                 }
 302
 303                 if (!get_entries) {
 304                         for (i = 0; i < sic->method.count; ++i) {
 305                                 if (!strcmp ("get_entries", sic->methods [i]->name) &&
 306                                     sic->methods [i]->signature->param_count == 0) {
 307                                         get_entries = sic->methods [i];
 308                                         break;
 309                                 }
 310                         }
 311                         g_assert (get_entries);
 312                 }
 313
 314                 pa [0] = mono_type_get_object (src, &klass->byval_arg);
 315                 mono_runtime_invoke_in_domain (src, serinfo_ctor1, src_serinfo, pa, NULL);
 316
 317                 ctx.additional = NULL;
 318                 ctx.state = 128; /* CrossAppDomain */
 319                 pa [0] = src_serinfo;
 320                 pa [1] = &ctx;
 321                 mono_runtime_invoke_in_domain (src, get_object_data, obj, pa, NULL);
 322
 323                 entries = (MonoArray *)mono_runtime_invoke_in_domain (src, get_entries, src_serinfo, NULL, NULL);
 324
 325                 g_assert (src_serinfo->vtable->domain == src);
 326                 g_assert (entries->obj.vtable->domain == src);
 327
 328                 /* transfer all SerializationEntry objects */
 329                 len = mono_array_length ((MonoArray*)entries);
 330                 trans_entries = mono_array_new (dst, entries->obj.vtable->klass->element_class, len);
 331
 332                 for (i = 0; i < len; i++) {
 333                         MonoSerializationEntry *s, *d;
 334                         s = (MonoSerializationEntry *)mono_array_addr_with_size (entries,
 335                                 sizeof (MonoSerializationEntry), i);
 336                         d = (MonoSerializationEntry *)mono_array_addr_with_size (trans_entries,
 337                                 sizeof (MonoSerializationEntry), i);
 338                         d->name = (MonoString *)mono_domain_transfer_object (src, dst, (MonoObject *)s->name);
 339                         d->value = mono_domain_transfer_object (src, dst, s->value);
 340                         d->type = (MonoReflectionType *)mono_domain_transfer_object (src, dst, (MonoObject *)s->type);
 341                 }
 342
 343                 dst_serinfo = mono_object_new (dst, sic);
 344
 345                 pa [0] = mono_type_get_object (dst, &klass->byval_arg);
 346                 pa [1] = trans_entries;
 347                 mono_runtime_invoke_in_domain (dst, serinfo_ctor2, dst_serinfo, pa, NULL);
 348
 349                 ser_ctor = NULL;
 350                 for (i = 0; i < klass->method.count; i++) {
 351                         MonoMethod *t = klass->methods [i];
 352                         if (!strcmp (t->name, ".ctor") && t->signature->param_count == 2 &&
 353                             mono_metadata_type_equal (t->signature->params [0],
 354                                                       &mono_defaults.serializationinfo_class->byval_arg) &&
 355                             mono_metadata_type_equal (t->signature->params [1],
 356                                                       &mono_defaults.streamingcontext_class->byval_arg))
 357                                 ser_ctor = t;
 358                 }
 359                 g_assert (ser_ctor);
 360
 361                 res = mono_object_new (dst, klass);
 362
 363                 ctx.additional = NULL;
 364                 ctx.state = 128; /* CrossAppDomain */
 365                 pa [0] = dst_serinfo;
 366                 pa [1] = &ctx;
 367                 mono_runtime_invoke_in_domain (dst, ser_ctor, res, pa, NULL);
 368
 369                 return res;
 370         }
 371
 372         if (!(klass->flags & TYPE_ATTRIBUTE_SERIALIZABLE)) {
 373                 MonoException *exc = NULL;
 374                 char *msg;
 375
 376                 msg = g_strdup_printf ("klass \"%s.%s\" is not serializable",
 377                                        klass->name_space, klass->name);
 378                 exc = mono_get_exception_serialization (msg);
 379                 g_free (msg);
 380
 381                 mono_raise_exception (exc);
 382         }
 383
 384         res = mono_object_new (dst, klass);
 385
 386         for (i = 0; i < klass->field.count; i++) {
 387                 MonoClassField *field = &klass->fields [i];
 388                 MonoType *type = field->type;
 389                 int size, align;
 390                 char *src_ptr, *dst_ptr;
 391                 int simple_type;
 392
 393                 if (type->attrs & FIELD_ATTRIBUTE_STATIC ||
 394                     type->attrs & FIELD_ATTRIBUTE_NOT_SERIALIZED)
 395                         continue;
 396
 397                 size = mono_type_size (type, &align);
 398
 399                 dst_ptr = (char*)res + field->offset;
 400                 src_ptr = (char *)obj + field->offset;
 401
 402                 g_assert (!type->byref);
 403
 404                 simple_type = type->type;
 405         handle_enum:
 406                 switch (simple_type) {
 407                 case MONO_TYPE_BOOLEAN:
 408                 case MONO_TYPE_CHAR:
 409                 case MONO_TYPE_I1:
 410                 case MONO_TYPE_U1:
 411                 case MONO_TYPE_I2:
 412                 case MONO_TYPE_U2:
 413                 case MONO_TYPE_I4:
 414                 case MONO_TYPE_U4:
 415                 case MONO_TYPE_I:
 416                 case MONO_TYPE_U:
 417                 case MONO_TYPE_I8:
 418                 case MONO_TYPE_U8:
 419                 case MONO_TYPE_R4:
 420                 case MONO_TYPE_R8:
 421                         memcpy (dst_ptr, src_ptr, size);
 422                         break;
 423                 case MONO_TYPE_OBJECT:
 424                 case MONO_TYPE_ARRAY:
 425                 case MONO_TYPE_SZARRAY:
 426                 case MONO_TYPE_CLASS:
 427                 case MONO_TYPE_STRING: {
 428                         *(MonoObject **)dst_ptr = mono_domain_transfer_object (src, dst, *(MonoObject **)src_ptr);
 429                         break;
 430                 }
 431                 case MONO_TYPE_VALUETYPE: {
 432                         MonoObject *boxed_src, *tmp;
 433
 434                         if (type->data.klass->enumtype) {
 435                                 simple_type = type->data.klass->enum_basetype->type;
 436                                 goto handle_enum;
 437                         }
 438                         boxed_src = mono_value_box (src, type->data.klass, src_ptr);
 439                         tmp = mono_domain_transfer_object (src, dst, boxed_src);
 440                         memcpy (dst_ptr, (char *)tmp + sizeof (MonoObject), size);
 441                         break;
 442                 }
 443                 default:
 444                         g_assert_not_reached ();
 445                 }
 446         }
 447
 448         return res;
 449 }
 450
 451 MonoObject *
 452 ves_icall_System_AppDomain_GetData (MonoAppDomain *ad, MonoString *name)
 453 {
 454         MonoDomain *add = ad->data;
 455         MonoDomain *cur = mono_domain_get ();
 456         MonoObject *o;
 457         char *str;
 458
 459         MONO_ARCH_SAVE_REGS;
 460
 461         g_assert (ad != NULL);
 462         g_assert (name != NULL);
 463
 464         str = mono_string_to_utf8 (name);
 465
 466         mono_domain_lock (add);
 467         if (!strcmp (str, "APPBASE"))
 468                 o = (MonoObject *)add->setup->application_base;
 469         else if (!strcmp (str, "APP_CONFIG_FILE"))
 470                 o = (MonoObject *)add->setup->configuration_file;
 471         else if (!strcmp (str, "DYNAMIC_BASE"))
 472                 o = (MonoObject *)add->setup->dynamic_base;
 473         else if (!strcmp (str, "APP_NAME"))
 474                 o = (MonoObject *)add->setup->application_name;
 475         else if (!strcmp (str, "CACHE_BASE"))
 476                 o = (MonoObject *)add->setup->cache_path;
 477         else if (!strcmp (str, "PRIVATE_BINPATH"))
 478                 o = (MonoObject *)add->setup->private_bin_path;
 479         else if (!strcmp (str, "BINPATH_PROBE_ONLY"))
 480                 o = (MonoObject *)add->setup->private_bin_path_probe;
 481         else if (!strcmp (str, "SHADOW_COPY_DIRS"))
 482                 o = (MonoObject *)add->setup->shadow_copy_directories;
 483         else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
 484                 o = (MonoObject *)add->setup->shadow_copy_files;
 485         else
 486                 o = mono_g_hash_table_lookup (add->env, name);
 487
 488         mono_domain_unlock (add);
 489         g_free (str);
 490
 491         if (!o)
 492                 return NULL;
 493
 494         return mono_domain_transfer_object (add, cur, o);
 495 }
 496
 497 void
 498 ves_icall_System_AppDomain_SetData (MonoAppDomain *ad, MonoString *name, MonoObject *data)
 499 {
 500         MonoDomain *add = ad->data;
 501         MonoDomain *cur = mono_domain_get ();
 502         MonoObject *o;
 503
 504         MONO_ARCH_SAVE_REGS;
 505
 506         g_assert (ad != NULL);
 507         g_assert (name != NULL);
 508
 509         o = mono_domain_transfer_object (cur, add, data);
 510
 511         mono_domain_lock (add);
 512         mono_g_hash_table_insert (add->env, name, o);
 513
 514         mono_domain_unlock (add);
 515 }
 516
 517 MonoAppDomainSetup *
 518 ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
 519 {
 520         MONO_ARCH_SAVE_REGS;
 521
 522         g_assert (ad != NULL);
 523         g_assert (ad->data != NULL);
 524
 525         return ad->data->setup;
 526 }
 527
 528 MonoString *
 529 ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
 530 {
 531         MONO_ARCH_SAVE_REGS;
 532
 533         g_assert (ad != NULL);
 534         g_assert (ad->data != NULL);
 535
 536         return mono_string_new (ad->data, ad->data->friendly_name);
 537 }
 538
 539 MonoAppDomain *
 540 ves_icall_System_AppDomain_getCurDomain ()
 541 {
 542         MonoDomain *add = mono_domain_get ();
 543
 544         MONO_ARCH_SAVE_REGS;
 545
 546         return add->domain;
 547 }
 548
 549 MonoAppDomain *
 550 ves_icall_System_AppDomain_createDomain (MonoString *friendly_name, MonoAppDomainSetup *setup)
 551 {
 552         MonoDomain *domain = mono_domain_get ();
 553         MonoClass *adclass;
 554         MonoAppDomain *ad;
 555         MonoDomain *data;
 556
 557         MONO_ARCH_SAVE_REGS;
 558
 559         adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
 560
 561         /* FIXME: pin all those objects */
 562         ad = (MonoAppDomain *) mono_object_new (domain, adclass);
 563         ad->data = data = mono_domain_create ();
 564         data->domain = ad;
 565         data->setup = setup;
 566         data->friendly_name = mono_string_to_utf8 (friendly_name);
 567
 568         /* FIXME: what to do next ? */
 569
 570         return ad;
 571 }
 572
 573 typedef struct {
 574         MonoArray *res;
 575         MonoDomain *domain;
 576         int idx;
 577 } add_assembly_helper_t;
 578
 579 static void
 580 add_assembly (gpointer key, gpointer value, gpointer user_data)
 581 {
 582         add_assembly_helper_t *ah = (add_assembly_helper_t *) user_data;
 583
 584         mono_array_set (ah->res, gpointer, ah->idx++, mono_assembly_get_object (ah->domain, value));
 585 }
 586
 587 MonoArray *
 588 ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad)
 589 {
 590         MonoDomain *domain = ad->data;
 591         static MonoClass *System_Reflection_Assembly;
 592         MonoArray *res;
 593         add_assembly_helper_t ah;
 594
 595         MONO_ARCH_SAVE_REGS;
 596
 597         if (!System_Reflection_Assembly)
 598                 System_Reflection_Assembly = mono_class_from_name (
 599                         mono_defaults.corlib, "System.Reflection", "Assembly");
 600
 601         res = mono_array_new (domain, System_Reflection_Assembly, g_hash_table_size (domain->assemblies));
 602
 603         ah.domain = domain;
 604         ah.res = res;
 605         ah.idx = 0;
 606         mono_domain_lock (domain);
 607         g_hash_table_foreach (domain->assemblies, add_assembly, &ah);
 608         mono_domain_unlock (domain);
 609
 610         return res;
 611 }
 612
 613 /*
 614  * Used to find methods in AppDomain class.
 615  * It only works if there are no multiple signatures for any given method name
 616  */
 617 static MonoMethod *
 618 look_for_method_by_name (MonoClass *klass, const gchar *name)
 619 {
 620         gint i;
 621         MonoMethod *method;
 622
 623         for (i = 0; i < klass->method.count; i++) {
 624                 method = klass->methods [i];
 625                 if (!strcmp (method->name, name))
 626                         return method;
 627         }
 628
 629         return NULL;
 630 }
 631
 632 static MonoReflectionAssembly *
 633 try_assembly_resolve (MonoDomain *domain, MonoString *fname)
 634 {
 635         MonoClass *klass;
 636         MonoMethod *method;
 637         void *params [1];
 638
 639         g_assert (domain != NULL && fname != NULL);
 640
 641         klass = domain->domain->mbr.obj.vtable->klass;
 642         g_assert (klass);
 643
 644         method = look_for_method_by_name (klass, "DoAssemblyResolve");
 645         if (method == NULL) {
 646                 g_warning ("Method AppDomain.DoAssemblyResolve not found.\n");
 647                 return NULL;
 648         }
 649
 650         *params = fname;
 651         return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
 652 }
 653
 654 static void
 655 add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass)
 656 {
 657         gint i;
 658
 659         if (g_hash_table_lookup (domain->assemblies, ass->aname.name))
 660                 return; /* This is ok while no lazy loading of assemblies */
 661
 662         mono_domain_lock (domain);
 663         g_hash_table_insert (domain->assemblies, (gpointer) ass->aname.name, ass);
 664         mono_domain_unlock (domain);
 665
 666         for (i = 0; ass->image->references [i] != NULL; i++)
 667                 add_assemblies_to_domain (domain, ass->image->references [i]);
 668 }
 669
 670 static void
 671 mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data)
 672 {
 673         MonoDomain *domain = mono_domain_get ();
 674         MonoReflectionAssembly *ref_assembly;
 675         MonoClass *klass;
 676         MonoMethod *method;
 677         void *params [1];
 678
 679         klass = domain->domain->mbr.obj.vtable->klass;
 680
 681         method = look_for_method_by_name (klass, "DoAssemblyLoad");
 682         if (method == NULL) {
 683                 g_warning ("Method AppDomain.DoAssemblyLoad not found.\n");
 684                 return;
 685         }
 686
 687         add_assemblies_to_domain (domain, assembly);
 688
 689         ref_assembly = mono_assembly_get_object (domain, assembly);
 690         g_assert (ref_assembly);
 691
 692         *params = ref_assembly;
 693         mono_runtime_invoke (method, domain->domain, params, NULL);
 694 }
 695
 696 static void
 697 set_domain_search_path (MonoDomain *domain)
 698 {
 699         MonoAppDomainSetup *setup;
 700         gchar **tmp;
 701         gchar *utf8;
 702         gint i;
 703         gint npaths = 0;
 704         gchar **pvt_split = NULL;
 705
 706         if (domain->search_path != NULL)
 707                 return;
 708
 709         setup = domain->setup;
 710         if (setup->application_base)
 711                 npaths++;
 712
 713         if (setup->private_bin_path) {
 714                 utf8 = mono_string_to_utf8 (setup->private_bin_path);
 715                 pvt_split = g_strsplit (utf8, G_SEARCHPATH_SEPARATOR_S, 1000);
 716                 g_free (utf8);
 717                 for (tmp = pvt_split; *tmp; tmp++, npaths++);
 718         }
 719
 720         if (!npaths) {
 721                 if (pvt_split)
 722                         g_strfreev (pvt_split);
 723                 /*
 724                  * Don't do this because the first time is called, the domain
 725                  * setup is not finished.
 726                  *
 727                  * domain->search_path = g_malloc (sizeof (char *));
 728                  * domain->search_path [0] = NULL;
 729                 */
 730                 return;
 731         }
 732
 733         domain->search_path = tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
 734         tmp [npaths] = NULL;
 735         if (setup->application_base) {
 736                 *tmp = mono_string_to_utf8 (setup->application_base);
 737         } else {
 738                 *tmp = g_strdup ("");
 739         }
 740
 741         tmp++;
 742         npaths--;
 743         for (i = 0; i < npaths; i++)
 744                 tmp [i] = pvt_split [i];
 745
 746         g_strfreev (pvt_split);
 747 }
 748
 749 static MonoAssembly *
 750 real_load (gchar **search_path, gchar *filename)
 751 {
 752         MonoAssembly *result;
 753         gchar **path;
 754         gchar *fullpath;
 755
 756         for (path = search_path; *path; path++) {
 757                 if (**path == '\0')
 758                         continue; /* Ignore empty ApplicationBase */
 759                 fullpath = g_build_filename (*path, filename, NULL);
 760                 result = mono_assembly_open (fullpath, NULL);
 761                 g_free (fullpath);
 762                 if (result)
 763                         return result;
 764         }
 765
 766         return NULL;
 767 }
 768
 769 /*
 770  * Try loading the assembly from ApplicationBase and PrivateBinPath
 771  * and then from assemblies_path if any.
 772  */
 773 static MonoAssembly *
 774 mono_domain_assembly_preload (MonoAssemblyName *aname,
 775                               gchar **assemblies_path,
 776                               gpointer user_data)
 777 {
 778         MonoDomain *domain = mono_domain_get ();
 779         MonoAssembly *result;
 780         gchar *dll, *exe;
 781
 782         set_domain_search_path (domain);
 783
 784         dll = g_strconcat (aname->name, ".dll", NULL);
 785         exe = g_strdup (dll);
 786         strcpy (exe + strlen (exe) - 4, ".exe");
 787
 788         if (domain->search_path && domain->search_path [0] != NULL) {
 789                 /* TODO: should also search in name/name.dll and name/name.exe from appbase */
 790                 result = real_load (domain->search_path, dll);
 791                 if (result) {
 792                         g_free (dll);
 793                         g_free (exe);
 794                         return result;
 795                 }
 796
 797                 result = real_load (domain->search_path, exe);
 798                 if (result) {
 799                         g_free (dll);
 800                         g_free (exe);
 801                         return result;
 802                 }
 803         }
 804
 805         if (assemblies_path && assemblies_path [0] != NULL) {
 806                 result = real_load (assemblies_path, dll);
 807                 if (result) {
 808                         g_free (dll);
 809                         g_free (exe);
 810                         return result;
 811                 }
 812
 813                 result = real_load (assemblies_path, exe);
 814                 if (result) {
 815                         g_free (dll);
 816                         g_free (exe);
 817                         return result;
 818                 }
 819         }
 820
 821         g_free (dll);
 822         g_free (exe);
 823         return NULL;
 824 }
 825
 826 MonoReflectionAssembly *
 827 ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname)
 828 {
 829         MonoDomain *domain = mono_domain_get ();
 830         char *name, *filename;
 831         MonoImageOpenStatus status = MONO_IMAGE_OK;
 832         MonoAssembly *ass;
 833
 834         MONO_ARCH_SAVE_REGS;
 835
 836         if (fname == NULL) {
 837                 MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
 838                 mono_raise_exception (exc);
 839         }
 840
 841         name = filename = mono_string_to_utf8 (fname);
 842
 843         /* FIXME: move uri handling to mono_assembly_open */
 844         if (strncmp (filename, "file://", 7) == 0)
 845                 filename += 7;
 846
 847         ass = mono_assembly_open (filename, &status);
 848
 849         g_free (name);
 850
 851         if (!ass){
 852                 MonoException *exc = mono_get_exception_file_not_found (fname);
 853                 mono_raise_exception (exc);
 854         }
 855
 856         return mono_assembly_get_object (domain, ass);
 857 }
 858
 859 static void
 860 free_assembly_name (MonoAssemblyName *aname)
 861 {
 862         if (aname == NULL)
 863                 return;
 864
 865         g_free ((void *) aname->name);
 866         g_free ((void *) aname->culture);
 867         g_free ((void *) aname->hash_value);
 868 }
 869
 870 static gboolean
 871 get_info_from_assembly_name (MonoReflectionAssemblyName *assRef, MonoAssemblyName *aname)
 872 {
 873         gchar *name;
 874         gchar *value;
 875         gchar **parts;
 876         gchar **tmp;
 877         gint major, minor, build, revision;
 878
 879         memset (aname, 0, sizeof (MonoAssemblyName));
 880
 881         name = mono_string_to_utf8 (assRef->name);
 882         parts = tmp = g_strsplit (name, ",", 4);
 883         g_free (name);
 884         if (!tmp || !*tmp) {
 885                 g_strfreev (tmp);
 886                 return FALSE;
 887         }
 888
 889         value = g_strstrip (*tmp);
 890         /* g_print ("Assembly name: %s\n", value); */
 891         aname->name = g_strdup (value);
 892         tmp++;
 893         if (!*tmp) {
 894                 g_strfreev (parts);
 895                 return TRUE;
 896         }
 897
 898         value = g_strstrip (*tmp);
 899         if (strncmp (value, "Version=", 8)) {
 900                 g_strfreev (parts);
 901                 return FALSE;
 902         }
 903
 904         if (sscanf (value + 8, "%u.%u.%u.%u", &major, &minor, &build, &revision) != 4) {
 905                 g_strfreev (parts);
 906                 return FALSE;
 907         }
 908
 909         /* g_print ("Version: %u.%u.%u.%u\n", major, minor, build, revision); */
 910         aname->major = major;
 911         aname->minor = minor;
 912         aname->build = build;
 913         aname->revision = revision;
 914         tmp++;
 915
 916         if (!*tmp) {
 917                 g_strfreev (parts);
 918                 return FALSE;
 919         }
 920
 921         value = g_strstrip (*tmp);
 922         if (strncmp (value, "Culture=", 8)) {
 923                 g_strfreev (parts);
 924                 return FALSE;
 925         }
 926
 927         /* g_print ("Culture: %s\n", aname->culture); */
 928         aname->culture = g_strstrip (g_strdup (value + 8));
 929         tmp++;
 930
 931         if (!*tmp) {
 932                 g_strfreev (parts);
 933                 return FALSE;
 934         }
 935
 936         value = g_strstrip (*tmp);
 937         if (strncmp (value, "PublicKeyToken=", 15)) {
 938                 g_strfreev (parts);
 939                 return FALSE;
 940         }
 941
 942         value += 15;
 943         if (*value && strcmp (value, "null")) {
 944                 gint i, len;
 945                 gchar h, l;
 946                 gchar *result;
 947
 948                 value = g_strstrip (g_strdup (value));
 949                 len = strlen (value);
 950                 if (len % 2) {
 951                         g_strfreev (parts);
 952                         return FALSE;
 953                 }
 954
 955                 aname->hash_len = len / 2;
 956                 aname->hash_value = g_malloc0 (aname->hash_len);
 957                 result = (gchar *) aname->hash_value;
 958
 959                 for (i = 0; i < len; i++) {
 960                         if (i % 2) {
 961                                 l = g_ascii_xdigit_value (value [i]);
 962                                 if (l == -1) {
 963                                         g_strfreev (parts);
 964                                         return FALSE;
 965                                 }
 966                                 result [i / 2] = (h * 16) + l;
 967                         } else {
 968                                 h = g_ascii_xdigit_value (value [i]);
 969                                 if (h == -1) {
 970                                         g_strfreev (parts);
 971                                         return FALSE;
 972                                 }
 973                         }
 974                 }
 975
 976                 /*
 977                 g_print ("PublicKeyToken: ");
 978                 for (i = 0; i < aname->hash_len; i++) {
 979                         g_print ("%x", 0x00FF & aname->hash_value [i]);
 980                 }
 981                 g_print ("\n");
 982                 */
 983         }
 984
 985         g_strfreev (parts);
 986         return TRUE;
 987 }
 988
 989 MonoReflectionAssembly *
 990 ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,  MonoReflectionAssemblyName *assRef, MonoObject *evidence)
 991 {
 992         MonoDomain *domain = ad->data;
 993         MonoImageOpenStatus status = MONO_IMAGE_OK;
 994         MonoAssembly *ass;
 995         MonoAssemblyName aname;
 996         MonoReflectionAssembly *refass = NULL;
 997
 998         MONO_ARCH_SAVE_REGS;
 999
1000         memset (&aname, 0, sizeof (aname));
1001
1002         /* FIXME : examine evidence? */
1003
1004         g_assert (assRef != NULL);
1005         g_assert (assRef->name != NULL);
1006
1007         if (!get_info_from_assembly_name (assRef, &aname)) {
1008                 MonoException *exc;
1009
1010                 free_assembly_name (&aname);
1011                 /* This is a parse error... */
1012                 exc = mono_get_exception_file_not_found (assRef->name);
1013                 mono_raise_exception (exc);
1014         }
1015
1016         ass = mono_assembly_load (&aname, NULL, &status);
1017         free_assembly_name (&aname);
1018
1019         if (!ass && (refass = try_assembly_resolve (domain, assRef->name)) == NULL){
1020                 /* FIXME: it doesn't make much sense since we really don't have a filename ... */
1021                 MonoException *exc = mono_get_exception_file_not_found (assRef->name);
1022                 mono_raise_exception (exc);
1023         }
1024
1025         if (refass != NULL)
1026                 return refass;
1027
1028         return mono_assembly_get_object (domain, ass);
1029 }
1030
1031 void
1032 ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
1033 {
1034         MONO_ARCH_SAVE_REGS;
1035
1036         mono_domain_unload (ad->data, FALSE);
1037 }
1038
1039 gint32
1040 ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad, MonoString *file,
1041                                             MonoObject *evidence, MonoArray *args)
1042 {
1043         MonoDomain *cdom = mono_domain_get ();
1044         MonoAssembly *assembly;
1045         MonoImage *image;
1046         MonoMethod *method;
1047         MonoObject *margs;
1048         char *filename;
1049         gint32 res;
1050
1051         MONO_ARCH_SAVE_REGS;
1052
1053         mono_domain_set (ad->data);
1054
1055         filename = mono_string_to_utf8 (file);
1056         assembly = mono_assembly_open (filename, NULL);
1057         g_free (filename);
1058
1059         if (!assembly) {
1060                 mono_raise_exception ((MonoException *)mono_exception_from_name (
1061                         mono_defaults.corlib, "System.IO", "FileNotFoundException"));
1062         }
1063
1064         image = assembly->image;
1065
1066         method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
1067
1068         if (!method)
1069                 g_error ("No entry point method found in %s", image->name);
1070
1071         margs = mono_domain_transfer_object (cdom, ad->data, (MonoObject *)args);
1072         if (!margs)
1073                 margs = (MonoObject *) mono_array_new (ad->data, mono_defaults.string_class, 0);
1074         res = mono_runtime_exec_main (method, (MonoArray *)margs, NULL);
1075
1076         mono_domain_set (cdom);
1077
1078         return res;
1079 }
1080