mono/metadata/w32file-win32-uwp.c

   1 /**
   2  * \file
   3  * UWP w32file support for Mono.
   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 #include "mono/utils/mono-compiler.h"
  11
  12 #if G_HAVE_API_SUPPORT(HAVE_UWP_WINAPI_SUPPORT)
  13 #include <windows.h>
  14 #include "mono/metadata/w32file-win32-internals.h"
  15
  16 gboolean
  17 mono_w32file_move (gunichar2 *path, gunichar2 *dest, gint32 *error)
  18 {
  19         gboolean result = FALSE;
  20         MONO_ENTER_GC_SAFE;
  21
  22         result = MoveFileEx (path, dest, MOVEFILE_COPY_ALLOWED);
  23         if (result == FALSE) {
  24                 *error=GetLastError ();
  25         }
  26
  27         MONO_EXIT_GC_SAFE;
  28         return result;
  29 }
  30
  31 gboolean
  32 mono_w32file_replace (gunichar2 *destinationFileName, gunichar2 *sourceFileName,
  33                            gunichar2 *destinationBackupFileName, guint32 flags, gint32 *error)
  34 {
  35         gboolean result = FALSE;
  36         MONO_ENTER_GC_SAFE;
  37
  38         result = ReplaceFile (destinationFileName, sourceFileName, destinationBackupFileName, flags, NULL, NULL);
  39         if (result == FALSE) {
  40                 *error=GetLastError ();
  41         }
  42
  43         MONO_EXIT_GC_SAFE;
  44         return result;
  45 }
  46
  47 gboolean
  48 mono_w32file_copy (gunichar2 *path, gunichar2 *dest, gboolean overwrite, gint32 *error)
  49 {
  50         gboolean                                                result = FALSE;
  51         COPYFILE2_EXTENDED_PARAMETERS   copy_param = {0};
  52
  53         copy_param.dwSize = sizeof (COPYFILE2_EXTENDED_PARAMETERS);
  54         copy_param.dwCopyFlags = (!overwrite) ? COPY_FILE_FAIL_IF_EXISTS : 0;
  55
  56         MONO_ENTER_GC_SAFE;
  57
  58         result = SUCCEEDED (CopyFile2 (path, dest, &copy_param));
  59         if (result == FALSE) {
  60                 *error=GetLastError ();
  61         }
  62
  63         MONO_EXIT_GC_SAFE;
  64         return result;
  65 }
  66
  67 gint64
  68 mono_w32file_get_file_size (HANDLE handle, gint32 *error)
  69 {
  70         LARGE_INTEGER length;
  71
  72         MONO_ENTER_GC_SAFE;
  73
  74         if (!GetFileSizeEx (handle, &length)) {
  75                 *error=GetLastError ();
  76                 length.QuadPart = INVALID_FILE_SIZE;
  77         }
  78
  79         MONO_EXIT_GC_SAFE;
  80         return length.QuadPart;
  81 }
  82
  83 gboolean
  84 mono_w32file_lock (HANDLE handle, gint64 position, gint64 length, gint32 *error)
  85 {
  86         gboolean result = FALSE;
  87         MONO_ENTER_GC_SAFE;
  88
  89         result = LockFile (handle, position & 0xFFFFFFFF, position >> 32,
  90                            length & 0xFFFFFFFF, length >> 32);
  91
  92         if (result == FALSE) {
  93                 *error = GetLastError ();
  94         }
  95
  96         MONO_EXIT_GC_SAFE;
  97         return result;
  98 }
  99
 100 gboolean
 101 mono_w32file_unlock (HANDLE handle, gint64 position, gint64 length, gint32 *error)
 102 {
 103         gboolean result = FALSE;
 104         MONO_ENTER_GC_SAFE;
 105
 106         result = UnlockFile (handle, position & 0xFFFFFFFF, position >> 32,
 107                              length & 0xFFFFFFFF, length >> 32);
 108
 109         if (result == FALSE) {
 110                 *error = GetLastError ();
 111         }
 112
 113         MONO_EXIT_GC_SAFE;
 114         return result;
 115 }
 116
 117 HANDLE
 118 mono_w32file_get_console_output (void)
 119 {
 120         MonoError mono_error;
 121         error_init (&mono_error);
 122
 123         g_unsupported_api ("GetStdHandle (STD_OUTPUT_HANDLE)");
 124
 125         mono_error_set_not_supported (&mono_error, G_UNSUPPORTED_API, "GetStdHandle (STD_OUTPUT_HANDLE)");
 126         mono_error_set_pending_exception (&mono_error);
 127
 128         SetLastError (ERROR_NOT_SUPPORTED);
 129
 130         return INVALID_HANDLE_VALUE;
 131 }
 132
 133 HANDLE
 134 mono_w32file_get_console_input (void)
 135 {
 136         MonoError mono_error;
 137         error_init (&mono_error);
 138
 139         g_unsupported_api ("GetStdHandle (STD_INPUT_HANDLE)");
 140
 141         mono_error_set_not_supported (&mono_error, G_UNSUPPORTED_API, "GetStdHandle (STD_INPUT_HANDLE)");
 142         mono_error_set_pending_exception (&mono_error);
 143
 144         SetLastError (ERROR_NOT_SUPPORTED);
 145
 146         return INVALID_HANDLE_VALUE;
 147 }
 148
 149 HANDLE
 150 mono_w32file_get_console_error (void)
 151 {
 152         MonoError mono_error;
 153         error_init (&mono_error);
 154
 155         g_unsupported_api ("GetStdHandle (STD_ERROR_HANDLE)");
 156
 157         mono_error_set_not_supported (&mono_error, G_UNSUPPORTED_API, "GetStdHandle (STD_ERROR_HANDLE)");
 158         mono_error_set_pending_exception (&mono_error);
 159
 160         SetLastError (ERROR_NOT_SUPPORTED);
 161
 162         return INVALID_HANDLE_VALUE;
 163 }
 164
 165 #else /* G_HAVE_API_SUPPORT(HAVE_UWP_WINAPI_SUPPORT) */
 166
 167 MONO_EMPTY_SOURCE_FILE (file_io_windows_uwp);
 168 #endif /* G_HAVE_API_SUPPORT(HAVE_UWP_WINAPI_SUPPORT) */