[metadata] Create strongly typed versions of mono_assembly_request_prepare (mono...

* [metadata] Create strongly typed versions of mono_assembly_request_prepare

Addresses the family of issues similar to Coverity mono/mono#1443346.

This came up as part of the Coverity review, and Coverity notices that this is
writting beyond the end of the structure.  While this is correct, this requires
that the idiom be properly followed - that is, that the structure being passed
is of the given size.

Replaced instead with a method that eliminates the room for error with methods
that will initialize the whole structure, and the actual size computation is
done inside the method with the proper type sizes.

While I used methods, I feel that this should use macros.

Commit migrated from https://github.com/mono/mono/commit/ce92c4376f31e9caf964938a3899d179bdc97e51

diff --git a/src/mono/mono/dis/main.c b/src/mono/mono/dis/main.c
index 9d8674b..24eb902 100644 (file)
--- a/src/mono/mono/dis/main.c
+++ b/src/mono/mono/dis/main.c
@@ -1634,7 +1634,8 @@ disassemble_file (const char *file)
                /* FIXME: is this call necessary? */
                /* FIXME: if it's necessary, can it be refonly instead? */
                MonoAssemblyLoadRequest req;
-               mono_assembly_request_prepare (&req, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
+               mono_assembly_request_prepare_load (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
+
                mono_assembly_request_load_from (img, file, &req, &status);
        }
 
@@ -1927,7 +1928,7 @@ monodis_preload (MonoAssemblyLoadContext *alc,
 
        if (assemblies_path && assemblies_path [0] != NULL) {
                MonoAssemblyOpenRequest req;
-               mono_assembly_request_prepare (&req.request, sizeof (req), refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, alc);
+               mono_assembly_request_prepare_open (&req, refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, alc);
 
                result = real_load (assemblies_path, aname->culture, aname->name, &req);
        }

diff --git a/src/mono/mono/metadata/appdomain.c b/src/mono/mono/metadata/appdomain.c
index da83ee1..dc9368d 100644 (file)
--- a/src/mono/mono/metadata/appdomain.c
+++ b/src/mono/mono/metadata/appdomain.c
@@ -2311,7 +2311,7 @@ mono_domain_assembly_preload (MonoAssemblyLoadContext *alc,
        }
 #endif
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, alc);
+       mono_assembly_request_prepare_open (&req, refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, alc);
        req.request.predicate = predicate;
        req.request.predicate_ud = predicate_ud;
 
@@ -2359,7 +2359,7 @@ mono_assembly_load_from_assemblies_path (gchar **assemblies_path, MonoAssemblyNa
        }
 #endif
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), asmctx, mono_domain_default_alc (mono_domain_get ()));
+       mono_assembly_request_prepare_open (&req, asmctx, mono_domain_default_alc (mono_domain_get ()));
        req.request.predicate = predicate;
        req.request.predicate_ud = predicate_ud;
        MonoAssembly *result = NULL;
@@ -2442,7 +2442,7 @@ ves_icall_System_Reflection_Assembly_InternalLoad (MonoStringHandle name_handle,
                alc = mono_domain_default_alc (domain);
        g_assert (alc);
        asmctx = MONO_ASMCTX_DEFAULT;
-       mono_assembly_request_prepare (&req.request, sizeof (req), asmctx, alc);
+       mono_assembly_request_prepare_byname (&req, asmctx, alc);
        req.basedir = NULL;
        req.no_postload_search = TRUE;
 
@@ -2494,7 +2494,7 @@ ves_icall_System_Reflection_Assembly_LoadFrom (MonoStringHandle fname, MonoBoole
 
        MonoAssembly *ass;
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), refOnly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_LOADFROM, mono_domain_default_alc (domain));
+       mono_assembly_request_prepare_open (&req, refOnly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_LOADFROM, mono_domain_default_alc (domain));
        req.requesting_assembly = requesting_assembly;
        ass = mono_assembly_request_open (filename, &req, &status);
        
