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)
10 * Copyright 2012 Xamarin Inc (http://www.xamarin.com)
21 #ifdef HAVE_SYS_STAT_H
24 #ifdef HAVE_SYS_TYPES_H
25 #include <sys/types.h>
28 #include <mono/metadata/object.h>
29 #include <mono/io-layer/io-layer.h>
30 #include <mono/metadata/file-io.h>
31 #include <mono/metadata/exception.h>
32 #include <mono/metadata/appdomain.h>
33 #include <mono/metadata/marshal.h>
34 #include <mono/utils/strenc.h>
35 #include <utils/mono-io-portability.h>
39 /* conversion functions */
41 static guint32 convert_mode(MonoFileMode mono_mode)
46 case FileMode_CreateNew:
55 case FileMode_OpenOrCreate:
58 case FileMode_Truncate:
59 mode=TRUNCATE_EXISTING;
65 g_warning("System.IO.FileMode has unknown value 0x%x",
74 static guint32 convert_access(MonoFileAccess mono_access)
82 case FileAccess_Write:
85 case FileAccess_ReadWrite:
86 access=GENERIC_READ|GENERIC_WRITE;
89 g_warning("System.IO.FileAccess has unknown value 0x%x",
98 static guint32 convert_share(MonoFileShare mono_share)
102 if (mono_share & FileShare_Read) {
103 share |= FILE_SHARE_READ;
105 if (mono_share & FileShare_Write) {
106 share |= FILE_SHARE_WRITE;
108 if (mono_share & FileShare_Delete) {
109 share |= FILE_SHARE_DELETE;
112 if (mono_share & ~(FileShare_Read|FileShare_Write|FileShare_Delete)) {
113 g_warning("System.IO.FileShare has unknown value 0x%x",
123 static guint32 convert_stdhandle(guint32 fd)
129 stdhandle=STD_INPUT_HANDLE;
132 stdhandle=STD_OUTPUT_HANDLE;
135 stdhandle=STD_ERROR_HANDLE;
138 g_warning("unknown standard file descriptor %d", fd);
139 stdhandle=STD_INPUT_HANDLE;
146 static guint32 convert_seekorigin(MonoSeekOrigin origin)
151 case SeekOrigin_Begin:
152 w32origin=FILE_BEGIN;
154 case SeekOrigin_Current:
155 w32origin=FILE_CURRENT;
161 g_warning("System.IO.SeekOrigin has unknown value 0x%x",
164 w32origin=FILE_CURRENT;
170 static gint64 convert_filetime (const FILETIME *filetime)
172 guint64 ticks = filetime->dwHighDateTime;
174 ticks += filetime->dwLowDateTime;
175 return (gint64)ticks;
178 static void convert_win32_file_attribute_data (const WIN32_FILE_ATTRIBUTE_DATA *data, 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;
187 /* Managed file attributes have nearly but not quite the same values
188 * as the w32 equivalents.
190 static guint32 convert_attrs(MonoFileAttributes attrs)
192 if(attrs & FileAttributes_Encrypted) {
193 attrs = (MonoFileAttributes)(attrs | FILE_ATTRIBUTE_ENCRYPTED);
200 * On Win32, GetFileAttributes|Ex () seems to try opening the file,
201 * which might lead to sharing violation errors, whereas FindFirstFile
202 * always succeeds. These 2 wrappers resort to FindFirstFile if
203 * GetFileAttributes|Ex () has failed.
206 get_file_attributes (const gunichar2 *path)
209 WIN32_FIND_DATA find_data;
213 res = GetFileAttributes (path);
217 error = GetLastError ();
219 if (error != ERROR_SHARING_VIOLATION)
222 find_handle = FindFirstFile (path, &find_data);
224 if (find_handle == INVALID_HANDLE_VALUE)
227 FindClose (find_handle);
229 return find_data.dwFileAttributes;
233 get_file_attributes_ex (const gunichar2 *path, WIN32_FILE_ATTRIBUTE_DATA *data)
236 WIN32_FIND_DATA find_data;
240 res = GetFileAttributesEx (path, GetFileExInfoStandard, data);
244 error = GetLastError ();
246 if (error != ERROR_SHARING_VIOLATION)
249 find_handle = FindFirstFile (path, &find_data);
251 if (find_handle == INVALID_HANDLE_VALUE)
254 FindClose (find_handle);
256 data->dwFileAttributes = find_data.dwFileAttributes;
257 data->ftCreationTime = find_data.ftCreationTime;
258 data->ftLastAccessTime = find_data.ftLastAccessTime;
259 data->ftLastWriteTime = find_data.ftLastWriteTime;
260 data->nFileSizeHigh = find_data.nFileSizeHigh;
261 data->nFileSizeLow = find_data.nFileSizeLow;
266 /* System.IO.MonoIO internal calls */
269 ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error)
272 MONO_PREPARE_BLOCKING;
274 *error=ERROR_SUCCESS;
276 ret=CreateDirectory (mono_string_chars (path), NULL);
278 *error=GetLastError ();
281 MONO_FINISH_BLOCKING;
286 ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error)
289 MONO_PREPARE_BLOCKING;
291 *error=ERROR_SUCCESS;
293 ret=RemoveDirectory (mono_string_chars (path));
295 *error=GetLastError ();
298 MONO_FINISH_BLOCKING;
303 get_search_dir (const gunichar2 *pattern)
308 p = g_utf16_to_utf8 (pattern, -1, NULL, NULL, NULL);
309 result = g_path_get_dirname (p);
315 get_filesystem_entries (const gunichar2 *path,
316 const gunichar2 *path_with_pattern,
317 gint attrs, gint mask,
321 WIN32_FIND_DATA data;
323 GPtrArray *names = NULL;
324 gchar *utf8_path = NULL, *utf8_result, *full_name;
327 mask = convert_attrs ((MonoFileAttributes)mask);
328 attributes = get_file_attributes (path);
329 if (attributes != -1) {
330 if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
331 *error = ERROR_INVALID_NAME;
335 *error = GetLastError ();
339 find_handle = FindFirstFile (path_with_pattern, &data);
340 if (find_handle == INVALID_HANDLE_VALUE) {
341 gint32 find_error = GetLastError ();
343 if (find_error == ERROR_FILE_NOT_FOUND || find_error == ERROR_NO_MORE_FILES) {
344 /* No files, so just return an empty array */
352 utf8_path = get_search_dir (path_with_pattern);
353 names = g_ptr_array_new ();
356 if ((data.cFileName[0] == '.' && data.cFileName[1] == 0) ||
357 (data.cFileName[0] == '.' && data.cFileName[1] == '.' && data.cFileName[2] == 0)) {
361 if ((data.dwFileAttributes & mask) == attrs) {
362 utf8_result = g_utf16_to_utf8 (data.cFileName, -1, NULL, NULL, NULL);
363 if (utf8_result == NULL) {
367 full_name = g_build_filename (utf8_path, utf8_result, NULL);
368 g_ptr_array_add (names, full_name);
370 g_free (utf8_result);
372 } while(FindNextFile (find_handle, &data));
374 if (FindClose (find_handle) == FALSE) {
375 *error = GetLastError ();
383 for (i = 0; i < names->len; i++)
384 g_free (g_ptr_array_index (names, i));
385 g_ptr_array_free (names, TRUE);
393 ves_icall_System_IO_MonoIO_GetFileSystemEntries (MonoString *path,
394 MonoString *path_with_pattern,
395 gint attrs, gint mask,
398 MonoDomain *domain = mono_domain_get ();
403 *error = ERROR_SUCCESS;
405 MONO_PREPARE_BLOCKING;
406 names = get_filesystem_entries (mono_string_chars (path), mono_string_chars (path_with_pattern), attrs, mask, error);
407 MONO_FINISH_BLOCKING;
410 // If there's no array and no error, then return an empty array.
411 if (*error == ERROR_SUCCESS)
412 return mono_array_new (domain, mono_defaults.string_class, 0);
416 result = mono_array_new (domain, mono_defaults.string_class, names->len);
417 for (i = 0; i < names->len; i++) {
418 mono_array_setref (result, i, mono_string_new (domain, (const char *)g_ptr_array_index (names, i)));
419 g_free (g_ptr_array_index (names, i));
421 g_ptr_array_free (names, TRUE);
432 incremental_find_check_match (IncrementalFind *handle, WIN32_FIND_DATA *data, MonoString **result)
437 if ((data->cFileName[0] == '.' && data->cFileName[1] == 0) || (data->cFileName[0] == '.' && data->cFileName[1] == '.' && data->cFileName[2] == 0))
440 utf8_result = g_utf16_to_utf8 (data->cFileName, -1, NULL, NULL, NULL);
441 if (utf8_result == NULL)
444 full_name = g_build_filename (handle->utf8_path, utf8_result, NULL);
445 g_free (utf8_result);
446 *result = mono_string_new (mono_domain_get (), full_name);
452 /* FIXME make gc suspendable */
454 ves_icall_System_IO_MonoIO_FindFirst (MonoString *path,
455 MonoString *path_with_pattern,
456 gint32 *result_attr, gint32 *error,
459 WIN32_FIND_DATA data;
461 IncrementalFind *ifh;
464 *error = ERROR_SUCCESS;
466 find_handle = FindFirstFile (mono_string_chars (path_with_pattern), &data);
468 if (find_handle == INVALID_HANDLE_VALUE) {
469 gint32 find_error = GetLastError ();
472 if (find_error == ERROR_FILE_NOT_FOUND)
479 ifh = g_new (IncrementalFind, 1);
480 ifh->find_handle = find_handle;
481 ifh->utf8_path = mono_string_to_utf8 (path);
482 ifh->domain = mono_domain_get ();
485 while (incremental_find_check_match (ifh, &data, &result) == 0){
486 if (FindNextFile (find_handle, &data) == FALSE){
487 int e = GetLastError ();
488 if (e != ERROR_NO_MORE_FILES)
493 *result_attr = data.dwFileAttributes;
498 /* FIXME make gc suspendable */
500 ves_icall_System_IO_MonoIO_FindNext (gpointer handle, gint32 *result_attr, gint32 *error)
502 IncrementalFind *ifh = (IncrementalFind *)handle;
503 WIN32_FIND_DATA data;
506 *error = ERROR_SUCCESS;
508 if (FindNextFile (ifh->find_handle, &data) == FALSE){
509 int e = GetLastError ();
510 if (e != ERROR_NO_MORE_FILES)
514 } while (incremental_find_check_match (ifh, &data, &result) == 0);
516 *result_attr = data.dwFileAttributes;
521 ves_icall_System_IO_MonoIO_FindClose (gpointer handle)
523 IncrementalFind *ifh = (IncrementalFind *)handle;
526 MONO_PREPARE_BLOCKING;
527 if (FindClose (ifh->find_handle) == FALSE){
528 error = GetLastError ();
530 error = ERROR_SUCCESS;
531 g_free (ifh->utf8_path);
533 MONO_FINISH_BLOCKING;
539 ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *io_error)
546 len = MAX_PATH + 1; /*FIXME this is too smal under most unix systems.*/
547 buf = g_new (gunichar2, len);
549 mono_error_init (&error);
550 *io_error=ERROR_SUCCESS;
553 res_len = GetCurrentDirectory (len, buf);
554 if (res_len > len) { /*buf is too small.*/
555 int old_res_len = res_len;
557 buf = g_new (gunichar2, res_len);
558 res_len = GetCurrentDirectory (res_len, buf) == old_res_len;
566 result = mono_string_new_utf16_checked (mono_domain_get (), buf, len, &error);
568 *io_error=GetLastError ();
572 mono_error_raise_exception (&error);
577 ves_icall_System_IO_MonoIO_SetCurrentDirectory (MonoString *path,
582 *error=ERROR_SUCCESS;
584 ret=SetCurrentDirectory (mono_string_chars (path));
586 *error=GetLastError ();
593 ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
597 MONO_PREPARE_BLOCKING;
599 *error=ERROR_SUCCESS;
601 ret=MoveFile (mono_string_chars (path), mono_string_chars (dest));
603 *error=GetLastError ();
606 MONO_FINISH_BLOCKING;
611 ves_icall_System_IO_MonoIO_ReplaceFile (MonoString *sourceFileName, MonoString *destinationFileName,
612 MonoString *destinationBackupFileName, MonoBoolean ignoreMetadataErrors,
616 gunichar2 *utf16_sourceFileName = NULL, *utf16_destinationFileName = NULL, *utf16_destinationBackupFileName = NULL;
617 guint32 replaceFlags = REPLACEFILE_WRITE_THROUGH;
618 MONO_PREPARE_BLOCKING;
621 utf16_sourceFileName = mono_string_chars (sourceFileName);
622 if (destinationFileName)
623 utf16_destinationFileName = mono_string_chars (destinationFileName);
624 if (destinationBackupFileName)
625 utf16_destinationBackupFileName = mono_string_chars (destinationBackupFileName);
627 *error = ERROR_SUCCESS;
628 if (ignoreMetadataErrors)
629 replaceFlags |= REPLACEFILE_IGNORE_MERGE_ERRORS;
631 /* FIXME: source and destination file names must not be NULL, but apparently they might be! */
632 ret = ReplaceFile (utf16_destinationFileName, utf16_sourceFileName, utf16_destinationBackupFileName,
633 replaceFlags, NULL, NULL);
635 *error = GetLastError ();
637 MONO_FINISH_BLOCKING;
642 ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
643 MonoBoolean overwrite, gint32 *error)
646 MONO_PREPARE_BLOCKING;
648 *error=ERROR_SUCCESS;
650 ret=CopyFile (mono_string_chars (path), mono_string_chars (dest), !overwrite);
652 *error=GetLastError ();
655 MONO_FINISH_BLOCKING;
660 ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
663 MONO_PREPARE_BLOCKING;
665 *error=ERROR_SUCCESS;
667 ret=DeleteFile (mono_string_chars (path));
669 *error=GetLastError ();
672 MONO_FINISH_BLOCKING;
677 ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
680 MONO_PREPARE_BLOCKING;
682 *error=ERROR_SUCCESS;
684 ret=get_file_attributes (mono_string_chars (path));
687 * The definition of INVALID_FILE_ATTRIBUTES in the cygwin win32
688 * headers is wrong, hence this temporary workaround.
690 * http://cygwin.com/ml/cygwin/2003-09/msg01771.html
693 /* if(ret==INVALID_FILE_ATTRIBUTES) { */
694 *error=GetLastError ();
697 MONO_FINISH_BLOCKING;
702 ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
706 MONO_PREPARE_BLOCKING;
708 *error=ERROR_SUCCESS;
710 ret=SetFileAttributes (mono_string_chars (path),
711 convert_attrs ((MonoFileAttributes)attrs));
713 *error=GetLastError ();
716 MONO_FINISH_BLOCKING;
721 ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
724 MONO_PREPARE_BLOCKING;
726 *error=ERROR_SUCCESS;
728 ret=GetFileType (handle);
729 if(ret==FILE_TYPE_UNKNOWN) {
730 /* Not necessarily an error, but the caller will have
731 * to decide based on the error value.
733 *error=GetLastError ();
736 MONO_FINISH_BLOCKING;
741 ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
745 WIN32_FILE_ATTRIBUTE_DATA data;
746 MONO_PREPARE_BLOCKING;
748 *error=ERROR_SUCCESS;
750 result = get_file_attributes_ex (mono_string_chars (path), &data);
753 convert_win32_file_attribute_data (&data, stat);
755 *error=GetLastError ();
756 memset (stat, 0, sizeof (MonoIOStat));
759 MONO_FINISH_BLOCKING;
764 ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode,
765 gint32 access_mode, gint32 share, gint32 options,
769 int attributes, attrs;
771 MONO_PREPARE_BLOCKING;
773 chars = mono_string_chars (filename);
774 *error=ERROR_SUCCESS;
777 if (options & FileOptions_Encrypted)
778 attributes = FILE_ATTRIBUTE_ENCRYPTED;
780 attributes = FILE_ATTRIBUTE_NORMAL;
781 if (options & FileOptions_DeleteOnClose)
782 attributes |= FILE_FLAG_DELETE_ON_CLOSE;
783 if (options & FileOptions_SequentialScan)
784 attributes |= FILE_FLAG_SEQUENTIAL_SCAN;
785 if (options & FileOptions_RandomAccess)
786 attributes |= FILE_FLAG_RANDOM_ACCESS;
788 if (options & FileOptions_Temporary)
789 attributes |= FILE_ATTRIBUTE_TEMPORARY;
791 /* Not sure if we should set FILE_FLAG_OVERLAPPED, how does this mix with the "Async" bool here? */
792 if (options & FileOptions_Asynchronous)
793 attributes |= FILE_FLAG_OVERLAPPED;
795 if (options & FileOptions_WriteThrough)
796 attributes |= FILE_FLAG_WRITE_THROUGH;
798 attributes = FILE_ATTRIBUTE_NORMAL;
800 /* If we're opening a directory we need to set the extra flag
802 attrs = get_file_attributes (chars);
803 if (attrs != INVALID_FILE_ATTRIBUTES) {
804 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
805 attributes |= FILE_FLAG_BACKUP_SEMANTICS;
809 ret=CreateFile (chars, convert_access ((MonoFileAccess)access_mode),
810 convert_share ((MonoFileShare)share), NULL, convert_mode ((MonoFileMode)mode),
812 if(ret==INVALID_HANDLE_VALUE) {
813 *error=GetLastError ();
816 MONO_FINISH_BLOCKING;
821 ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
824 MONO_PREPARE_BLOCKING;
826 *error=ERROR_SUCCESS;
828 ret=CloseHandle (handle);
830 *error=GetLastError ();
833 MONO_FINISH_BLOCKING;
838 ves_icall_System_IO_MonoIO_Read (HANDLE handle, MonoArray *dest,
839 gint32 dest_offset, gint32 count,
846 *error=ERROR_SUCCESS;
848 MONO_CHECK_ARG_NULL (dest, 0);
850 if (dest_offset > mono_array_length (dest) - count) {
851 mono_set_pending_exception (mono_get_exception_argument ("array", "array too small. numBytes/offset wrong."));
855 buffer = mono_array_addr (dest, guchar, dest_offset);
857 MONO_PREPARE_BLOCKING;
858 result = ReadFile (handle, buffer, count, &n, NULL);
859 MONO_FINISH_BLOCKING;
862 *error=GetLastError ();
870 ves_icall_System_IO_MonoIO_Write (HANDLE handle, MonoArray *src,
871 gint32 src_offset, gint32 count,
878 *error=ERROR_SUCCESS;
880 MONO_CHECK_ARG_NULL (src, 0);
882 if (src_offset > mono_array_length (src) - count) {
883 mono_set_pending_exception (mono_get_exception_argument ("array", "array too small. numBytes/offset wrong."));
887 buffer = mono_array_addr (src, guchar, src_offset);
888 MONO_PREPARE_BLOCKING;
889 result = WriteFile (handle, buffer, count, &n, NULL);
890 MONO_FINISH_BLOCKING;
893 *error=GetLastError ();
901 ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
905 MONO_PREPARE_BLOCKING;
907 *error=ERROR_SUCCESS;
909 offset_hi = offset >> 32;
910 offset = SetFilePointer (handle, (gint32) (offset & 0xFFFFFFFF), &offset_hi,
911 convert_seekorigin ((MonoSeekOrigin)origin));
913 if(offset==INVALID_SET_FILE_POINTER) {
914 *error=GetLastError ();
917 MONO_FINISH_BLOCKING;
918 return offset | ((gint64)offset_hi << 32);
922 ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
925 MONO_PREPARE_BLOCKING;
927 *error=ERROR_SUCCESS;
929 ret=FlushFileBuffers (handle);
931 *error=GetLastError ();
934 MONO_FINISH_BLOCKING;
939 ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
943 MONO_PREPARE_BLOCKING;
945 *error=ERROR_SUCCESS;
947 length = GetFileSize (handle, &length_hi);
948 if(length==INVALID_FILE_SIZE) {
949 *error=GetLastError ();
952 MONO_FINISH_BLOCKING;
953 return length | ((gint64)length_hi << 32);
956 /* FIXME make gc suspendable */
958 ves_icall_System_IO_MonoIO_SetLength (HANDLE handle, gint64 length,
961 gint64 offset, offset_set;
966 *error=ERROR_SUCCESS;
968 /* save file pointer */
971 offset = SetFilePointer (handle, 0, &offset_hi, FILE_CURRENT);
972 if(offset==INVALID_SET_FILE_POINTER) {
973 *error=GetLastError ();
977 /* extend or truncate */
979 length_hi = length >> 32;
980 offset_set=SetFilePointer (handle, length & 0xFFFFFFFF, &length_hi,
982 if(offset_set==INVALID_SET_FILE_POINTER) {
983 *error=GetLastError ();
987 result = SetEndOfFile (handle);
989 *error=GetLastError ();
993 /* restore file pointer */
995 offset_set=SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
997 if(offset_set==INVALID_SET_FILE_POINTER) {
998 *error=GetLastError ();
1006 ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time,
1007 gint64 last_access_time,
1008 gint64 last_write_time, gint32 *error)
1011 const FILETIME *creation_filetime;
1012 const FILETIME *last_access_filetime;
1013 const FILETIME *last_write_filetime;
1014 MONO_PREPARE_BLOCKING;
1016 *error=ERROR_SUCCESS;
1018 if (creation_time < 0)
1019 creation_filetime = NULL;
1021 creation_filetime = (FILETIME *)&creation_time;
1023 if (last_access_time < 0)
1024 last_access_filetime = NULL;
1026 last_access_filetime = (FILETIME *)&last_access_time;
1028 if (last_write_time < 0)
1029 last_write_filetime = NULL;
1031 last_write_filetime = (FILETIME *)&last_write_time;
1033 ret=SetFileTime (handle, creation_filetime, last_access_filetime, last_write_filetime);
1035 *error=GetLastError ();
1038 MONO_FINISH_BLOCKING;
1043 ves_icall_System_IO_MonoIO_get_ConsoleOutput ()
1045 return GetStdHandle (STD_OUTPUT_HANDLE);
1049 ves_icall_System_IO_MonoIO_get_ConsoleInput ()
1051 return GetStdHandle (STD_INPUT_HANDLE);
1055 ves_icall_System_IO_MonoIO_get_ConsoleError ()
1057 return GetStdHandle (STD_ERROR_HANDLE);
1061 ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle, HANDLE *write_handle, gint32 *error)
1063 SECURITY_ATTRIBUTES attr;
1066 attr.nLength=sizeof(SECURITY_ATTRIBUTES);
1067 attr.bInheritHandle=TRUE;
1068 attr.lpSecurityDescriptor=NULL;
1070 MONO_PREPARE_BLOCKING;
1071 ret=CreatePipe (read_handle, write_handle, &attr, 0);
1072 MONO_FINISH_BLOCKING;
1075 *error = GetLastError ();
1076 /* FIXME: throw an exception? */
1084 ves_icall_System_IO_MonoIO_DuplicateHandle (HANDLE source_process_handle, HANDLE source_handle,
1085 HANDLE target_process_handle, HANDLE *target_handle, gint32 access, gint32 inherit, gint32 options, gint32 *error)
1087 /* This is only used on Windows */
1090 MONO_PREPARE_BLOCKING;
1091 ret=DuplicateHandle (source_process_handle, source_handle, target_process_handle, target_handle, access, inherit, options);
1092 MONO_FINISH_BLOCKING;
1095 *error = GetLastError ();
1096 /* FIXME: throw an exception? */
1104 ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar ()
1106 #if defined (TARGET_WIN32)
1107 return (gunichar2) ':'; /* colon */
1109 return (gunichar2) '/'; /* forward slash */
1114 ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar ()
1116 #if defined (TARGET_WIN32)
1117 return (gunichar2) '\\'; /* backslash */
1119 return (gunichar2) '/'; /* forward slash */
1124 ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar ()
1126 #if defined (TARGET_WIN32)
1127 return (gunichar2) '/'; /* forward slash */
1129 if (IS_PORTABILITY_SET)
1130 return (gunichar2) '\\'; /* backslash */
1132 return (gunichar2) '/'; /* forward slash */
1137 ves_icall_System_IO_MonoIO_get_PathSeparator ()
1139 #if defined (TARGET_WIN32)
1140 return (gunichar2) ';'; /* semicolon */
1142 return (gunichar2) ':'; /* colon */
1146 static const gunichar2
1147 invalid_path_chars [] = {
1148 #if defined (TARGET_WIN32)
1149 0x0022, /* double quote, which seems allowed in MS.NET but should be rejected */
1150 0x003c, /* less than */
1151 0x003e, /* greater than */
1168 ves_icall_System_IO_MonoIO_get_InvalidPathChars ()
1174 domain = mono_domain_get ();
1175 n = sizeof (invalid_path_chars) / sizeof (gunichar2);
1176 chars = mono_array_new (domain, mono_defaults.char_class, n);
1178 for (i = 0; i < n; ++ i)
1179 mono_array_set (chars, gunichar2, i, invalid_path_chars [i]);
1184 void ves_icall_System_IO_MonoIO_Lock (HANDLE handle, gint64 position,
1185 gint64 length, gint32 *error)
1188 MONO_PREPARE_BLOCKING;
1190 *error=ERROR_SUCCESS;
1192 ret=LockFile (handle, position & 0xFFFFFFFF, position >> 32,
1193 length & 0xFFFFFFFF, length >> 32);
1195 *error = GetLastError ();
1198 MONO_FINISH_BLOCKING;
1201 void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position,
1202 gint64 length, gint32 *error)
1205 MONO_PREPARE_BLOCKING;
1207 *error=ERROR_SUCCESS;
1209 ret=UnlockFile (handle, position & 0xFFFFFFFF, position >> 32,
1210 length & 0xFFFFFFFF, length >> 32);
1212 *error = GetLastError ();
1215 MONO_FINISH_BLOCKING;
1218 //Support for io-layer free mmap'd files.
1220 #if defined (TARGET_IOS) || defined (TARGET_ANDROID)
1223 mono_filesize_from_path (MonoString *string)
1227 char *path = mono_string_to_utf8 (string);
1229 MONO_PREPARE_BLOCKING;
1230 if (stat (path, &buf) == -1)
1233 res = (gint64)buf.st_size;
1237 MONO_FINISH_BLOCKING;
1242 mono_filesize_from_fd (int fd)
1247 MONO_PREPARE_BLOCKING;
1248 res = fstat (fd, &buf);
1249 MONO_FINISH_BLOCKING;
1254 return (gint64)buf.st_size;
1259 void _wapi_handle_dump (void);
1261 void ves_icall_System_IO_MonoIO_DumpHandles (void)
1264 _wapi_handle_dump ();