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
  13 #include <winsock2.h>
  14 #include <windows.h>
  15 #include <objbase.h>
  16 #include "mono/metadata/marshal-windows-internals.h"
  17 #include "icall-decl.h"
  18
  19 #if G_HAVE_API_SUPPORT(HAVE_CLASSIC_WINAPI_SUPPORT)
  20
  21 void*
  22 mono_marshal_alloc_hglobal (size_t size)
  23 {
  24         return GlobalAlloc (GMEM_FIXED, size);
  25 }
  26
  27 gpointer
  28 mono_marshal_realloc_hglobal (gpointer ptr, size_t size)
  29 {
  30         return GlobalReAlloc (ptr, size, GMEM_MOVEABLE);
  31 }
  32
  33 void
  34 mono_marshal_free_hglobal (gpointer ptr)
  35 {
  36         GlobalFree (ptr);
  37 }
  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);
  61
  62 char*
  63 ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (const gunichar2 *s, int length)
  64 {
  65         g_assert_not_netcore ();
  66
  67         // FIXME pass mono_utf16_to_utf8 an allocator to avoid double alloc/copy.
  68
  69         ERROR_DECL (error);
  70         size_t len = 0;
  71         char* ret = NULL;
  72         char* tres = mono_utf16_to_utf8 (s, length, error);
  73         if (!tres || !is_ok (error))
  74                 goto exit;
  75
  76         /*
  77          * mono_utf16_to_utf8() returns a memory area at least as large as length,
  78          * even if it contains NULL characters. The copy we allocate here has to be equally
  79          * large.
  80          */
  81         len = MAX (strlen (tres) + 1, length);
  82         ret = (char*)mono_marshal_alloc_hglobal_error (len, error);
  83         if (ret)
  84                 memcpy (ret, tres, len);
  85 exit:
  86         g_free (tres);
  87         mono_error_set_pending_exception (error);
  88         return ret;
  89 }
  90
  91 gpointer
  92 mono_string_to_utf8str_impl (MonoStringHandle s, MonoError *error)
  93 {
  94         char *as, *tmp;
  95         glong len;
  96         GError *gerror = NULL;
  97
  98         if (MONO_HANDLE_IS_NULL (s))
  99                 return NULL;
 100
 101         if (!mono_string_handle_length (s)) {
 102                 as = (char*)CoTaskMemAlloc (1);
 103                 g_assert (as);
 104                 as [0] = '\0';
 105                 return as;
 106         }
 107
 108         // FIXME pass g_utf16_to_utf8 an allocator to avoid double alloc/copy.
 109
 110         uint32_t gchandle = 0;
 111         tmp = g_utf16_to_utf8 (mono_string_handle_pin_chars (s, &gchandle), mono_string_handle_length (s), NULL, &len, &gerror);
 112         mono_gchandle_free_internal (gchandle);
 113         if (gerror) {
 114                 mono_error_set_argument (error, "string", gerror->message);
 115                 g_error_free (gerror);
 116                 return NULL;
 117         } else {
 118                 as = (char*)CoTaskMemAlloc (len + 1);
 119                 g_assert (as);
 120                 memcpy (as, tmp, len + 1);
 121                 g_free (tmp);
 122                 return as;
 123         }
 124 }
 125
 126 #endif /* HOST_WIN32 */