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         gboolean r = TRUE;
 252
 253         MONO_ARCH_SAVE_REGS;
 254
 255         *error=ERROR_SUCCESS;
 256
 257         result = FindFirstFile (mono_string_chars (path), &data);
 258
 259         /* note: WIN32_FIND_DATA is an extension of WIN32_FILE_ATTRIBUTE_DATA */
 260         while (result != INVALID_HANDLE_VALUE && r) {
 261                 if ((data.cFileName [0] == '.' && data.cFileName [1] == 0) ||
 262                     (data.cFileName [0] == '.' && data.cFileName [1] == '.' && data.cFileName [2] == 0)) {
 263                         r = FindNextFile (result, &data);
 264                 } else {
 265                         convert_win32_file_attribute_data ((const WIN32_FILE_ATTRIBUTE_DATA *)&data,
 266                                                            &data.cFileName [0], stat);
 267                         break;
 268                 }
 269         }
 270
 271         if (result == INVALID_HANDLE_VALUE) {
 272                 *error=GetLastError ();
 273         }
 274
 275         return result;
 276 }
 277
 278 MonoBoolean
 279 ves_icall_System_IO_MonoIO_FindNextFile (HANDLE find, MonoIOStat *stat,
 280                                          gint32 *error)
 281 {
 282         WIN32_FIND_DATA data;
 283         gboolean result;
 284
 285         MONO_ARCH_SAVE_REGS;
 286
 287         *error=ERROR_SUCCESS;
 288
 289         result = FindNextFile (find, &data);
 290         while (result != FALSE) {
 291                 if ((data.cFileName [0] == '.' && data.cFileName [1] == 0) ||
 292                     (data.cFileName [0] == '.' && data.cFileName [1] == '.' && data.cFileName [2] == 0)) {
 293                         result = FindNextFile (find, &data);
 294                 } else {
 295                         convert_win32_file_attribute_data ((const WIN32_FILE_ATTRIBUTE_DATA *)&data,
 296                                                            &data.cFileName [0], stat);
 297                         break;
 298                 }
 299         }
 300
 301         if (result == FALSE) {
 302                 *error=GetLastError ();
 303         }
 304
 305         return result;
 306 }
 307
 308 MonoBoolean
 309 ves_icall_System_IO_MonoIO_FindClose (HANDLE find, gint32 *error)
 310 {
 311         gboolean ret;
 312
 313         MONO_ARCH_SAVE_REGS;
 314
 315         *error=ERROR_SUCCESS;
 316
 317         ret=FindClose (find);
 318         if(ret==FALSE) {
 319                 *error=GetLastError ();
 320         }
 321
 322         return(ret);
 323 }
 324
 325 MonoString *
 326 ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *error)
 327 {
 328         MonoString *result;
 329         gunichar2 *buf;
 330         int len;
 331
 332         MONO_ARCH_SAVE_REGS;
 333
 334         len = MAX_PATH + 1;
 335         buf = g_new (gunichar2, len);
 336
 337         *error=ERROR_SUCCESS;
 338         result = NULL;
 339
 340         if (GetCurrentDirectory (len, buf) > 0) {
 341                 len = 0;
 342                 while (buf [len])
 343                         ++ len;
 344
 345                 result = mono_string_new_utf16 (mono_domain_get (), buf, len);
 346         } else {
 347                 *error=GetLastError ();
 348         }
 349
 350         g_free (buf);
 351         return result;
 352 }
 353
 354 MonoBoolean
 355 ves_icall_System_IO_MonoIO_SetCurrentDirectory (MonoString *path,
 356                                                 gint32 *error)
 357 {
 358         gboolean ret;
 359
 360         MONO_ARCH_SAVE_REGS;
 361
 362         *error=ERROR_SUCCESS;
 363
 364         ret=SetCurrentDirectory (mono_string_chars (path));
 365         if(ret==FALSE) {
 366                 *error=GetLastError ();
 367         }
 368
 369         return(ret);
 370 }
 371
 372 MonoBoolean
 373 ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
 374                                      gint32 *error)
 375 {
 376         gboolean ret;
 377
 378         MONO_ARCH_SAVE_REGS;
 379
 380         *error=ERROR_SUCCESS;
 381
 382         ret=MoveFile (mono_string_chars (path), mono_string_chars (dest));
 383         if(ret==FALSE) {
 384                 *error=GetLastError ();
 385         }
 386
 387         return(ret);
 388 }
 389
 390 MonoBoolean
 391 ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
 392                                      MonoBoolean overwrite, gint32 *error)
 393 {
 394         gboolean ret;
 395
 396         MONO_ARCH_SAVE_REGS;
 397
 398         *error=ERROR_SUCCESS;
 399
 400         ret=CopyFile (mono_string_chars (path), mono_string_chars (dest), !overwrite);
 401         if(ret==FALSE) {
 402                 *error=GetLastError ();
 403         }
 404
 405         return(ret);
 406 }
 407
 408 MonoBoolean
 409 ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
 410 {
 411         gboolean ret;
 412
 413         MONO_ARCH_SAVE_REGS;
 414
 415         *error=ERROR_SUCCESS;
 416
 417         ret=DeleteFile (mono_string_chars (path));
 418         if(ret==FALSE) {
 419                 *error=GetLastError ();
 420         }
 421
 422         return(ret);
 423 }
 424
 425 gint32
 426 ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
 427 {
 428         gint32 ret;
 429
 430         MONO_ARCH_SAVE_REGS;
 431
 432         *error=ERROR_SUCCESS;
 433
 434         ret=GetFileAttributes (mono_string_chars (path));
 435
 436         /*
 437          * The definition of INVALID_FILE_ATTRIBUTES in the cygwin win32
 438          * headers is wrong, hence this temporary workaround.
 439          * See
 440          * http://cygwin.com/ml/cygwin/2003-09/msg01771.html
 441          */
 442         if (ret==-1) {
 443 //      if(ret==INVALID_FILE_ATTRIBUTES) {
 444                 *error=GetLastError ();
 445         }
 446
 447         return(ret);
 448 }
 449
 450 MonoBoolean
 451 ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
 452                                               gint32 *error)
 453 {
 454         gboolean ret;
 455
 456         MONO_ARCH_SAVE_REGS;
 457
 458         *error=ERROR_SUCCESS;
 459
 460         ret=SetFileAttributes (mono_string_chars (path),
 461                                convert_attrs (attrs));
 462         if(ret==FALSE) {
 463                 *error=GetLastError ();
 464         }
 465
 466         return(ret);
 467 }
 468
 469 gint32
 470 ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
 471 {
 472         gboolean ret;
 473
 474         MONO_ARCH_SAVE_REGS;
 475
 476         *error=ERROR_SUCCESS;
 477
 478         ret=GetFileType (handle);
 479         if(ret==FILE_TYPE_UNKNOWN) {
 480                 /* Not necessarily an error, but the caller will have
 481                  * to decide based on the error value.
 482                  */
 483                 *error=GetLastError ();
 484         }
 485
 486         return(ret);
 487 }
 488
 489 MonoBoolean
 490 ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
 491                                         gint32 *error)
 492 {
 493         gboolean result;
 494         WIN32_FILE_ATTRIBUTE_DATA data;
 495
 496         MONO_ARCH_SAVE_REGS;
 497
 498         *error=ERROR_SUCCESS;
 499
 500         result = GetFileAttributesEx (mono_string_chars (path), GetFileExInfoStandard, &data);
 501
 502         if (result) {
 503                 convert_win32_file_attribute_data (&data,
 504                                                    mono_string_chars (path),
 505                                                    stat);
 506         } else {
 507                 *error=GetLastError ();
 508         }
 509
 510         return result;
 511 }
 512
 513 HANDLE
 514 ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode,
 515                                  gint32 access_mode, gint32 share,
 516                                  MonoBoolean async, gint32 *error)
 517 {
 518         HANDLE ret;
 519
 520         MONO_ARCH_SAVE_REGS;
 521
 522         *error=ERROR_SUCCESS;
 523
 524         ret=CreateFile (mono_string_chars (filename),
 525                         convert_access (access_mode), convert_share (share),
 526                         NULL, convert_mode (mode),
 527                         FILE_ATTRIBUTE_NORMAL | ((async) ? FILE_FLAG_OVERLAPPED : 0),
 528                         NULL);
 529         if(ret==INVALID_HANDLE_VALUE) {
 530                 *error=GetLastError ();
 531         }
 532
 533         return(ret);
 534 }
 535
 536 MonoBoolean
 537 ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
 538 {
 539         gboolean ret;
 540
 541         MONO_ARCH_SAVE_REGS;
 542
 543         *error=ERROR_SUCCESS;
 544
 545         ret=CloseHandle (handle);
 546         if(ret==FALSE) {
 547                 *error=GetLastError ();
 548         }
 549
 550         return(ret);
 551 }
 552
 553 gint32
 554 ves_icall_System_IO_MonoIO_Read (HANDLE handle, MonoArray *dest,
 555                                  gint32 dest_offset, gint32 count,
 556                                  gint32 *error)
 557 {
 558         guchar *buffer;
 559         gboolean result;
 560         guint32 n;
 561
 562         MONO_ARCH_SAVE_REGS;
 563
 564         *error=ERROR_SUCCESS;
 565
 566         if (dest_offset + count > mono_array_length (dest))
 567                 return 0;
 568
 569         buffer = mono_array_addr (dest, guchar, dest_offset);
 570         result = ReadFile (handle, buffer, count, &n, NULL);
 571
 572         if (!result) {
 573                 *error=GetLastError ();
 574                 return -1;
 575         }
 576
 577         return (gint32)n;
 578 }
 579
 580 gint32
 581 ves_icall_System_IO_MonoIO_Write (HANDLE handle, MonoArray *src,
 582                                   gint32 src_offset, gint32 count,
 583                                   gint32 *error)
 584 {
 585         guchar *buffer;
 586         gboolean result;
 587         guint32 n;
 588
 589         MONO_ARCH_SAVE_REGS;
 590
 591         *error=ERROR_SUCCESS;
 592
 593         if (src_offset + count > mono_array_length (src))
 594                 return 0;
 595
 596         buffer = mono_array_addr (src, guchar, src_offset);
 597         result = WriteFile (handle, buffer, count, &n, NULL);
 598
 599         if (!result) {
 600                 *error=GetLastError ();
 601                 return -1;
 602         }
 603
 604         return (gint32)n;
 605 }
 606
 607 gint64
 608 ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
 609                                  gint32 *error)
 610 {
 611         guint32 offset_hi;
 612
 613         MONO_ARCH_SAVE_REGS;
 614
 615         *error=ERROR_SUCCESS;
 616
 617         offset_hi = offset >> 32;
 618         offset = SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
 619                                  convert_seekorigin (origin));
 620
 621         if(offset==INVALID_SET_FILE_POINTER) {
 622                 *error=GetLastError ();
 623         }
 624
 625         return offset | ((gint64)offset_hi << 32);
 626 }
 627
 628 MonoBoolean
 629 ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
 630 {
 631         gboolean ret;
 632
 633         MONO_ARCH_SAVE_REGS;
 634
 635         *error=ERROR_SUCCESS;
 636
 637         ret=FlushFileBuffers (handle);
 638         if(ret==FALSE) {
 639                 *error=GetLastError ();
 640         }
 641
 642         return(ret);
 643 }
 644
 645 gint64
 646 ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
 647 {
 648         gint64 length;
 649         guint32 length_hi;
 650
 651         MONO_ARCH_SAVE_REGS;
 652
 653         *error=ERROR_SUCCESS;
 654
 655         length = GetFileSize (handle, &length_hi);
 656         if(length==INVALID_FILE_SIZE) {
 657                 *error=GetLastError ();
 658         }
 659
 660         return length | ((gint64)length_hi << 32);
 661 }
 662
 663 MonoBoolean
 664 ves_icall_System_IO_MonoIO_SetLength (HANDLE handle, gint64 length,
 665                                       gint32 *error)
 666 {
 667         gint64 offset, offset_set;
 668         gint32 offset_hi;
 669         gint32 length_hi;
 670         gboolean result;
 671
 672         MONO_ARCH_SAVE_REGS;
 673
 674         *error=ERROR_SUCCESS;
 675
 676         /* save file pointer */
 677
 678         offset_hi = 0;
 679         offset = SetFilePointer (handle, 0, &offset_hi, FILE_CURRENT);
 680         if(offset==INVALID_SET_FILE_POINTER) {
 681                 *error=GetLastError ();
 682                 return(FALSE);
 683         }
 684
 685         /* extend or truncate */
 686
 687         length_hi = length >> 32;
 688         offset_set=SetFilePointer (handle, length & 0xFFFFFFFF, &length_hi,
 689                                    FILE_BEGIN);
 690         if(offset_set==INVALID_SET_FILE_POINTER) {
 691                 *error=GetLastError ();
 692                 return(FALSE);
 693         }
 694
 695         result = SetEndOfFile (handle);
 696         if(result==FALSE) {
 697                 *error=GetLastError ();
 698                 return(FALSE);
 699         }
 700
 701         /* restore file pointer */
 702
 703         offset_set=SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
 704                                    FILE_BEGIN);
 705         if(offset_set==INVALID_SET_FILE_POINTER) {
 706                 *error=GetLastError ();
 707                 return(FALSE);
 708         }
 709
 710         return result;
 711 }
 712
 713 MonoBoolean
 714 ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time,
 715                                         gint64 last_access_time,
 716                                         gint64 last_write_time, gint32 *error)
 717 {
 718         gboolean ret;
 719         const FILETIME *creation_filetime;
 720         const FILETIME *last_access_filetime;
 721         const FILETIME *last_write_filetime;
 722
 723         MONO_ARCH_SAVE_REGS;
 724
 725         *error=ERROR_SUCCESS;
 726
 727         if (creation_time < 0)
 728                 creation_filetime = NULL;
 729         else
 730                 creation_filetime = (FILETIME *)&creation_time;
 731
 732         if (last_access_time < 0)
 733                 last_access_filetime = NULL;
 734         else
 735                 last_access_filetime = (FILETIME *)&last_access_time;
 736
 737         if (last_write_time < 0)
 738                 last_write_filetime = NULL;
 739         else
 740                 last_write_filetime = (FILETIME *)&last_write_time;
 741
 742         ret=SetFileTime (handle, creation_filetime, last_access_filetime, last_write_filetime);
 743         if(ret==FALSE) {
 744                 *error=GetLastError ();
 745         }
 746
 747         return(ret);
 748 }
 749
 750 HANDLE
 751 ves_icall_System_IO_MonoIO_get_ConsoleOutput ()
 752 {
 753         MONO_ARCH_SAVE_REGS;
 754
 755         return GetStdHandle (STD_OUTPUT_HANDLE);
 756 }
 757
 758 HANDLE
 759 ves_icall_System_IO_MonoIO_get_ConsoleInput ()
 760 {
 761         MONO_ARCH_SAVE_REGS;
 762
 763         return GetStdHandle (STD_INPUT_HANDLE);
 764 }
 765
 766 HANDLE
 767 ves_icall_System_IO_MonoIO_get_ConsoleError ()
 768 {
 769         MONO_ARCH_SAVE_REGS;
 770
 771         return GetStdHandle (STD_ERROR_HANDLE);
 772 }
 773
 774 MonoBoolean
 775 ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle,
 776                                        HANDLE *write_handle)
 777 {
 778         SECURITY_ATTRIBUTES attr;
 779         gboolean ret;
 780
 781         MONO_ARCH_SAVE_REGS;
 782
 783         attr.nLength=sizeof(SECURITY_ATTRIBUTES);
 784         attr.bInheritHandle=TRUE;
 785         attr.lpSecurityDescriptor=NULL;
 786
 787         ret=CreatePipe (read_handle, write_handle, &attr, 0);
 788         if(ret==FALSE) {
 789                 /* FIXME: throw an exception? */
 790                 return(FALSE);
 791         }
 792
 793         return(TRUE);
 794 }
 795
 796 gunichar2
 797 ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar ()
 798 {
 799         MONO_ARCH_SAVE_REGS;
 800
 801 #if defined (PLATFORM_WIN32)
 802         return (gunichar2) 0x003a;      /* colon */
 803 #else
 804         return (gunichar2) 0x002f;      /* forward slash */
 805 #endif
 806 }
 807
 808 gunichar2
 809 ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar ()
 810 {
 811         MONO_ARCH_SAVE_REGS;
 812
 813 #if defined (PLATFORM_WIN32)
 814         return (gunichar2) 0x005c;      /* backslash */
 815 #else
 816         return (gunichar2) 0x002f;      /* forward slash */
 817 #endif
 818 }
 819
 820 gunichar2
 821 ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar ()
 822 {
 823         MONO_ARCH_SAVE_REGS;
 824
 825 #if defined (PLATFORM_WIN32)
 826         return (gunichar2) 0x002f;      /* forward slash */
 827 #else
 828         return (gunichar2) 0x005c;      /* backslash */
 829 #endif
 830 }
 831
 832 gunichar2
 833 ves_icall_System_IO_MonoIO_get_PathSeparator ()
 834 {
 835         MONO_ARCH_SAVE_REGS;
 836
 837 #if defined (PLATFORM_WIN32)
 838         return (gunichar2) 0x003b;      /* semicolon */
 839 #else
 840         return (gunichar2) 0x003a;      /* colon */
 841 #endif
 842 }
 843
 844 static gunichar2 invalid_path_chars [] = {
 845 #if defined (PLATFORM_WIN32)
 846         0x0022,                         /* double quote, which seems allowed in MS.NET but should be rejected */
 847         0x003c,                         /* less than */
 848         0x003e,                         /* greater than */
 849         0x007c,                         /* pipe */
 850         0x0008,
 851         0x0010,
 852         0x0011,
 853         0x0012,
 854         0x0014,
 855         0x0015,
 856         0x0016,
 857         0x0017,
 858         0x0018,
 859         0x0019,
 860 #endif
 861         0x0000                          /* null */
 862 };
 863
 864 MonoArray *
 865 ves_icall_System_IO_MonoIO_get_InvalidPathChars ()
 866 {
 867         MonoArray *chars;
 868         MonoDomain *domain;
 869         int i, n;
 870
 871         MONO_ARCH_SAVE_REGS;
 872
 873         domain = mono_domain_get ();
 874         chars = mono_array_new (domain, mono_defaults.char_class, 15);
 875
 876         n = sizeof (invalid_path_chars) / sizeof (gunichar2);
 877
 878         for (i = 0; i < n; ++ i)
 879                 mono_array_set (chars, gunichar2, i, invalid_path_chars [i]);
 880
 881         return chars;
 882 }
 883
 884 gint32
 885 ves_icall_System_IO_MonoIO_GetTempPath (MonoString **mono_name)
 886 {
 887         gunichar2 *name;
 888         int ret;
 889
 890         name=g_new0 (gunichar2, 256);
 891
 892         ret=GetTempPath (256, name);
 893         if(ret>255) {
 894                 /* Buffer was too short. Try again... */
 895                 g_free (name);
 896                 name=g_new0 (gunichar2, ret+2); /* include the terminator */
 897                 ret=GetTempPath (ret, name);
 898         }
 899
 900         if(ret>0) {
 901 #ifdef DEBUG
 902                 g_message (G_GNUC_PRETTY_FUNCTION
 903                            ": Temp path is [%s] (len %d)", name, ret);
 904 #endif
 905
 906                 *mono_name=mono_string_new_utf16 (mono_domain_get (), name,
 907                                                   ret);
 908         }
 909
 910         g_free (name);
 911
 912         return(ret);
 913 }
 914
 915 /*
 916  * Asynchronous IO
 917  */
 918 MonoBoolean
 919 ves_icall_System_IO_MonoIO_GetSupportsAsync (void)
 920 {
 921         MONO_ARCH_SAVE_REGS;
 922
 923 #ifdef PLATFORM_WIN32
 924         /* Seems like BindIoCompletionCallback is not found when compiling...
 925          * Disabling AIO support on win. Any one wants to fix this?
 926          */
 927         return FALSE;
 928         /* return (g_getenv ("MONO_DISABLE_AIO") == NULL && WINVER >= 0x500); */
 929 #elif defined(USE_AIO)
 930         if (aio_cancel (-1, NULL) == -1 && errno == ENOSYS)
 931                 return FALSE;
 932
 933         return (g_getenv ("MONO_DISABLE_AIO") == NULL);
 934 #else
 935         return FALSE;
 936 #endif
 937 }
 938
 939 static WapiOverlapped *
 940 get_overlapped_from_fsa (MonoFSAsyncResult *ares)
 941 {
 942         WapiOverlapped *ovl;
 943
 944         ovl = g_new0 (WapiOverlapped, 1);
 945         ovl->Offset = ares->offset;
 946         ovl->hEvent = ares->wait_handle;
 947
 948         return ovl;
 949 }
 950
 951 MonoBoolean
 952 ves_icall_System_IO_MonoIO_BeginRead (HANDLE handle, MonoFSAsyncResult *ares)
 953 {
 954         guint32 bytesread;
 955         WapiOverlapped *ovl;
 956
 957         MONO_ARCH_SAVE_REGS;
 958
 959         ovl = get_overlapped_from_fsa (ares);
 960         ovl->handle1 = ares;
 961         return ReadFile (handle, mono_array_addr (ares->buffer, gchar, ares->offset), ares->count, &bytesread, ovl);
 962 }
 963
 964 MonoBoolean
 965 ves_icall_System_IO_MonoIO_BeginWrite (HANDLE handle, MonoFSAsyncResult *ares)
 966 {
 967         guint32 byteswritten;
 968         WapiOverlapped *ovl;
 969
 970         MONO_ARCH_SAVE_REGS;
 971
 972         ovl = get_overlapped_from_fsa (ares);
 973         ovl->handle1 = ares;
 974         return WriteFile (handle, mono_array_addr (ares->buffer, gchar, ares->offset), ares->count, &byteswritten, ovl);
 975 }
 976
 977 void ves_icall_System_IO_MonoIO_Lock (HANDLE handle, gint64 position,
 978                                       gint64 length, gint32 *error)
 979 {
 980         gboolean ret;
 981
 982         *error=ERROR_SUCCESS;
 983
 984         ret=LockFile (handle, position & 0xFFFFFFFF, position >> 32,
 985                       length & 0xFFFFFFFF, length >> 32);
 986         if (ret == FALSE) {
 987                 *error = GetLastError ();
 988         }
 989 }
 990
 991 void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position,
 992                                         gint64 length, gint32 *error)
 993 {
 994         gboolean ret;
 995
 996         *error=ERROR_SUCCESS;
 997
 998         ret=UnlockFile (handle, position & 0xFFFFFFFF, position >> 32,
 999                         length & 0xFFFFFFFF, length >> 32);
1000         if (ret == FALSE) {
1001                 *error = GetLastError ();
1002         }
1003 }
1004