mono/metadata/icall-windows.c

   1 /**
   2  * \file
   3  * Windows icall 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 <mono/metadata/icall-internals.h>
  15 #include <mono/utils/w32subset.h>
  16
  17 void
  18 mono_icall_make_platform_path (gchar *path)
  19 {
  20         for (size_t i = strlen (path); i > 0; i--)
  21                 if (path [i-1] == '\\')
  22                         path [i-1] = '/';
  23 }
  24
  25 const gchar *
  26 mono_icall_get_file_path_prefix (const gchar *path)
  27 {
  28         if (*path == '/' && *(path + 1) == '/') {
  29                 return "file:";
  30         } else {
  31                 return "file:///";
  32         }
  33 }
  34
  35 gpointer
  36 mono_icall_module_get_hinstance (MonoImage *image)
  37 {
  38         if (image && m_image_is_module_handle (image))
  39                 return image->raw_data;
  40
  41         return (gpointer) (-1);
  42 }
  43
  44 #if HAVE_API_SUPPORT_WIN32_GET_COMPUTER_NAME
  45 MonoStringHandle
  46 mono_icall_get_machine_name (MonoError *error)
  47 {
  48         gunichar2 buf [MAX_COMPUTERNAME_LENGTH + 1];
  49         DWORD len = G_N_ELEMENTS (buf);
  50
  51         if (GetComputerNameW (buf, &len))
  52                 return mono_string_new_utf16_handle (mono_domain_get (), buf, len, error);
  53         return MONO_HANDLE_NEW (MonoString, NULL);
  54 }
  55 #elif !HAVE_EXTERN_DEFINED_WIN32_GET_COMPUTER_NAME
  56 MonoStringHandle
  57 mono_icall_get_machine_name (MonoError *error)
  58 {
  59         g_unsupported_api ("GetComputerName");
  60         return mono_string_new_handle (mono_domain_get (), "mono", error);
  61 }
  62 #endif
  63
  64 int
  65 mono_icall_get_platform (void)
  66 {
  67         /* Win32NT */
  68         return 2;
  69 }
  70
  71 MonoStringHandle
  72 mono_icall_get_new_line (MonoError *error)
  73 {
  74         return mono_string_new_handle (mono_domain_get (), "\r\n", error);
  75 }
  76
  77 MonoBoolean
  78 mono_icall_is_64bit_os (void)
  79 {
  80 #if SIZEOF_VOID_P == 8
  81         return TRUE;
  82 #else
  83         gboolean isWow64Process = FALSE;
  84         if (IsWow64Process (GetCurrentProcess (), &isWow64Process)) {
  85                 return (MonoBoolean)isWow64Process;
  86         }
  87         return FALSE;
  88 #endif
  89 }
  90
  91 MonoArrayHandle
  92 mono_icall_get_environment_variable_names (MonoError *error)
  93 {
  94         MonoArrayHandle names;
  95         MonoDomain *domain;
  96         MonoStringHandle str;
  97         WCHAR* env_strings;
  98         WCHAR* env_string;
  99         WCHAR* equal_str;
 100         int n = 0;
 101
 102         env_strings = GetEnvironmentStrings();
 103
 104         if (env_strings) {
 105                 env_string = env_strings;
 106                 while (*env_string != '\0') {
 107                 /* weird case that MS seems to skip */
 108                         if (*env_string != '=')
 109                                 n++;
 110                         while (*env_string != '\0')
 111                                 env_string++;
 112                         env_string++;
 113                 }
 114         }
 115
 116         domain = mono_domain_get ();
 117         names = mono_array_new_handle (domain, mono_defaults.string_class, n, error);
 118         return_val_if_nok (error, NULL_HANDLE_ARRAY);
 119
 120         if (env_strings) {
 121                 n = 0;
 122                 str = MONO_HANDLE_NEW (MonoString, NULL);
 123                 env_string = env_strings;
 124                 while (*env_string != '\0') {
 125                         /* weird case that MS seems to skip */
 126                         if (*env_string != '=') {
 127                                 equal_str = wcschr(env_string, '=');
 128                                 g_assert(equal_str);
 129                                 MonoString *s = mono_string_new_utf16_checked (domain, env_string, (gint32)(equal_str - env_string), error);
 130                                 goto_if_nok (error, cleanup);
 131                                 MONO_HANDLE_ASSIGN_RAW (str, s);
 132
 133                                 mono_array_handle_setref (names, n, str);
 134                                 n++;
 135                         }
 136                         while (*env_string != '\0')
 137                                 env_string++;
 138                         env_string++;
 139                 }
 140
 141         }
 142
 143 cleanup:
 144         if (env_strings)
 145                 FreeEnvironmentStrings (env_strings);
 146         if (!is_ok (error))
 147                 return NULL_HANDLE_ARRAY;
 148         return names;
 149 }
 150
 151 #if HAVE_API_SUPPORT_WIN32_SH_GET_FOLDER_PATH
 152 #include <shlobj.h>
 153 MonoStringHandle
 154 mono_icall_get_windows_folder_path (int folder, MonoError *error)
 155 {
 156         error_init (error);
 157         #ifndef CSIDL_FLAG_CREATE
 158                 #define CSIDL_FLAG_CREATE       0x8000
 159         #endif
 160
 161         WCHAR path [MAX_PATH];
 162         /* Create directory if no existing */
 163         if (SUCCEEDED (SHGetFolderPathW (NULL, folder | CSIDL_FLAG_CREATE, NULL, 0, path))) {
 164                 int len = 0;
 165                 while (path [len])
 166                         ++ len;
 167                 return mono_string_new_utf16_handle (mono_domain_get (), path, len, error);
 168         }
 169         return mono_string_new_handle (mono_domain_get (), "", error);
 170 }
 171 #elif !HAVE_EXTERN_DEFINED_WIN32_SH_GET_FOLDER_PATH
 172 MonoStringHandle
 173 mono_icall_get_windows_folder_path (int folder, MonoError *error)
 174 {
 175         error_init (error);
 176         g_unsupported_api ("SHGetFolderPath");
 177         return mono_string_new_handle (mono_domain_get (), "", error);
 178 }
 179 #endif
 180
 181 #if HAVE_API_SUPPORT_WIN32_SEND_MESSAGE_TIMEOUT
 182 ICALL_EXPORT void
 183 ves_icall_System_Environment_BroadcastSettingChange (MonoError *error)
 184 {
 185         SendMessageTimeoutW (HWND_BROADCAST, WM_SETTINGCHANGE, (WPARAM)NULL, (LPARAM)L"Environment", SMTO_ABORTIFHUNG, 2000, 0);
 186 }
 187 #elif !HAVE_EXTERN_DEFINED_WIN32_SEND_MESSAGE_TIMEOUT
 188 ICALL_EXPORT void
 189 ves_icall_System_Environment_BroadcastSettingChange (MonoError *error)
 190 {
 191         g_unsupported_api ("SendMessageTimeout");
 192         mono_error_set_not_supported (error, G_UNSUPPORTED_API, "SendMessageTimeout");
 193         SetLastError (ERROR_NOT_SUPPORTED);
 194 }
 195 #endif
 196
 197 #if HAVE_API_SUPPORT_WIN32_WAIT_FOR_INPUT_IDLE
 198 gint32
 199 mono_icall_wait_for_input_idle (gpointer handle, gint32 milliseconds)
 200 {
 201         return WaitForInputIdle (handle, milliseconds);
 202 }
 203 #elif !HAVE_EXTERN_DEFINED_WIN32_WAIT_FOR_INPUT_IDLE
 204 gint32
 205 mono_icall_wait_for_input_idle (gpointer handle, gint32 milliseconds)
 206 {
 207         ERROR_DECL (error);
 208         g_unsupported_api ("WaitForInputIdle");
 209         mono_error_set_not_supported (error, G_UNSUPPORTED_API, "WaitForInputIdle");
 210         mono_error_set_pending_exception (error);
 211         return WAIT_TIMEOUT;
 212 }
 213 #endif
 214
 215 void
 216 mono_icall_write_windows_debug_string (const gunichar2 *message)
 217 {
 218         OutputDebugString (message);
 219 }
 220
 221 #endif /* HOST_WIN32 */