mono/metadata/marshal-windows.c

   1 /**
   2  * \file
   3  * Windows marshal support.
   4  *
   5  * Copyright 2016 Microsoft
   6  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   7  */
   8 #include <config.h>
   9 #include <glib.h>
  10
  11 #if defined(HOST_WIN32)
  12 #include <winsock2.h>
  13 #include <windows.h>
  14 #include <objbase.h>
  15 #include "mono/metadata/marshal-windows-internals.h"
  16 #include "icall-decl.h"
  17
  18 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
  19 void*
  20 mono_marshal_alloc_hglobal (size_t size, MonoError *error)
  21 {
  22         void* p = GlobalAlloc (GMEM_FIXED, size);
  23         if (!p)
  24                 mono_error_set_out_of_memory (error, "");
  25         return p;
  26 }
  27
  28 gpointer
  29 mono_marshal_realloc_hglobal (gpointer ptr, size_t size)
  30 {
  31         return GlobalReAlloc (ptr, size, GMEM_MOVEABLE);
  32 }
  33
  34 void
  35 mono_marshal_free_hglobal (gpointer ptr)
  36 {
  37         GlobalFree (ptr);
  38 }
  39 #endif /* G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT) */
  40
  41 void*
  42 mono_marshal_alloc_co_task_mem (size_t size)
  43 {
  44         return CoTaskMemAlloc (size);
  45 }
  46
  47 void
  48 mono_marshal_free_co_task_mem (void *ptr)
  49 {
  50         CoTaskMemFree (ptr);
  51 }
  52
  53 gpointer
  54 mono_marshal_realloc_co_task_mem (gpointer ptr, size_t size)
  55 {
  56         return CoTaskMemRealloc (ptr, size);
  57 }
  58
  59 char*
  60 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (const gunichar2 *s, int length, MonoError *error)
  61 {
  62         // FIXME pass mono_utf16_to_utf8 an allocator to avoid double alloc/copy.
  63
  64         char* tres = mono_utf16_to_utf8 (s, length, error);
  65         return_val_if_nok (error, NULL);
  66         if (!tres)
  67                 return tres;
  68
  69         /*
  70          * mono_utf16_to_utf8() returns a memory area at least as large as length,
  71          * even if it contains NULL characters. The copy we allocate here has to be equally
  72          * large.
  73          */
  74         size_t len = MAX (strlen (tres) + 1, length);
  75         char* ret = (char*)ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (len, error);
  76         if (ret)
  77                 memcpy (ret, tres, len);
  78         g_free (tres);
  79         return ret;
  80 }
  81
  82 gpointer
  83 mono_string_to_utf8str_impl (MonoStringHandle s, MonoError *error)
  84 {
  85         char *as, *tmp;
  86         glong len;
  87         GError *gerror = NULL;
  88
  89         if (MONO_HANDLE_IS_NULL (s))
  90                 return NULL;
  91
  92         if (!mono_string_handle_length (s)) {
  93                 as = (char*)CoTaskMemAlloc (1);
  94                 g_assert (as);
  95                 as [0] = '\0';
  96                 return as;
  97         }
  98
  99         // FIXME pass g_utf16_to_utf8 an allocator to avoid double alloc/copy.
 100
 101         uint32_t gchandle = 0;
 102         tmp = g_utf16_to_utf8 (mono_string_handle_pin_chars (s, &gchandle), mono_string_handle_length (s), NULL, &len, &gerror);
 103         mono_gchandle_free_internal (gchandle);
 104         if (gerror) {
 105                 mono_error_set_argument (error, "string", gerror->message);
 106                 g_error_free (gerror);
 107                 return NULL;
 108         } else {
 109                 as = (char*)CoTaskMemAlloc (len + 1);
 110                 g_assert (as);
 111                 memcpy (as, tmp, len + 1);
 112                 g_free (tmp);
 113                 return as;
 114         }
 115 }
 116
 117 #endif /* HOST_WIN32 */