@@ -2536,7 +2536,7 @@ mono_alc_load_file (MonoAssemblyLoadContext *alc, MonoStringHandle fname, MonoAs
 
        MonoImageOpenStatus status;
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), asmctx, alc);
+       mono_assembly_request_prepare_open (&req, asmctx, alc);
        req.requesting_assembly = executing_assembly;
        ass = mono_assembly_request_open (filename, &req, &status);
        if (!ass) {
@@ -2680,7 +2680,7 @@ mono_alc_load_raw_bytes (MonoAssemblyLoadContext *alc, guint8 *assembly_data, gu
        }
 
        MonoAssemblyLoadRequest req;
-       mono_assembly_request_prepare (&req, sizeof (req), refonly? MONO_ASMCTX_REFONLY : MONO_ASMCTX_INDIVIDUAL, alc);
+       mono_assembly_request_prepare_load (&req, refonly? MONO_ASMCTX_REFONLY : MONO_ASMCTX_INDIVIDUAL, alc);
        ass = mono_assembly_request_load_from (image, "", &req, &status);
 
        if (!ass) {
@@ -2746,7 +2746,7 @@ ves_icall_System_AppDomain_LoadAssembly (MonoAppDomainHandle ad, MonoStringHandl
 
 
        MonoAssemblyByNameRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), asmctx, mono_domain_default_alc (domain));
+       mono_assembly_request_prepare_byname (&req, asmctx, mono_domain_default_alc (domain));
        req.basedir = basedir;
        req.no_postload_search = TRUE;
        ass = mono_assembly_request_byname (&aname, &req, &status);

diff --git a/src/mono/mono/metadata/assembly-internals.h b/src/mono/mono/metadata/assembly-internals.h
index 64ef82a..96e7da3 100644 (file)
--- a/src/mono/mono/metadata/assembly-internals.h
+++ b/src/mono/mono/metadata/assembly-internals.h
@@ -102,10 +102,17 @@ typedef struct MonoAssemblyByNameRequest {
        /* FIXME: predicate unused? */
 } MonoAssemblyByNameRequest;
 
-void                   mono_assembly_request_prepare (MonoAssemblyLoadRequest *req,
-                                                     size_t req_size,
-                                                     MonoAssemblyContextKind asmctx,
-                                                     MonoAssemblyLoadContext *alc);
+void                   mono_assembly_request_prepare_load (MonoAssemblyLoadRequest *req,
+                                                          MonoAssemblyContextKind asmctx,
+                                                          MonoAssemblyLoadContext *alc);
+
+void                   mono_assembly_request_prepare_open (MonoAssemblyOpenRequest *req,
+                                                          MonoAssemblyContextKind asmctx,
+                                                          MonoAssemblyLoadContext *alc);
+
+void                   mono_assembly_request_prepare_byname (MonoAssemblyByNameRequest *req,
+                                                            MonoAssemblyContextKind asmctx,
+                                                            MonoAssemblyLoadContext *alc);
 
 MonoAssembly*          mono_assembly_request_open (const char *filename,
                                                     const MonoAssemblyOpenRequest *req,

diff --git a/src/mono/mono/metadata/assembly.c b/src/mono/mono/metadata/assembly.c
index ba37820..66c938f 100644 (file)
--- a/src/mono/mono/metadata/assembly.c
+++ b/src/mono/mono/metadata/assembly.c
@@ -753,23 +753,53 @@ assembly_names_compare_versions (MonoAssemblyName *l, MonoAssemblyName *r, int m
 }
 
 /**
- * mono_assembly_request_prepare:
- * \param req the request to be initialized
- * \param req_size the size of the request structure
+ * mono_assembly_request_prepare_load:
+ * \param req the load request to be initialized
  * \param asmctx the assembly load context kind
  * \param alc the AssemblyLoadContext in netcore
  *
- * Initialize an assembly loader request.  The passed structure \p req must be
- * of size \p req_size.  Its state will be reset and the assembly context kind will be prefilled with \p asmctx.
+ * Initialize an assembly loader request.  Its state will be reset and the assembly context kind will be prefilled with \p asmctx.
  */
 void
-mono_assembly_request_prepare (MonoAssemblyLoadRequest *req, size_t req_size, MonoAssemblyContextKind asmctx, MonoAssemblyLoadContext *alc)
+mono_assembly_request_prepare_load (MonoAssemblyLoadRequest *req, MonoAssemblyContextKind asmctx, MonoAssemblyLoadContext *alc)
 {
-       memset (req, 0, req_size);
+       memset (req, 0, sizeof (MonoAssemblyLoadRequest));
        req->asmctx = asmctx;
        req->alc = alc;
 }
 
+/**
+ * mono_assembly_request_prepare_open:
+ * \param req the open request to be initialized
+ * \param asmctx the assembly load context kind
+ * \param alc the AssemblyLoadContext in netcore
+ *
+ * Initialize an assembly loader request intended to be used for open operations.  Its state will be reset and the assembly context kind will be prefilled with \p asmctx.
+ */
+void
+mono_assembly_request_prepare_open (MonoAssemblyOpenRequest *req, MonoAssemblyContextKind asmctx, MonoAssemblyLoadContext *alc)
+{
+       memset (req, 0, sizeof (MonoAssemblyOpenRequest));
+       req->request.asmctx = asmctx;
+       req->request.alc = alc;
+}
+
+/**
+ * mono_assembly_request_prepare_byname:
+ * \param req the byname request to be initialized
+ * \param asmctx the assembly load context kind
+ * \param alc the AssemblyLoadContext in netcore
+ *
+ * Initialize an assembly load by name request.  Its state will be reset and the assembly context kind will be prefilled with \p asmctx.
+ */
+void
+mono_assembly_request_prepare_byname (MonoAssemblyByNameRequest *req, MonoAssemblyContextKind asmctx, MonoAssemblyLoadContext *alc)
+{
+       memset (req, 0, sizeof (MonoAssemblyByNameRequest));
+       req->request.asmctx = asmctx;
+       req->request.alc = alc;
+}
+
 static MonoAssembly *
 load_in_path (const char *basename, const char** search_path, const MonoAssemblyOpenRequest *req, MonoImageOpenStatus *status)
 {
@@ -1478,7 +1508,7 @@ load_reference_by_aname_refonly_asmctx (MonoAssemblyName *aname, MonoAssemblyLoa
                /* We use the loaded corlib */
                if (!strcmp (aname->name, MONO_ASSEMBLY_CORLIB_NAME)) {
                        MonoAssemblyByNameRequest req;
-                       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+                       mono_assembly_request_prepare_byname (&req, MONO_ASMCTX_DEFAULT, alc);
                        req.requesting_assembly = assm;
                        req.basedir = assm->basedir;
                        reference = mono_assembly_request_byname (aname, &req, status);
@@ -1513,7 +1543,7 @@ load_reference_by_aname_default_asmctx (MonoAssemblyName *aname, MonoAssemblyLoa
                 * example bug-349190.2.cs and who knows how much more code in the wild.
                 */
                MonoAssemblyByNameRequest req;
-               mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+               mono_assembly_request_prepare_byname (&req, MONO_ASMCTX_DEFAULT, alc);
                req.requesting_assembly = assm;
                reference = mono_assembly_request_byname (aname, &req, status);
                if (!reference && assm) {
@@ -1532,7 +1562,7 @@ load_reference_by_aname_loadfrom_asmctx (MonoAssemblyName *aname, MonoAssemblyLo
 {
        MonoAssembly *reference = NULL;
        MonoAssemblyByNameRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_LOADFROM, alc);
+       mono_assembly_request_prepare_byname (&req, MONO_ASMCTX_LOADFROM, alc);
        req.requesting_assembly = requesting;
        req.basedir = requesting->basedir;
        /* Just like default search, but look in the requesting assembly basedir right away */
@@ -1571,7 +1601,7 @@ load_reference_by_aname_individual_asmctx (MonoAssemblyName *aname, MonoAssembly
         */
        if (!reference) {
                MonoAssemblyByNameRequest req;
-               mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_alc_domain (alc)));
+               mono_assembly_request_prepare_byname (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_alc_domain (alc)));
                req.requesting_assembly = requesting;
                reference = mono_assembly_request_byname (aname, &req, status);
        }
@@ -1622,7 +1652,7 @@ netcore_load_reference (MonoAssemblyName *aname, MonoAssemblyLoadContext *alc, M
 
        if (is_default || !is_satellite) {
                MonoAssemblyByNameRequest req;
-               mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_alc_domain (alc)));
+               mono_assembly_request_prepare_byname (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_alc_domain (alc)));
                req.requesting_assembly = requesting;
                reference = mono_assembly_request_byname (aname, &req, status);
                if (reference)
@@ -2379,7 +2409,7 @@ mono_assembly_open_full (const char *filename, MonoImageOpenStatus *status, gboo
        MonoAssembly *res;
        MONO_ENTER_GC_UNSAFE;
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req),
+       mono_assembly_request_prepare_open (&req,
                                       refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT,
                                       mono_domain_default_alc (mono_domain_get ()));
        res = mono_assembly_request_open (filename, &req, status);
@@ -2797,7 +2827,7 @@ mono_assembly_binding_applies_to_image (MonoAssemblyLoadContext *alc, MonoImage*
                MonoImageOpenStatus new_status = MONO_IMAGE_OK;
 
                MonoAssemblyByNameRequest new_req;
-               mono_assembly_request_prepare (&new_req.request, sizeof (new_req), new_asmctx, alc);
+               mono_assembly_request_prepare_byname (&new_req, new_asmctx, alc);
                new_req.requesting_assembly = new_requesting;
                new_req.basedir = new_basedir;
                result_ass = mono_assembly_request_byname (result_name, &new_req, &new_status);
@@ -2854,7 +2884,7 @@ mono_problematic_image_reprobe (MonoAssemblyLoadContext *alc, MonoImage *image,
        MonoAssembly *new_requesting = NULL;
        MonoImageOpenStatus new_status = MONO_IMAGE_OK;
        MonoAssemblyByNameRequest new_req;
-       mono_assembly_request_prepare (&new_req.request, sizeof (new_req), new_asmctx, alc);
+       mono_assembly_request_prepare_byname (&new_req, new_asmctx, alc);
        new_req.requesting_assembly = new_requesting;
        new_req.basedir = new_basedir;
        // Note: this interacts with mono_image_open_a_lot (). If the path from
@@ -2898,7 +2928,7 @@ mono_assembly_open (const char *filename, MonoImageOpenStatus *status)
        MonoAssembly *res;
        MONO_ENTER_GC_UNSAFE;
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
+       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
        res = mono_assembly_request_open (filename, &req, status);
        MONO_EXIT_GC_UNSAFE;
        return res;
@@ -2933,7 +2963,7 @@ mono_assembly_load_from_full (MonoImage *image, const char*fname,
        MonoImageOpenStatus def_status;
        if (!status)
                status = &def_status;
-       mono_assembly_request_prepare (&req, sizeof (req), refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
+       mono_assembly_request_prepare_load (&req, refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
        res = mono_assembly_request_load_from (image, fname, &req, status);
        MONO_EXIT_GC_UNSAFE;
        return res;
@@ -3126,7 +3156,7 @@ mono_assembly_load_from (MonoImage *image, const char *fname,
        MonoImageOpenStatus def_status;
        if (!status)
                status = &def_status;
-       mono_assembly_request_prepare (&req, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
+       mono_assembly_request_prepare_load (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
        res = mono_assembly_request_load_from (image, fname, &req, status);
        MONO_EXIT_GC_UNSAFE;
        return res;
@@ -3761,7 +3791,7 @@ probe_for_partial_name (const char *basepath, const char *fullname, MonoAssembly
                return NULL;
        else {
                MonoAssemblyOpenRequest req;
-               mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+               mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
                MonoAssembly *res = mono_assembly_request_open (fullpath, &req, status);
                g_free (fullpath);
                return res;
@@ -4339,7 +4369,7 @@ mono_assembly_load_from_gac (MonoAssemblyName *aname,  gchar *filename, MonoImag
        g_free (culture);
 
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req),
+       mono_assembly_request_prepare_open (&req,
                                       refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT,
                                       mono_domain_default_alc (mono_domain_get ()));
 
@@ -4378,7 +4408,7 @@ mono_assembly_load_corlib (const MonoRuntimeInfo *runtime, MonoImageOpenStatus *
 {
        MonoAssemblyName *aname;
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
+       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
 
        if (corlib) {
                /* g_print ("corlib already loaded\n"); */
@@ -4610,7 +4640,7 @@ mono_assembly_load_full_gac_base_default (MonoAssemblyName *aname,
 #endif
 
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), asmctx, alc);
+       mono_assembly_request_prepare_open (&req, asmctx, alc);
        req.request.predicate = predicate;
        req.request.predicate_ud = predicate_ud;
 
@@ -4695,7 +4725,7 @@ mono_assembly_load_full (MonoAssemblyName *aname, const char *basedir, MonoImage
        MonoAssembly *res;
        MONO_ENTER_GC_UNSAFE;
        MonoAssemblyByNameRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req),
+       mono_assembly_request_prepare_byname (&req,
                                       refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT,
                                       mono_domain_default_alc (mono_domain_get ()));
        req.requesting_assembly = NULL;
@@ -4721,7 +4751,7 @@ MonoAssembly*
 mono_assembly_load (MonoAssemblyName *aname, const char *basedir, MonoImageOpenStatus *status)
 {
        MonoAssemblyByNameRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
+       mono_assembly_request_prepare_byname (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
        req.requesting_assembly = NULL;
        req.basedir = basedir;
        return mono_assembly_request_byname (aname, &req, status);

diff --git a/src/mono/mono/metadata/attach.c b/src/mono/mono/metadata/attach.c
index ae326b9..0a74b9e 100644 (file)
--- a/src/mono/mono/metadata/attach.c
+++ b/src/mono/mono/metadata/attach.c
@@ -277,7 +277,7 @@ mono_attach_load_agent (MonoDomain *domain, char *agent, char *args, MonoObject
        MonoImageOpenStatus open_status;
 
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
+       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_domain_get ()));
        agent_assembly = mono_assembly_request_open (agent, &req, &open_status);
        if (!agent_assembly) {
                fprintf (stderr, "Cannot open agent assembly '%s': %s.\n", agent, mono_image_strerror (open_status));

diff --git a/src/mono/mono/metadata/coree.c b/src/mono/mono/metadata/coree.c
index a030d3c..9f09564 100644 (file)
--- a/src/mono/mono/metadata/coree.c
+++ b/src/mono/mono/metadata/coree.c
@@ -123,7 +123,7 @@ BOOL STDMETHODCALLTYPE _CorDllMain(HINSTANCE hInst, DWORD dwReason, LPVOID lpRes
                 */
                if (image->tables [MONO_TABLE_ASSEMBLY].rows && image->image_info->cli_cli_header.ch_vtable_fixups.rva) {
                        MonoAssemblyOpenRequest req;
-                       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+                       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
                        assembly = mono_assembly_request_open (file_name, &req, NULL);
                }
 
@@ -177,7 +177,7 @@ __int32 STDMETHODCALLTYPE _CorExeMain(void)
        }
 
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
+       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
        assembly = mono_assembly_request_open (file_name, &req, NULL);
        mono_close_exe_image ();
        if (!assembly) {

diff --git a/src/mono/mono/metadata/domain.c b/src/mono/mono/metadata/domain.c
index da1d8a5..bb9ec97 100644 (file)
--- a/src/mono/mono/metadata/domain.c
+++ b/src/mono/mono/metadata/domain.c
@@ -1059,7 +1059,7 @@ mono_domain_assembly_open_internal (MonoDomain *domain, MonoAssemblyLoadContext
 #endif
 
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
        if (domain != mono_domain_get ()) {
                current = mono_domain_get ();
 

diff --git a/src/mono/mono/metadata/mono-security.c b/src/mono/mono/metadata/mono-security.c
index 2d726dd..2f1ad59 100644 (file)
--- a/src/mono/mono/metadata/mono-security.c
+++ b/src/mono/mono/metadata/mono-security.c
@@ -615,7 +615,7 @@ mono_invoke_protected_memory_method (MonoArrayHandle data, MonoObjectHandle scop
                        system_security_assembly = mono_image_loaded_internal (alc, "System.Security", FALSE);
                        if (!system_security_assembly) {
                                MonoAssemblyOpenRequest req;
-                               mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+                               mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
                                MonoAssembly *sa = mono_assembly_request_open ("System.Security.dll", &req, NULL);
                                g_assert (sa);
                                system_security_assembly = mono_assembly_get_image_internal (sa);

diff --git a/src/mono/mono/metadata/w32socket.c b/src/mono/mono/metadata/w32socket.c
index 7a94753..639f331 100644 (file)
--- a/src/mono/mono/metadata/w32socket.c
+++ b/src/mono/mono/metadata/w32socket.c
@@ -726,7 +726,7 @@ get_socket_assembly (void)
                socket_assembly = mono_image_loaded_internal (alc, "System", FALSE);
                if (!socket_assembly) {
                        MonoAssemblyOpenRequest req;
-                       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+                       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
                        MonoAssembly *sa = mono_assembly_request_open ("System.dll", &req, NULL);
                
                        if (!sa) {
@@ -1854,7 +1854,7 @@ ves_icall_System_Net_Sockets_Socket_GetSocketOption_obj_internal (gsize sock, gi
                        mono_posix_image = mono_image_loaded_internal (alc, "Mono.Posix", FALSE);
                        if (!mono_posix_image) {
                                MonoAssemblyOpenRequest req;
-                               mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+                               mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
                                MonoAssembly *sa = mono_assembly_request_open ("Mono.Posix.dll", &req, NULL);
                                if (!sa) {
                                        *werror = WSAENOPROTOOPT;

diff --git a/src/mono/mono/mini/aot-runtime.c b/src/mono/mono/mini/aot-runtime.c
index 7c2bf4e..7185a89 100644 (file)
--- a/src/mono/mono/mini/aot-runtime.c
+++ b/src/mono/mono/mini/aot-runtime.c
@@ -2093,7 +2093,7 @@ if (container_assm_name && !container_amodule) {
        MonoImageOpenStatus status = MONO_IMAGE_OK;
        MonoAssemblyOpenRequest req;
        gchar *dll = g_strdup_printf (          "%s.dll", local_ref);
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, alc);
+       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, alc);
        MonoAssembly *assm = mono_assembly_request_open (dll, &req, &status);
        if (!assm) {
                gchar *exe = g_strdup_printf ("%s.exe", local_ref);

diff --git a/src/mono/mono/mini/driver.c b/src/mono/mono/mini/driver.c
index c70c2f2..aeb74bd 100644 (file)
--- a/src/mono/mono/mini/driver.c
+++ b/src/mono/mono/mini/driver.c
@@ -666,7 +666,7 @@ mini_regression_list (int verbose, int count, char *images [])
        total_run =  total = 0;
        for (i = 0; i < count; ++i) {
                MonoAssemblyOpenRequest req;
-               mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
+               mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
                ass = mono_assembly_request_open (images [i], &req, NULL);
                if (!ass) {
                        g_warning ("failed to load assembly: %s", images [i]);
@@ -793,7 +793,7 @@ mono_interp_regression_list (int verbose, int count, char *images [])
        total_run = total = 0;
        for (i = 0; i < count; ++i) {
                MonoAssemblyOpenRequest req;
-               mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
+               mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
                MonoAssembly *ass = mono_assembly_request_open (images [i], &req, NULL);
                if (!ass) {
                        g_warning ("failed to load assembly: %s", images [i]);
@@ -1429,7 +1429,7 @@ load_agent (MonoDomain *domain, char *desc)
        }
 
        MonoAssemblyOpenRequest req;
-       mono_assembly_request_prepare (&req.request, sizeof (req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
+       mono_assembly_request_prepare_open (&req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
        agent_assembly = mono_assembly_request_open (agent, &req, &open_status);
        if (!agent_assembly) {
                fprintf (stderr, "Cannot open agent assembly '%s': %s.\n", agent, mono_image_strerror (open_status));
@@ -2584,7 +2584,7 @@ mono_main (int argc, char* argv[])
        }
 
        MonoAssemblyOpenRequest open_req;
-       mono_assembly_request_prepare (&open_req.request, sizeof (open_req), MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
+       mono_assembly_request_prepare_open (&open_req, MONO_ASMCTX_DEFAULT, mono_domain_default_alc (mono_get_root_domain ()));
        assembly = mono_assembly_request_open (aname, &open_req, &open_status);
        if (!assembly && !mono_compile_aot) {
                fprintf (stderr, "Cannot open assembly '%s': %s.\n", aname, mono_image_strerror (open_status));

diff --git a/src/mono/mono/mini/main-core.c b/src/mono/mono/mini/main-core.c
index 6d4e2a8..7d0be45 100644 (file)
--- a/src/mono/mono/mini/main-core.c
+++ b/src/mono/mono/mini/main-core.c
@@ -139,7 +139,7 @@ mono_core_preload_hook (MonoAssemblyLoadContext *alc, MonoAssemblyName *aname, c
        for (int i = 0; i < a->assembly_count; ++i) {
                if (!strcmp (basename, a->basenames[i])) {
                        MonoAssemblyOpenRequest req;
-                       mono_assembly_request_prepare (&req.request, sizeof (req), refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, default_alc);
+                       mono_assembly_request_prepare_open (&req, refonly ? MONO_ASMCTX_REFONLY : MONO_ASMCTX_DEFAULT, default_alc);
                        req.request.predicate = predicate;
                        req.request.predicate_ud = predicate_ud;