2 * file-io.c: File IO internal calls
5 * Dick Porter (dick@ximian.com)
6 * Gonzalo Paniagua Javier (gonzalo@ximian.com)
8 * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
9 * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
20 #ifdef HAVE_SYS_STAT_H
23 #ifdef HAVE_SYS_TYPES_H
24 #include <sys/types.h>
27 #include <mono/metadata/object.h>
28 #include <mono/io-layer/io-layer.h>
29 #include <mono/metadata/file-io.h>
30 #include <mono/metadata/exception.h>
31 #include <mono/metadata/appdomain.h>
32 #include <mono/metadata/marshal.h>
33 #include <mono/utils/strenc.h>
37 /* conversion functions */
39 static guint32 convert_mode(MonoFileMode mono_mode)
44 case FileMode_CreateNew:
53 case FileMode_OpenOrCreate:
56 case FileMode_Truncate:
57 mode=TRUNCATE_EXISTING;
63 g_warning("System.IO.FileMode has unknown value 0x%x",
72 static guint32 convert_access(MonoFileAccess mono_access)
80 case FileAccess_Write:
83 case FileAccess_ReadWrite:
84 access=GENERIC_READ|GENERIC_WRITE;
87 g_warning("System.IO.FileAccess has unknown value 0x%x",
96 static guint32 convert_share(MonoFileShare mono_share)
100 if (mono_share & FileShare_Read) {
101 share |= FILE_SHARE_READ;
103 if (mono_share & FileShare_Write) {
104 share |= FILE_SHARE_WRITE;
106 if (mono_share & FileShare_Delete) {
107 share |= FILE_SHARE_DELETE;
110 if (mono_share & ~(FileShare_Read|FileShare_Write|FileShare_Delete)) {
111 g_warning("System.IO.FileShare has unknown value 0x%x",
121 static guint32 convert_stdhandle(guint32 fd)
127 stdhandle=STD_INPUT_HANDLE;
130 stdhandle=STD_OUTPUT_HANDLE;
133 stdhandle=STD_ERROR_HANDLE;
136 g_warning("unknown standard file descriptor %d", fd);
137 stdhandle=STD_INPUT_HANDLE;
144 static guint32 convert_seekorigin(MonoSeekOrigin origin)
149 case SeekOrigin_Begin:
150 w32origin=FILE_BEGIN;
152 case SeekOrigin_Current:
153 w32origin=FILE_CURRENT;
159 g_warning("System.IO.SeekOrigin has unknown value 0x%x",
162 w32origin=FILE_CURRENT;
168 static gint64 convert_filetime (const FILETIME *filetime)
170 guint64 ticks = filetime->dwHighDateTime;
172 ticks += filetime->dwLowDateTime;
173 return (gint64)ticks;
176 static void convert_win32_file_attribute_data (const WIN32_FILE_ATTRIBUTE_DATA *data, const gunichar2 *name, MonoIOStat *stat)
180 stat->attributes = data->dwFileAttributes;
181 stat->creation_time = convert_filetime (&data->ftCreationTime);
182 stat->last_access_time = convert_filetime (&data->ftLastAccessTime);
183 stat->last_write_time = convert_filetime (&data->ftLastWriteTime);
184 stat->length = ((gint64)data->nFileSizeHigh << 32) | data->nFileSizeLow;
190 MONO_STRUCT_SETREF (stat, name, mono_string_new_utf16 (mono_domain_get (), name, len));
193 /* Managed file attributes have nearly but not quite the same values
194 * as the w32 equivalents.
196 static guint32 convert_attrs(MonoFileAttributes attrs)
198 if(attrs & FileAttributes_Encrypted) {
199 attrs |= FILE_ATTRIBUTE_ENCRYPTED;
206 * On Win32, GetFileAttributes|Ex () seems to try opening the file,
207 * which might lead to sharing violation errors, whereas FindFirstFile
208 * always succeeds. These 2 wrappers resort to FindFirstFile if
209 * GetFileAttributes|Ex () has failed.
212 get_file_attributes (const gunichar2 *path)
215 WIN32_FIND_DATA find_data;
219 res = GetFileAttributes (path);
223 error = GetLastError ();
225 if (error != ERROR_SHARING_VIOLATION)
228 find_handle = FindFirstFile (path, &find_data);
230 if (find_handle == INVALID_HANDLE_VALUE)
233 FindClose (find_handle);
235 return find_data.dwFileAttributes;
239 get_file_attributes_ex (const gunichar2 *path, WIN32_FILE_ATTRIBUTE_DATA *data)
242 WIN32_FIND_DATA find_data;
246 res = GetFileAttributesEx (path, GetFileExInfoStandard, data);
250 error = GetLastError ();
252 if (error != ERROR_SHARING_VIOLATION)
255 find_handle = FindFirstFile (path, &find_data);
257 if (find_handle == INVALID_HANDLE_VALUE)
260 FindClose (find_handle);
262 data->dwFileAttributes = find_data.dwFileAttributes;
263 data->ftCreationTime = find_data.ftCreationTime;
264 data->ftLastAccessTime = find_data.ftLastAccessTime;
265 data->ftLastWriteTime = find_data.ftLastWriteTime;
266 data->nFileSizeHigh = find_data.nFileSizeHigh;
267 data->nFileSizeLow = find_data.nFileSizeLow;
272 /* System.IO.MonoIO internal calls */
275 ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error)
281 *error=ERROR_SUCCESS;
283 ret=CreateDirectory (mono_string_chars (path), NULL);
285 *error=GetLastError ();
292 ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error)
298 *error=ERROR_SUCCESS;
300 ret=RemoveDirectory (mono_string_chars (path));
302 *error=GetLastError ();
309 get_search_dir (MonoString *pattern)
314 p = mono_string_to_utf8 (pattern);
315 result = g_path_get_dirname (p);
321 ves_icall_System_IO_MonoIO_GetFileSystemEntries (MonoString *path,
322 MonoString *path_with_pattern,
323 gint attrs, gint mask,
329 WIN32_FIND_DATA data;
332 gchar *utf8_path, *utf8_result, *full_name;
337 *error = ERROR_SUCCESS;
339 domain = mono_domain_get ();
340 mask = convert_attrs (mask);
341 attributes = get_file_attributes (mono_string_chars (path));
342 if (attributes != -1) {
343 if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
344 *error = ERROR_INVALID_NAME;
348 *error = GetLastError ();
352 find_handle = FindFirstFile (mono_string_chars (path_with_pattern), &data);
353 if (find_handle == INVALID_HANDLE_VALUE) {
354 gint32 find_error = GetLastError ();
356 if (find_error == ERROR_FILE_NOT_FOUND || find_error == ERROR_NO_MORE_FILES) {
357 /* No files, so just return an empty array */
358 result = mono_array_new (domain,
359 mono_defaults.string_class,
369 utf8_path = get_search_dir (path_with_pattern);
370 names = g_ptr_array_new ();
373 if ((data.cFileName[0] == '.' && data.cFileName[1] == 0) ||
374 (data.cFileName[0] == '.' && data.cFileName[1] == '.' && data.cFileName[2] == 0)) {
378 if ((data.dwFileAttributes & mask) == attrs) {
379 utf8_result = g_utf16_to_utf8 (data.cFileName, -1, NULL, NULL, NULL);
380 if (utf8_result == NULL) {
384 full_name = g_build_filename (utf8_path, utf8_result, NULL);
385 g_ptr_array_add (names, full_name);
387 g_free (utf8_result);
389 } while(FindNextFile (find_handle, &data));
391 if (FindClose (find_handle) == FALSE) {
392 *error = GetLastError ();
395 result = mono_array_new (domain, mono_defaults.string_class, names->len);
396 for (i = 0; i < names->len; i++) {
397 mono_array_setref (result, i, mono_string_new (domain, g_ptr_array_index (names, i)));
401 for (i = 0; i < names->len; i++) {
402 g_free (g_ptr_array_index (names, i));
404 g_ptr_array_free (names, TRUE);
417 incremental_find_check_match (IncrementalFind *handle, WIN32_FIND_DATA *data, MonoString **result)
422 if ((data->cFileName[0] == '.' && data->cFileName[1] == 0) || (data->cFileName[0] == '.' && data->cFileName[1] == '.' && data->cFileName[2] == 0))
425 utf8_result = g_utf16_to_utf8 (data->cFileName, -1, NULL, NULL, NULL);
426 if (utf8_result == NULL)
429 full_name = g_build_filename (handle->utf8_path, utf8_result, NULL);
430 g_free (utf8_result);
431 *result = mono_string_new (mono_domain_get (), full_name);
438 ves_icall_System_IO_MonoIO_FindFirst (MonoString *path,
439 MonoString *path_with_pattern,
440 gint32 *result_attr, gint32 *error,
443 WIN32_FIND_DATA data;
445 IncrementalFind *ifh;
448 *error = ERROR_SUCCESS;
450 find_handle = FindFirstFile (mono_string_chars (path_with_pattern), &data);
452 if (find_handle == INVALID_HANDLE_VALUE) {
453 gint32 find_error = GetLastError ();
456 if (find_error == ERROR_FILE_NOT_FOUND)
463 ifh = g_new (IncrementalFind, 1);
464 ifh->find_handle = find_handle;
465 ifh->utf8_path = mono_string_to_utf8 (path);
466 ifh->domain = mono_domain_get ();
469 while (incremental_find_check_match (ifh, &data, &result) == 0){
470 if (FindNextFile (find_handle, &data) == FALSE){
471 int e = GetLastError ();
472 if (e != ERROR_NO_MORE_FILES)
477 *result_attr = data.dwFileAttributes;
483 ves_icall_System_IO_MonoIO_FindNext (gpointer handle, gint32 *result_attr, gint32 *error)
485 IncrementalFind *ifh = handle;
486 WIN32_FIND_DATA data;
489 error = ERROR_SUCCESS;
491 if (FindNextFile (ifh->find_handle, &data) == FALSE){
492 int e = GetLastError ();
493 if (e != ERROR_NO_MORE_FILES)
497 } while (incremental_find_check_match (ifh, &data, &result) == 0);
499 *result_attr = data.dwFileAttributes;
504 ves_icall_System_IO_MonoIO_FindClose (gpointer handle)
506 IncrementalFind *ifh = handle;
509 if (FindClose (ifh->find_handle) == FALSE){
510 error = GetLastError ();
512 error = ERROR_SUCCESS;
513 g_free (ifh->utf8_path);
520 ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *error)
528 len = MAX_PATH + 1; /*FIXME this is too smal under most unix systems.*/
529 buf = g_new (gunichar2, len);
531 *error=ERROR_SUCCESS;
534 res_len = GetCurrentDirectory (len, buf);
535 if (res_len > len) { /*buf is too small.*/
536 int old_res_len = res_len;
538 buf = g_new (gunichar2, res_len);
539 res_len = GetCurrentDirectory (res_len, buf) == old_res_len;
547 result = mono_string_new_utf16 (mono_domain_get (), buf, len);
549 *error=GetLastError ();
557 ves_icall_System_IO_MonoIO_SetCurrentDirectory (MonoString *path,
564 *error=ERROR_SUCCESS;
566 ret=SetCurrentDirectory (mono_string_chars (path));
568 *error=GetLastError ();
575 ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
582 *error=ERROR_SUCCESS;
584 ret=MoveFile (mono_string_chars (path), mono_string_chars (dest));
586 *error=GetLastError ();
593 ves_icall_System_IO_MonoIO_ReplaceFile (MonoString *sourceFileName, MonoString *destinationFileName,
594 MonoString *destinationBackupFileName, MonoBoolean ignoreMetadataErrors,
598 gunichar2 *utf16_sourceFileName = NULL, *utf16_destinationFileName = NULL, *utf16_destinationBackupFileName = NULL;
599 guint32 replaceFlags = REPLACEFILE_WRITE_THROUGH;
604 utf16_sourceFileName = mono_string_chars (sourceFileName);
605 if (destinationFileName)
606 utf16_destinationFileName = mono_string_chars (destinationFileName);
607 if (destinationBackupFileName)
608 utf16_destinationBackupFileName = mono_string_chars (destinationBackupFileName);
610 *error = ERROR_SUCCESS;
611 if (ignoreMetadataErrors)
612 replaceFlags |= REPLACEFILE_IGNORE_MERGE_ERRORS;
614 ret = ReplaceFile (utf16_destinationFileName, utf16_sourceFileName, utf16_destinationBackupFileName,
615 replaceFlags, NULL, NULL);
617 *error = GetLastError ();
623 ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
624 MonoBoolean overwrite, gint32 *error)
630 *error=ERROR_SUCCESS;
632 ret=CopyFile (mono_string_chars (path), mono_string_chars (dest), !overwrite);
634 *error=GetLastError ();
641 ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
647 *error=ERROR_SUCCESS;
649 ret=DeleteFile (mono_string_chars (path));
651 *error=GetLastError ();
658 ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
664 *error=ERROR_SUCCESS;
666 ret=get_file_attributes (mono_string_chars (path));
669 * The definition of INVALID_FILE_ATTRIBUTES in the cygwin win32
670 * headers is wrong, hence this temporary workaround.
672 * http://cygwin.com/ml/cygwin/2003-09/msg01771.html
675 /* if(ret==INVALID_FILE_ATTRIBUTES) { */
676 *error=GetLastError ();
683 ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
690 *error=ERROR_SUCCESS;
692 ret=SetFileAttributes (mono_string_chars (path),
693 convert_attrs (attrs));
695 *error=GetLastError ();
702 ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
708 *error=ERROR_SUCCESS;
710 ret=GetFileType (handle);
711 if(ret==FILE_TYPE_UNKNOWN) {
712 /* Not necessarily an error, but the caller will have
713 * to decide based on the error value.
715 *error=GetLastError ();
722 ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
726 WIN32_FILE_ATTRIBUTE_DATA data;
730 *error=ERROR_SUCCESS;
732 result = get_file_attributes_ex (mono_string_chars (path), &data);
735 convert_win32_file_attribute_data (&data,
736 mono_string_chars (path),
739 *error=GetLastError ();
740 memset (stat, 0, sizeof (MonoIOStat));
747 ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode,
748 gint32 access_mode, gint32 share, gint32 options,
752 int attributes, attrs;
753 gunichar2 *chars = mono_string_chars (filename);
757 *error=ERROR_SUCCESS;
760 if (options & FileOptions_Encrypted)
761 attributes = FILE_ATTRIBUTE_ENCRYPTED;
763 attributes = FILE_ATTRIBUTE_NORMAL;
764 if (options & FileOptions_DeleteOnClose)
765 attributes |= FILE_FLAG_DELETE_ON_CLOSE;
766 if (options & FileOptions_SequentialScan)
767 attributes |= FILE_FLAG_SEQUENTIAL_SCAN;
768 if (options & FileOptions_RandomAccess)
769 attributes |= FILE_FLAG_RANDOM_ACCESS;
771 if (options & FileOptions_Temporary)
772 attributes |= FILE_ATTRIBUTE_TEMPORARY;
774 /* Not sure if we should set FILE_FLAG_OVERLAPPED, how does this mix with the "Async" bool here? */
775 if (options & FileOptions_Asynchronous)
776 attributes |= FILE_FLAG_OVERLAPPED;
778 if (options & FileOptions_WriteThrough)
779 attributes |= FILE_FLAG_WRITE_THROUGH;
781 attributes = FILE_ATTRIBUTE_NORMAL;
783 /* If we're opening a directory we need to set the extra flag
785 attrs = get_file_attributes (chars);
786 if (attrs != INVALID_FILE_ATTRIBUTES) {
787 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
788 attributes |= FILE_FLAG_BACKUP_SEMANTICS;
792 ret=CreateFile (chars, convert_access (access_mode),
793 convert_share (share), NULL, convert_mode (mode),
795 if(ret==INVALID_HANDLE_VALUE) {
796 *error=GetLastError ();
803 ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
809 *error=ERROR_SUCCESS;
811 ret=CloseHandle (handle);
813 *error=GetLastError ();
820 ves_icall_System_IO_MonoIO_Read (HANDLE handle, MonoArray *dest,
821 gint32 dest_offset, gint32 count,
830 *error=ERROR_SUCCESS;
832 MONO_CHECK_ARG_NULL (dest);
834 if (dest_offset + count > mono_array_length (dest))
837 buffer = mono_array_addr (dest, guchar, dest_offset);
838 result = ReadFile (handle, buffer, count, &n, NULL);
841 *error=GetLastError ();
849 ves_icall_System_IO_MonoIO_Write (HANDLE handle, MonoArray *src,
850 gint32 src_offset, gint32 count,
859 *error=ERROR_SUCCESS;
861 MONO_CHECK_ARG_NULL (src);
863 if (src_offset + count > mono_array_length (src))
866 buffer = mono_array_addr (src, guchar, src_offset);
867 result = WriteFile (handle, buffer, count, &n, NULL);
870 *error=GetLastError ();
878 ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
885 *error=ERROR_SUCCESS;
887 offset_hi = offset >> 32;
888 offset = SetFilePointer (handle, (gint32) (offset & 0xFFFFFFFF), &offset_hi,
889 convert_seekorigin (origin));
891 if(offset==INVALID_SET_FILE_POINTER) {
892 *error=GetLastError ();
895 return offset | ((gint64)offset_hi << 32);
899 ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
905 *error=ERROR_SUCCESS;
907 ret=FlushFileBuffers (handle);
909 *error=GetLastError ();
916 ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
923 *error=ERROR_SUCCESS;
925 length = GetFileSize (handle, &length_hi);
926 if(length==INVALID_FILE_SIZE) {
927 *error=GetLastError ();
930 return length | ((gint64)length_hi << 32);
934 ves_icall_System_IO_MonoIO_SetLength (HANDLE handle, gint64 length,
937 gint64 offset, offset_set;
944 *error=ERROR_SUCCESS;
946 /* save file pointer */
949 offset = SetFilePointer (handle, 0, &offset_hi, FILE_CURRENT);
950 if(offset==INVALID_SET_FILE_POINTER) {
951 *error=GetLastError ();
955 /* extend or truncate */
957 length_hi = length >> 32;
958 offset_set=SetFilePointer (handle, length & 0xFFFFFFFF, &length_hi,
960 if(offset_set==INVALID_SET_FILE_POINTER) {
961 *error=GetLastError ();
965 result = SetEndOfFile (handle);
967 *error=GetLastError ();
971 /* restore file pointer */
973 offset_set=SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
975 if(offset_set==INVALID_SET_FILE_POINTER) {
976 *error=GetLastError ();
984 ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time,
985 gint64 last_access_time,
986 gint64 last_write_time, gint32 *error)
989 const FILETIME *creation_filetime;
990 const FILETIME *last_access_filetime;
991 const FILETIME *last_write_filetime;
995 *error=ERROR_SUCCESS;
997 if (creation_time < 0)
998 creation_filetime = NULL;
1000 creation_filetime = (FILETIME *)&creation_time;
1002 if (last_access_time < 0)
1003 last_access_filetime = NULL;
1005 last_access_filetime = (FILETIME *)&last_access_time;
1007 if (last_write_time < 0)
1008 last_write_filetime = NULL;
1010 last_write_filetime = (FILETIME *)&last_write_time;
1012 ret=SetFileTime (handle, creation_filetime, last_access_filetime, last_write_filetime);
1014 *error=GetLastError ();
1021 ves_icall_System_IO_MonoIO_get_ConsoleOutput ()
1023 MONO_ARCH_SAVE_REGS;
1025 return GetStdHandle (STD_OUTPUT_HANDLE);
1029 ves_icall_System_IO_MonoIO_get_ConsoleInput ()
1031 MONO_ARCH_SAVE_REGS;
1033 return GetStdHandle (STD_INPUT_HANDLE);
1037 ves_icall_System_IO_MonoIO_get_ConsoleError ()
1039 MONO_ARCH_SAVE_REGS;
1041 return GetStdHandle (STD_ERROR_HANDLE);
1045 ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle,
1046 HANDLE *write_handle)
1048 SECURITY_ATTRIBUTES attr;
1051 MONO_ARCH_SAVE_REGS;
1053 attr.nLength=sizeof(SECURITY_ATTRIBUTES);
1054 attr.bInheritHandle=TRUE;
1055 attr.lpSecurityDescriptor=NULL;
1057 ret=CreatePipe (read_handle, write_handle, &attr, 0);
1059 /* FIXME: throw an exception? */
1066 MonoBoolean ves_icall_System_IO_MonoIO_DuplicateHandle (HANDLE source_process_handle,
1067 HANDLE source_handle, HANDLE target_process_handle, HANDLE *target_handle,
1068 gint32 access, gint32 inherit, gint32 options)
1070 /* This is only used on Windows */
1073 MONO_ARCH_SAVE_REGS;
1075 ret=DuplicateHandle (source_process_handle, source_handle, target_process_handle, target_handle, access, inherit, options);
1077 /* FIXME: throw an exception? */
1085 ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar ()
1087 #if defined (TARGET_WIN32)
1088 return (gunichar2) ':'; /* colon */
1090 return (gunichar2) '/'; /* forward slash */
1095 ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar ()
1097 #if defined (TARGET_WIN32)
1098 return (gunichar2) '\\'; /* backslash */
1100 return (gunichar2) '/'; /* forward slash */
1105 ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar ()
1107 #if defined (TARGET_WIN32)
1108 return (gunichar2) '/'; /* forward slash */
1110 return (gunichar2) '/'; /* slash, same as DirectorySeparatorChar */
1115 ves_icall_System_IO_MonoIO_get_PathSeparator ()
1117 #if defined (TARGET_WIN32)
1118 return (gunichar2) ';'; /* semicolon */
1120 return (gunichar2) ':'; /* colon */
1124 static const gunichar2
1125 invalid_path_chars [] = {
1126 #if defined (TARGET_WIN32)
1127 0x0022, /* double quote, which seems allowed in MS.NET but should be rejected */
1128 0x003c, /* less than */
1129 0x003e, /* greater than */
1146 ves_icall_System_IO_MonoIO_get_InvalidPathChars ()
1152 MONO_ARCH_SAVE_REGS;
1154 domain = mono_domain_get ();
1155 n = sizeof (invalid_path_chars) / sizeof (gunichar2);
1156 chars = mono_array_new (domain, mono_defaults.char_class, n);
1158 for (i = 0; i < n; ++ i)
1159 mono_array_set (chars, gunichar2, i, invalid_path_chars [i]);
1165 ves_icall_System_IO_MonoIO_GetTempPath (MonoString **mono_name)
1170 name=g_new0 (gunichar2, 256);
1172 ret=GetTempPath (256, name);
1174 /* Buffer was too short. Try again... */
1176 name=g_new0 (gunichar2, ret+2); /* include the terminator */
1177 ret=GetTempPath (ret, name);
1182 g_message ("%s: Temp path is [%s] (len %d)", __func__, name, ret);
1185 mono_gc_wbarrier_generic_store ((gpointer) mono_name,
1186 (MonoObject*) mono_string_new_utf16 (mono_domain_get (), name, ret));
1194 void ves_icall_System_IO_MonoIO_Lock (HANDLE handle, gint64 position,
1195 gint64 length, gint32 *error)
1199 *error=ERROR_SUCCESS;
1201 ret=LockFile (handle, position & 0xFFFFFFFF, position >> 32,
1202 length & 0xFFFFFFFF, length >> 32);
1204 *error = GetLastError ();
1208 void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position,
1209 gint64 length, gint32 *error)
1213 *error=ERROR_SUCCESS;
1215 ret=UnlockFile (handle, position & 0xFFFFFFFF, position >> 32,
1216 length & 0xFFFFFFFF, length >> 32);
1218 *error = GetLastError ();