mono/metadata/file-io.c

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