mono/metadata/file-io.c

   1 /*
   2  * file-io.c: File IO internal calls
   3  *
   4  * Author:
   5  *      Dick Porter (dick@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <string.h>
  13 #include <errno.h>
  14 #include <signal.h>
  15 #include <unistd.h>
  16
  17 #ifndef PLATFORM_WIN32
  18 #ifdef HAVE_AIO_H
  19 #include <aio.h>
  20 #define USE_AIO 1
  21 #elif defined(HAVE_SYS_AIO_H)
  22 #include <sys/aio.h>
  23 #define USE_AIO 1
  24 #else
  25 #undef USE_AIO
  26 #endif
  27 #endif
  28
  29 #include <mono/metadata/object.h>
  30 #include <mono/io-layer/io-layer.h>
  31 #include <mono/metadata/file-io.h>
  32 #include <mono/metadata/exception.h>
  33 #include <mono/metadata/appdomain.h>
  34 #include <mono/metadata/marshal.h>
  35
  36 #undef DEBUG
  37
  38 /* conversion functions */
  39
  40 static guint32 convert_mode(MonoFileMode mono_mode)
  41 {
  42         guint32 mode;
  43
  44         switch(mono_mode) {
  45         case FileMode_CreateNew:
  46                 mode=CREATE_NEW;
  47                 break;
  48         case FileMode_Create:
  49                 mode=CREATE_ALWAYS;
  50                 break;
  51         case FileMode_Open:
  52                 mode=OPEN_EXISTING;
  53                 break;
  54         case FileMode_OpenOrCreate:
  55                 mode=OPEN_ALWAYS;
  56                 break;
  57         case FileMode_Truncate:
  58                 mode=TRUNCATE_EXISTING;
  59                 break;
  60         case FileMode_Append:
  61                 mode=OPEN_ALWAYS;
  62                 break;
  63         default:
  64                 g_warning("System.IO.FileMode has unknown value 0x%x",
  65                           mono_mode);
  66                 /* Safe fallback */
  67                 mode=OPEN_EXISTING;
  68         }
  69
  70         return(mode);
  71 }
  72
  73 static guint32 convert_access(MonoFileAccess mono_access)
  74 {
  75         guint32 access;
  76
  77         switch(mono_access) {
  78         case FileAccess_Read:
  79                 access=GENERIC_READ;
  80                 break;
  81         case FileAccess_Write:
  82                 access=GENERIC_WRITE;
  83                 break;
  84         case FileAccess_ReadWrite:
  85                 access=GENERIC_READ|GENERIC_WRITE;
  86                 break;
  87         default:
  88                 g_warning("System.IO.FileAccess has unknown value 0x%x",
  89                           mono_access);
  90                 /* Safe fallback */
  91                 access=GENERIC_READ;
  92         }
  93
  94         return(access);
  95 }
  96
  97 static guint32 convert_share(MonoFileShare mono_share)
  98 {
  99         guint32 share;
 100
 101         switch(mono_share) {
 102         case FileShare_None:
 103                 share=0;
 104                 break;
 105         case FileShare_Read:
 106                 share=FILE_SHARE_READ;
 107                 break;
 108         case FileShare_Write:
 109                 share=FILE_SHARE_WRITE;
 110                 break;
 111         case FileShare_ReadWrite:
 112                 share=FILE_SHARE_READ|FILE_SHARE_WRITE;
 113                 break;
 114         default:
 115                 g_warning("System.IO.FileShare has unknown value 0x%x",
 116                           mono_share);
 117                 /* Safe fallback */
 118                 share=0;
 119         }
 120
 121         return(share);
 122 }
 123
 124 #if 0
 125 static guint32 convert_stdhandle(guint32 fd)
 126 {
 127         guint32 stdhandle;
 128
 129         switch(fd) {
 130         case 0:
 131                 stdhandle=STD_INPUT_HANDLE;
 132                 break;
 133         case 1:
 134                 stdhandle=STD_OUTPUT_HANDLE;
 135                 break;
 136         case 2:
 137                 stdhandle=STD_ERROR_HANDLE;
 138                 break;
 139         default:
 140                 g_warning("unknown standard file descriptor %d", fd);
 141                 stdhandle=STD_INPUT_HANDLE;
 142         }
 143
 144         return(stdhandle);
 145 }
 146 #endif
 147
 148 static guint32 convert_seekorigin(MonoSeekOrigin origin)
 149 {
 150         guint32 w32origin;
 151
 152         switch(origin) {
 153         case SeekOrigin_Begin:
 154                 w32origin=FILE_BEGIN;
 155                 break;
 156         case SeekOrigin_Current:
 157                 w32origin=FILE_CURRENT;
 158                 break;
 159         case SeekOrigin_End:
 160                 w32origin=FILE_END;
 161                 break;
 162         default:
 163                 g_warning("System.IO.SeekOrigin has unknown value 0x%x",
 164                           origin);
 165                 /* Safe fallback */
 166                 w32origin=FILE_CURRENT;
 167         }
 168
 169         return(w32origin);
 170 }
 171
 172 static gint64 convert_filetime (const FILETIME *filetime)
 173 {
 174         guint64 ticks = filetime->dwHighDateTime;
 175         ticks <<= 32;
 176         ticks += filetime->dwLowDateTime;
 177         return (gint64)ticks;
 178 }
 179
 180 static void convert_win32_file_attribute_data (const WIN32_FILE_ATTRIBUTE_DATA *data, const gunichar2 *name, MonoIOStat *stat)
 181 {
 182         int len;
 183
 184         stat->attributes = data->dwFileAttributes;
 185         stat->creation_time = convert_filetime (&data->ftCreationTime);
 186         stat->last_access_time = convert_filetime (&data->ftLastAccessTime);
 187         stat->last_write_time = convert_filetime (&data->ftLastWriteTime);
 188         stat->length = ((gint64)data->nFileSizeHigh << 32) | data->nFileSizeLow;
 189
 190         len = 0;
 191         while (name [len])
 192                 ++ len;
 193
 194         stat->name = mono_string_new_utf16 (mono_domain_get (), name, len);
 195 }
 196
 197 /* Managed file attributes have nearly but not quite the same values
 198  * as the w32 equivalents.
 199  */
 200 static guint32 convert_attrs(MonoFileAttributes attrs)
 201 {
 202         if(attrs & FileAttributes_Encrypted) {
 203                 attrs |= FILE_ATTRIBUTE_ENCRYPTED;
 204         }
 205
 206         return(attrs);
 207 }
 208
 209 /* System.IO.MonoIO internal calls */
 210
 211 MonoBoolean
 212 ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error)
 213 {
 214         gboolean ret;
 215
 216         MONO_ARCH_SAVE_REGS;
 217
 218         *error=ERROR_SUCCESS;
 219
 220         ret=CreateDirectory (mono_string_chars (path), NULL);
 221         if(ret==FALSE) {
 222                 *error=GetLastError ();
 223         }
 224
 225         return(ret);
 226 }
 227
 228 MonoBoolean
 229 ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error)
 230 {
 231         gboolean ret;
 232
 233         MONO_ARCH_SAVE_REGS;
 234
 235         *error=ERROR_SUCCESS;
 236
 237         ret=RemoveDirectory (mono_string_chars (path));
 238         if(ret==FALSE) {
 239                 *error=GetLastError ();
 240         }
 241
 242         return(ret);
 243 }
 244
 245 HANDLE
 246 ves_icall_System_IO_MonoIO_FindFirstFile (MonoString *path, MonoIOStat *stat,
 247                                           gint32 *error)
 248 {
 249         WIN32_FIND_DATA data;
 250         HANDLE result;
 251
 252         MONO_ARCH_SAVE_REGS;
 253
 254         *error=ERROR_SUCCESS;
 255
 256         result = FindFirstFile (mono_string_chars (path), &data);
 257
 258         /* note: WIN32_FIND_DATA is an extension of WIN32_FILE_ATTRIBUTE_DATA */
 259
 260         if (result != INVALID_HANDLE_VALUE) {
 261                 convert_win32_file_attribute_data ((const WIN32_FILE_ATTRIBUTE_DATA *)&data,
 262                                                    &data.cFileName [0], stat);
 263         } else {
 264                 *error=GetLastError ();
 265         }
 266
 267         return result;
 268 }
 269
 270 MonoBoolean
 271 ves_icall_System_IO_MonoIO_FindNextFile (HANDLE find, MonoIOStat *stat,
 272                                          gint32 *error)
 273 {
 274         WIN32_FIND_DATA data;
 275         gboolean result;
 276
 277         MONO_ARCH_SAVE_REGS;
 278
 279         *error=ERROR_SUCCESS;
 280
 281         result = FindNextFile (find, &data);
 282         if (result) {
 283                 convert_win32_file_attribute_data ((const WIN32_FILE_ATTRIBUTE_DATA *)&data,
 284                                                    &data.cFileName [0], stat);
 285         } else {
 286                 *error=GetLastError ();
 287         }
 288
 289         return result;
 290 }
 291
 292 MonoBoolean
 293 ves_icall_System_IO_MonoIO_FindClose (HANDLE find, gint32 *error)
 294 {
 295         gboolean ret;
 296
 297         MONO_ARCH_SAVE_REGS;
 298
 299         *error=ERROR_SUCCESS;
 300
 301         ret=FindClose (find);
 302         if(ret==FALSE) {
 303                 *error=GetLastError ();
 304         }
 305
 306         return(ret);
 307 }
 308
 309 MonoString *
 310 ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *error)
 311 {
 312         MonoString *result;
 313         gunichar2 *buf;
 314         int len;
 315
 316         MONO_ARCH_SAVE_REGS;
 317
 318         len = MAX_PATH + 1;
 319         buf = g_new (gunichar2, len);
 320
 321         *error=ERROR_SUCCESS;
 322         result = NULL;
 323
 324         if (GetCurrentDirectory (len, buf) > 0) {
 325                 len = 0;
 326                 while (buf [len])
 327                         ++ len;
 328
 329                 result = mono_string_new_utf16 (mono_domain_get (), buf, len);
 330         } else {
 331                 *error=GetLastError ();
 332         }
 333
 334         g_free (buf);
 335         return result;
 336 }
 337
 338 MonoBoolean
 339 ves_icall_System_IO_MonoIO_SetCurrentDirectory (MonoString *path,
 340                                                 gint32 *error)
 341 {
 342         gboolean ret;
 343
 344         MONO_ARCH_SAVE_REGS;
 345
 346         *error=ERROR_SUCCESS;
 347
 348         ret=SetCurrentDirectory (mono_string_chars (path));
 349         if(ret==FALSE) {
 350                 *error=GetLastError ();
 351         }
 352
 353         return(ret);
 354 }
 355
 356 MonoBoolean
 357 ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
 358                                      gint32 *error)
 359 {
 360         gboolean ret;
 361
 362         MONO_ARCH_SAVE_REGS;
 363
 364         *error=ERROR_SUCCESS;
 365
 366         ret=MoveFile (mono_string_chars (path), mono_string_chars (dest));
 367         if(ret==FALSE) {
 368                 *error=GetLastError ();
 369         }
 370
 371         return(ret);
 372 }
 373
 374 MonoBoolean
 375 ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
 376                                      MonoBoolean overwrite, gint32 *error)
 377 {
 378         gboolean ret;
 379
 380         MONO_ARCH_SAVE_REGS;
 381
 382         *error=ERROR_SUCCESS;
 383
 384         ret=CopyFile (mono_string_chars (path), mono_string_chars (dest), !overwrite);
 385         if(ret==FALSE) {
 386                 *error=GetLastError ();
 387         }
 388
 389         return(ret);
 390 }
 391
 392 MonoBoolean
 393 ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
 394 {
 395         gboolean ret;
 396
 397         MONO_ARCH_SAVE_REGS;
 398
 399         *error=ERROR_SUCCESS;
 400
 401         ret=DeleteFile (mono_string_chars (path));
 402         if(ret==FALSE) {
 403                 *error=GetLastError ();
 404         }
 405
 406         return(ret);
 407 }
 408
 409 gint32
 410 ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
 411 {
 412         gint32 ret;
 413
 414         MONO_ARCH_SAVE_REGS;
 415
 416         *error=ERROR_SUCCESS;
 417
 418         ret=GetFileAttributes (mono_string_chars (path));
 419
 420         /*
 421          * The definition of INVALID_FILE_ATTRIBUTES in the cygwin win32
 422          * headers is wrong, hence this temporary workaround.
 423          * See
 424          * http://cygwin.com/ml/cygwin/2003-09/msg01771.html
 425          */
 426         if (ret==-1) {
 427 //      if(ret==INVALID_FILE_ATTRIBUTES) {
 428                 *error=GetLastError ();
 429         }
 430
 431         return(ret);
 432 }
 433
 434 MonoBoolean
 435 ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
 436                                               gint32 *error)
 437 {
 438         gboolean ret;
 439
 440         MONO_ARCH_SAVE_REGS;
 441
 442         *error=ERROR_SUCCESS;
 443
 444         ret=SetFileAttributes (mono_string_chars (path),
 445                                convert_attrs (attrs));
 446         if(ret==FALSE) {
 447                 *error=GetLastError ();
 448         }
 449
 450         return(ret);
 451 }
 452
 453 gint32
 454 ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
 455 {
 456         gboolean ret;
 457
 458         MONO_ARCH_SAVE_REGS;
 459
 460         *error=ERROR_SUCCESS;
 461
 462         ret=GetFileType (handle);
 463         if(ret==FILE_TYPE_UNKNOWN) {
 464                 /* Not necessarily an error, but the caller will have
 465                  * to decide based on the error value.
 466                  */
 467                 *error=GetLastError ();
 468         }
 469
 470         return(ret);
 471 }
 472
 473 MonoBoolean
 474 ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
 475                                         gint32 *error)
 476 {
 477         gboolean result;
 478         WIN32_FILE_ATTRIBUTE_DATA data;
 479
 480         MONO_ARCH_SAVE_REGS;
 481
 482         *error=ERROR_SUCCESS;
 483
 484         result = GetFileAttributesEx (mono_string_chars (path), GetFileExInfoStandard, &data);
 485
 486         if (result) {
 487                 convert_win32_file_attribute_data (&data,
 488                                                    mono_string_chars (path),
 489                                                    stat);
 490         } else {
 491                 *error=GetLastError ();
 492         }
 493
 494         return result;
 495 }
 496
 497 HANDLE
 498 ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode,
 499                                  gint32 access_mode, gint32 share,
 500                                  MonoBoolean async, gint32 *error)
 501 {
 502         HANDLE ret;
 503
 504         MONO_ARCH_SAVE_REGS;
 505
 506         *error=ERROR_SUCCESS;
 507
 508         ret=CreateFile (mono_string_chars (filename),
 509                         convert_access (access_mode), convert_share (share),
 510                         NULL, convert_mode (mode),
 511                         FILE_ATTRIBUTE_NORMAL | ((async) ? FILE_FLAG_OVERLAPPED : 0),
 512                         NULL);
 513         if(ret==INVALID_HANDLE_VALUE) {
 514                 *error=GetLastError ();
 515         }
 516
 517         return(ret);
 518 }
 519
 520 MonoBoolean
 521 ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
 522 {
 523         gboolean ret;
 524
 525         MONO_ARCH_SAVE_REGS;
 526
 527         *error=ERROR_SUCCESS;
 528
 529         ret=CloseHandle (handle);
 530         if(ret==FALSE) {
 531                 *error=GetLastError ();
 532         }
 533
 534         return(ret);
 535 }
 536
 537 gint32
 538 ves_icall_System_IO_MonoIO_Read (HANDLE handle, MonoArray *dest,
 539                                  gint32 dest_offset, gint32 count,
 540                                  gint32 *error)
 541 {
 542         guchar *buffer;
 543         gboolean result;
 544         guint32 n;
 545
 546         MONO_ARCH_SAVE_REGS;
 547
 548         *error=ERROR_SUCCESS;
 549
 550         if (dest_offset + count > mono_array_length (dest))
 551                 return 0;
 552
 553         buffer = mono_array_addr (dest, guchar, dest_offset);
 554         result = ReadFile (handle, buffer, count, &n, NULL);
 555
 556         if (!result) {
 557                 *error=GetLastError ();
 558                 return -1;
 559         }
 560
 561         return (gint32)n;
 562 }
 563
 564 gint32
 565 ves_icall_System_IO_MonoIO_Write (HANDLE handle, MonoArray *src,
 566                                   gint32 src_offset, gint32 count,
 567                                   gint32 *error)
 568 {
 569         guchar *buffer;
 570         gboolean result;
 571         guint32 n;
 572
 573         MONO_ARCH_SAVE_REGS;
 574
 575         *error=ERROR_SUCCESS;
 576
 577         if (src_offset + count > mono_array_length (src))
 578                 return 0;
 579
 580         buffer = mono_array_addr (src, guchar, src_offset);
 581         result = WriteFile (handle, buffer, count, &n, NULL);
 582
 583         if (!result) {
 584                 *error=GetLastError ();
 585                 return -1;
 586         }
 587
 588         return (gint32)n;
 589 }
 590
 591 gint64
 592 ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
 593                                  gint32 *error)
 594 {
 595         guint32 offset_hi;
 596
 597         MONO_ARCH_SAVE_REGS;
 598
 599         *error=ERROR_SUCCESS;
 600
 601         offset_hi = offset >> 32;
 602         offset = SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
 603                                  convert_seekorigin (origin));
 604
 605         if(offset==INVALID_SET_FILE_POINTER) {
 606                 *error=GetLastError ();
 607         }
 608
 609         return offset | ((gint64)offset_hi << 32);
 610 }
 611
 612 MonoBoolean
 613 ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
 614 {
 615         gboolean ret;
 616
 617         MONO_ARCH_SAVE_REGS;
 618
 619         *error=ERROR_SUCCESS;
 620
 621         ret=FlushFileBuffers (handle);
 622         if(ret==FALSE) {
 623                 *error=GetLastError ();
 624         }
 625
 626         return(ret);
 627 }
 628
 629 gint64
 630 ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
 631 {
 632         gint64 length;
 633         guint32 length_hi;
 634
 635         MONO_ARCH_SAVE_REGS;
 636
 637         *error=ERROR_SUCCESS;
 638
 639         length = GetFileSize (handle, &length_hi);
 640         if(length==INVALID_FILE_SIZE) {
 641                 *error=GetLastError ();
 642         }
 643
 644         return length | ((gint64)length_hi << 32);
 645 }
 646
 647 MonoBoolean
 648 ves_icall_System_IO_MonoIO_SetLength (HANDLE handle, gint64 length,
 649                                       gint32 *error)
 650 {
 651         gint64 offset, offset_set;
 652         gint32 offset_hi;
 653         gint32 length_hi;
 654         gboolean result;
 655
 656         MONO_ARCH_SAVE_REGS;
 657
 658         *error=ERROR_SUCCESS;
 659
 660         /* save file pointer */
 661
 662         offset_hi = 0;
 663         offset = SetFilePointer (handle, 0, &offset_hi, FILE_CURRENT);
 664         if(offset==INVALID_SET_FILE_POINTER) {
 665                 *error=GetLastError ();
 666                 return(FALSE);
 667         }
 668
 669         /* extend or truncate */
 670
 671         length_hi = length >> 32;
 672         offset_set=SetFilePointer (handle, length & 0xFFFFFFFF, &length_hi,
 673                                    FILE_BEGIN);
 674         if(offset_set==INVALID_SET_FILE_POINTER) {
 675                 *error=GetLastError ();
 676                 return(FALSE);
 677         }
 678
 679         result = SetEndOfFile (handle);
 680         if(result==FALSE) {
 681                 *error=GetLastError ();
 682                 return(FALSE);
 683         }
 684
 685         /* restore file pointer */
 686
 687         offset_set=SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
 688                                    FILE_BEGIN);
 689         if(offset_set==INVALID_SET_FILE_POINTER) {
 690                 *error=GetLastError ();
 691                 return(FALSE);
 692         }
 693
 694         return result;
 695 }
 696
 697 MonoBoolean
 698 ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time,
 699                                         gint64 last_access_time,
 700                                         gint64 last_write_time, gint32 *error)
 701 {
 702         gboolean ret;
 703         const FILETIME *creation_filetime;
 704         const FILETIME *last_access_filetime;
 705         const FILETIME *last_write_filetime;
 706
 707         MONO_ARCH_SAVE_REGS;
 708
 709         *error=ERROR_SUCCESS;
 710
 711         if (creation_time < 0)
 712                 creation_filetime = NULL;
 713         else
 714                 creation_filetime = (FILETIME *)&creation_time;
 715
 716         if (last_access_time < 0)
 717                 last_access_filetime = NULL;
 718         else
 719                 last_access_filetime = (FILETIME *)&last_access_time;
 720
 721         if (last_write_time < 0)
 722                 last_write_filetime = NULL;
 723         else
 724                 last_write_filetime = (FILETIME *)&last_write_time;
 725
 726         ret=SetFileTime (handle, creation_filetime, last_access_filetime, last_write_filetime);
 727         if(ret==FALSE) {
 728                 *error=GetLastError ();
 729         }
 730
 731         return(ret);
 732 }
 733
 734 HANDLE
 735 ves_icall_System_IO_MonoIO_get_ConsoleOutput ()
 736 {
 737         MONO_ARCH_SAVE_REGS;
 738
 739         return GetStdHandle (STD_OUTPUT_HANDLE);
 740 }
 741
 742 HANDLE
 743 ves_icall_System_IO_MonoIO_get_ConsoleInput ()
 744 {
 745         MONO_ARCH_SAVE_REGS;
 746
 747         return GetStdHandle (STD_INPUT_HANDLE);
 748 }
 749
 750 HANDLE
 751 ves_icall_System_IO_MonoIO_get_ConsoleError ()
 752 {
 753         MONO_ARCH_SAVE_REGS;
 754
 755         return GetStdHandle (STD_ERROR_HANDLE);
 756 }
 757
 758 MonoBoolean
 759 ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle,
 760                                        HANDLE *write_handle)
 761 {
 762         SECURITY_ATTRIBUTES attr;
 763         gboolean ret;
 764
 765         MONO_ARCH_SAVE_REGS;
 766
 767         attr.nLength=sizeof(SECURITY_ATTRIBUTES);
 768         attr.bInheritHandle=TRUE;
 769         attr.lpSecurityDescriptor=NULL;
 770
 771         ret=CreatePipe (read_handle, write_handle, &attr, 0);
 772         if(ret==FALSE) {
 773                 /* FIXME: throw an exception? */
 774                 return(FALSE);
 775         }
 776
 777         return(TRUE);
 778 }
 779
 780 gunichar2
 781 ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar ()
 782 {
 783         MONO_ARCH_SAVE_REGS;
 784
 785 #if defined (PLATFORM_WIN32)
 786         return (gunichar2) 0x003a;      /* colon */
 787 #else
 788         return (gunichar2) 0x002f;      /* forward slash */
 789 #endif
 790 }
 791
 792 gunichar2
 793 ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar ()
 794 {
 795         MONO_ARCH_SAVE_REGS;
 796
 797 #if defined (PLATFORM_WIN32)
 798         return (gunichar2) 0x005c;      /* backslash */
 799 #else
 800         return (gunichar2) 0x002f;      /* forward slash */
 801 #endif
 802 }
 803
 804 gunichar2
 805 ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar ()
 806 {
 807         MONO_ARCH_SAVE_REGS;
 808
 809 #if defined (PLATFORM_WIN32)
 810         return (gunichar2) 0x002f;      /* forward slash */
 811 #else
 812         return (gunichar2) 0x005c;      /* backslash */
 813 #endif
 814 }
 815
 816 gunichar2
 817 ves_icall_System_IO_MonoIO_get_PathSeparator ()
 818 {
 819         MONO_ARCH_SAVE_REGS;
 820
 821 #if defined (PLATFORM_WIN32)
 822         return (gunichar2) 0x003b;      /* semicolon */
 823 #else
 824         return (gunichar2) 0x003a;      /* colon */
 825 #endif
 826 }
 827
 828 static gunichar2 invalid_path_chars [] = {
 829 #if defined (PLATFORM_WIN32)
 830         0x0022,                         /* double quote, which seems allowed in MS.NET but should be rejected */
 831         0x003c,                         /* less than */
 832         0x003e,                         /* greater than */
 833         0x007c,                         /* pipe */
 834         0x0008,
 835         0x0010,
 836         0x0011,
 837         0x0012,
 838         0x0014,
 839         0x0015,
 840         0x0016,
 841         0x0017,
 842         0x0018,
 843         0x0019,
 844 #endif
 845         0x0000                          /* null */
 846 };
 847
 848 MonoArray *
 849 ves_icall_System_IO_MonoIO_get_InvalidPathChars ()
 850 {
 851         MonoArray *chars;
 852         MonoDomain *domain;
 853         int i, n;
 854
 855         MONO_ARCH_SAVE_REGS;
 856
 857         domain = mono_domain_get ();
 858         chars = mono_array_new (domain, mono_defaults.char_class, 15);
 859
 860         n = sizeof (invalid_path_chars) / sizeof (gunichar2);
 861
 862         for (i = 0; i < n; ++ i)
 863                 mono_array_set (chars, gunichar2, i, invalid_path_chars [i]);
 864
 865         return chars;
 866 }
 867
 868 gint32
 869 ves_icall_System_IO_MonoIO_GetTempPath (MonoString **mono_name)
 870 {
 871         gunichar2 *name;
 872         int ret;
 873
 874         name=g_new0 (gunichar2, 256);
 875
 876         ret=GetTempPath (256, name);
 877         if(ret>255) {
 878                 /* Buffer was too short. Try again... */
 879                 g_free (name);
 880                 name=g_new0 (gunichar2, ret+2); /* include the terminator */
 881                 ret=GetTempPath (ret, name);
 882         }
 883
 884         if(ret>0) {
 885 #ifdef DEBUG
 886                 g_message (G_GNUC_PRETTY_FUNCTION
 887                            ": Temp path is [%s] (len %d)", name, ret);
 888 #endif
 889
 890                 *mono_name=mono_string_new_utf16 (mono_domain_get (), name,
 891                                                   ret);
 892         }
 893
 894         g_free (name);
 895
 896         return(ret);
 897 }
 898
 899 /*
 900  * Asynchronous IO
 901  */
 902 MonoBoolean
 903 ves_icall_System_IO_MonoIO_GetSupportsAsync (void)
 904 {
 905         MONO_ARCH_SAVE_REGS;
 906
 907 #ifdef PLATFORM_WIN32
 908         /* Seems like BindIoCompletionCallback is not found when compiling...
 909          * Disabling AIO support on win. Any one wants to fix this?
 910          */
 911         return FALSE;
 912         /* return (g_getenv ("MONO_DISABLE_AIO") == NULL && WINVER >= 0x500); */
 913 #elif defined(USE_AIO)
 914         if (aio_cancel (-1, NULL) == -1 && errno == ENOSYS)
 915                 return FALSE;
 916
 917         return (g_getenv ("MONO_DISABLE_AIO") == NULL);
 918 #else
 919         return FALSE;
 920 #endif
 921 }
 922
 923 static WapiOverlapped *
 924 get_overlapped_from_fsa (MonoFSAsyncResult *ares)
 925 {
 926         WapiOverlapped *ovl;
 927
 928         ovl = g_new0 (WapiOverlapped, 1);
 929         ovl->Offset = ares->offset;
 930         ovl->hEvent = ares->wait_handle;
 931
 932         return ovl;
 933 }
 934
 935 MonoBoolean
 936 ves_icall_System_IO_MonoIO_BeginRead (HANDLE handle, MonoFSAsyncResult *ares)
 937 {
 938         guint32 bytesread;
 939         WapiOverlapped *ovl;
 940
 941         MONO_ARCH_SAVE_REGS;
 942
 943         ovl = get_overlapped_from_fsa (ares);
 944         ovl->handle1 = ares;
 945         return ReadFile (handle, mono_array_addr (ares->buffer, gchar, ares->offset), ares->count, &bytesread, ovl);
 946 }
 947
 948 MonoBoolean
 949 ves_icall_System_IO_MonoIO_BeginWrite (HANDLE handle, MonoFSAsyncResult *ares)
 950 {
 951         guint32 byteswritten;
 952         WapiOverlapped *ovl;
 953
 954         MONO_ARCH_SAVE_REGS;
 955
 956         ovl = get_overlapped_from_fsa (ares);
 957         ovl->handle1 = ares;
 958         return WriteFile (handle, mono_array_addr (ares->buffer, gchar, ares->offset), ares->count, &byteswritten, ovl);
 959 }
 960