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 #include <unistd.h>
  18 #ifdef HAVE_SYS_STAT_H
  19 #include <sys/stat.h>
  20 #endif
  21 #ifdef HAVE_SYS_TYPES_H
  22 #include <sys/types.h>
  23 #endif
  24
  25 #include <mono/metadata/object.h>
  26 #include <mono/io-layer/io-layer.h>
  27 #include <mono/metadata/file-io.h>
  28 #include <mono/metadata/exception.h>
  29 #include <mono/metadata/appdomain.h>
  30 #include <mono/metadata/marshal.h>
  31 #include <mono/utils/strenc.h>
  32
  33 #undef DEBUG
  34
  35 /* conversion functions */
  36
  37 static guint32 convert_mode(MonoFileMode mono_mode)
  38 {
  39         guint32 mode;
  40
  41         switch(mono_mode) {
  42         case FileMode_CreateNew:
  43                 mode=CREATE_NEW;
  44                 break;
  45         case FileMode_Create:
  46                 mode=CREATE_ALWAYS;
  47                 break;
  48         case FileMode_Open:
  49                 mode=OPEN_EXISTING;
  50                 break;
  51         case FileMode_OpenOrCreate:
  52                 mode=OPEN_ALWAYS;
  53                 break;
  54         case FileMode_Truncate:
  55                 mode=TRUNCATE_EXISTING;
  56                 break;
  57         case FileMode_Append:
  58                 mode=OPEN_ALWAYS;
  59                 break;
  60         default:
  61                 g_warning("System.IO.FileMode has unknown value 0x%x",
  62                           mono_mode);
  63                 /* Safe fallback */
  64                 mode=OPEN_EXISTING;
  65         }
  66
  67         return(mode);
  68 }
  69
  70 static guint32 convert_access(MonoFileAccess mono_access)
  71 {
  72         guint32 access;
  73
  74         switch(mono_access) {
  75         case FileAccess_Read:
  76                 access=GENERIC_READ;
  77                 break;
  78         case FileAccess_Write:
  79                 access=GENERIC_WRITE;
  80                 break;
  81         case FileAccess_ReadWrite:
  82                 access=GENERIC_READ|GENERIC_WRITE;
  83                 break;
  84         default:
  85                 g_warning("System.IO.FileAccess has unknown value 0x%x",
  86                           mono_access);
  87                 /* Safe fallback */
  88                 access=GENERIC_READ;
  89         }
  90
  91         return(access);
  92 }
  93
  94 static guint32 convert_share(MonoFileShare mono_share)
  95 {
  96         guint32 share;
  97
  98         switch(mono_share) {
  99         case FileShare_None:
 100                 share=0;
 101                 break;
 102         case FileShare_Read:
 103                 share=FILE_SHARE_READ;
 104                 break;
 105         case FileShare_Write:
 106                 share=FILE_SHARE_WRITE;
 107                 break;
 108         case FileShare_ReadWrite:
 109                 share=FILE_SHARE_READ|FILE_SHARE_WRITE;
 110                 break;
 111         default:
 112                 g_warning("System.IO.FileShare has unknown value 0x%x",
 113                           mono_share);
 114                 /* Safe fallback */
 115                 share=0;
 116         }
 117
 118         return(share);
 119 }
 120
 121 #if 0
 122 static guint32 convert_stdhandle(guint32 fd)
 123 {
 124         guint32 stdhandle;
 125
 126         switch(fd) {
 127         case 0:
 128                 stdhandle=STD_INPUT_HANDLE;
 129                 break;
 130         case 1:
 131                 stdhandle=STD_OUTPUT_HANDLE;
 132                 break;
 133         case 2:
 134                 stdhandle=STD_ERROR_HANDLE;
 135                 break;
 136         default:
 137                 g_warning("unknown standard file descriptor %d", fd);
 138                 stdhandle=STD_INPUT_HANDLE;
 139         }
 140
 141         return(stdhandle);
 142 }
 143 #endif
 144
 145 static guint32 convert_seekorigin(MonoSeekOrigin origin)
 146 {
 147         guint32 w32origin;
 148
 149         switch(origin) {
 150         case SeekOrigin_Begin:
 151                 w32origin=FILE_BEGIN;
 152                 break;
 153         case SeekOrigin_Current:
 154                 w32origin=FILE_CURRENT;
 155                 break;
 156         case SeekOrigin_End:
 157                 w32origin=FILE_END;
 158                 break;
 159         default:
 160                 g_warning("System.IO.SeekOrigin has unknown value 0x%x",
 161                           origin);
 162                 /* Safe fallback */
 163                 w32origin=FILE_CURRENT;
 164         }
 165
 166         return(w32origin);
 167 }
 168
 169 static gint64 convert_filetime (const FILETIME *filetime)
 170 {
 171         guint64 ticks = filetime->dwHighDateTime;
 172         ticks <<= 32;
 173         ticks += filetime->dwLowDateTime;
 174         return (gint64)ticks;
 175 }
 176
 177 static void convert_win32_file_attribute_data (const WIN32_FILE_ATTRIBUTE_DATA *data, const gunichar2 *name, MonoIOStat *stat)
 178 {
 179         int len;
 180
 181         stat->attributes = data->dwFileAttributes;
 182         stat->creation_time = convert_filetime (&data->ftCreationTime);
 183         stat->last_access_time = convert_filetime (&data->ftLastAccessTime);
 184         stat->last_write_time = convert_filetime (&data->ftLastWriteTime);
 185         stat->length = ((gint64)data->nFileSizeHigh << 32) | data->nFileSizeLow;
 186
 187         len = 0;
 188         while (name [len])
 189                 ++ len;
 190
 191         stat->name = mono_string_new_utf16 (mono_domain_get (), name, len);
 192 }
 193
 194 /* Managed file attributes have nearly but not quite the same values
 195  * as the w32 equivalents.
 196  */
 197 static guint32 convert_attrs(MonoFileAttributes attrs)
 198 {
 199         if(attrs & FileAttributes_Encrypted) {
 200                 attrs |= FILE_ATTRIBUTE_ENCRYPTED;
 201         }
 202
 203         return(attrs);
 204 }
 205
 206 /* System.IO.MonoIO internal calls */
 207
 208 MonoBoolean
 209 ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error)
 210 {
 211         gboolean ret;
 212
 213         MONO_ARCH_SAVE_REGS;
 214
 215         *error=ERROR_SUCCESS;
 216
 217         ret=CreateDirectory (mono_string_chars (path), NULL);
 218         if(ret==FALSE) {
 219                 *error=GetLastError ();
 220         }
 221
 222         return(ret);
 223 }
 224
 225 MonoBoolean
 226 ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error)
 227 {
 228         gboolean ret;
 229
 230         MONO_ARCH_SAVE_REGS;
 231
 232         *error=ERROR_SUCCESS;
 233
 234         ret=RemoveDirectory (mono_string_chars (path));
 235         if(ret==FALSE) {
 236                 *error=GetLastError ();
 237         }
 238
 239         return(ret);
 240 }
 241
 242 static gint
 243 get_error_from_g_file_error (gint error)
 244 {
 245         switch (error) {
 246         case G_FILE_ERROR_ACCES:
 247                 error = ERROR_ACCESS_DENIED;
 248                 break;
 249         case G_FILE_ERROR_NAMETOOLONG:
 250                 error = ERROR_FILENAME_EXCED_RANGE;
 251                 break;
 252         case G_FILE_ERROR_NOENT:
 253                 error = ERROR_FILE_NOT_FOUND;
 254                 break;
 255         case G_FILE_ERROR_NOTDIR:
 256                 error = ERROR_FILE_NOT_FOUND;
 257                 break;
 258         case G_FILE_ERROR_ROFS:
 259                 error = ERROR_ACCESS_DENIED;
 260                 break;
 261         case G_FILE_ERROR_TXTBSY:
 262                 error = ERROR_SHARING_VIOLATION;
 263                 break;
 264         case G_FILE_ERROR_NOSPC:
 265                 error = ERROR_HANDLE_DISK_FULL;
 266                 break;
 267         case G_FILE_ERROR_NFILE:
 268         case G_FILE_ERROR_MFILE:
 269                 error = ERROR_TOO_MANY_OPEN_FILES;
 270                 break;
 271         case G_FILE_ERROR_BADF:
 272                 error = ERROR_INVALID_HANDLE;
 273                 break;
 274         case G_FILE_ERROR_INVAL:
 275                 error = ERROR_INVALID_PARAMETER;
 276                 break;
 277         case G_FILE_ERROR_AGAIN:
 278                 error = ERROR_SHARING_VIOLATION;
 279                 break;
 280         case G_FILE_ERROR_INTR:
 281                 error = ERROR_IO_PENDING;
 282                 break;
 283         case G_FILE_ERROR_PERM:
 284                 error = ERROR_ACCESS_DENIED;
 285                 break;
 286         case G_FILE_ERROR_FAILED:
 287                 error = ERROR_INVALID_PARAMETER;
 288                 break;
 289         case G_FILE_ERROR_NXIO:
 290         case G_FILE_ERROR_NOMEM:
 291         case G_FILE_ERROR_NODEV:
 292         case G_FILE_ERROR_FAULT:
 293         case G_FILE_ERROR_LOOP:
 294         case G_FILE_ERROR_PIPE:
 295         case G_FILE_ERROR_IO:
 296         default:
 297                 error = ERROR_GEN_FAILURE;
 298                 break;
 299
 300         }
 301
 302         return error;
 303 }
 304
 305 static gint
 306 file_compare (gconstpointer a, gconstpointer b)
 307 {
 308         gchar *astr = *(gchar **) a;
 309         gchar *bstr = *(gchar **) b;
 310
 311         return strcmp (astr, bstr);
 312 }
 313
 314 static gint
 315 get_file_attributes (const char *filename)
 316 {
 317 #ifdef PLATFORM_WIN32
 318         gunichar2 *full16;
 319         gint result;
 320
 321         full16 = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
 322         if (full16 == NULL) {
 323                 g_message ("Bad encoding for '%s'\n", filename);
 324                 return FALSE;
 325         }
 326
 327         result = GetFileAttributes (full16);
 328         g_free (full16);
 329         return result;
 330 #else
 331         struct stat buf;
 332         struct stat linkbuf;
 333         int result;
 334         int file_attrs;
 335         gboolean issymlink = FALSE;
 336
 337         result = lstat (filename, &buf);
 338         if (result == -1)
 339                 return FALSE;
 340
 341         if (S_ISLNK (buf.st_mode)) {
 342                 issymlink = TRUE;
 343                 result = stat (filename, &linkbuf);
 344                 if (result != -1) {
 345                         buf = linkbuf;
 346                 }
 347         }
 348
 349         /* Sockets (0140000) != Directory (040000) + Regular file (0100000) */
 350         if (S_ISSOCK (buf.st_mode))
 351                 buf.st_mode &= ~S_IFSOCK; /* don't consider socket protection */
 352
 353         file_attrs = 0;
 354         if (S_ISDIR (buf.st_mode))
 355                 file_attrs |= FILE_ATTRIBUTE_DIRECTORY;
 356         else
 357                 file_attrs |= FILE_ATTRIBUTE_ARCHIVE;
 358
 359         if ((buf.st_mode & S_IWUSR) == 0)
 360                 file_attrs |= FILE_ATTRIBUTE_READONLY;
 361
 362         if (*filename == '.')
 363                 file_attrs |= FILE_ATTRIBUTE_HIDDEN;
 364
 365         if (issymlink) {
 366                 file_attrs |= FILE_ATTRIBUTE_REPARSE_POINT;
 367         }
 368
 369         return file_attrs;
 370 #endif
 371 }
 372
 373 static gboolean
 374 test_file (const char *filename, int attrs, int mask)
 375 {
 376         int file_attr;
 377
 378         file_attr = get_file_attributes (filename);
 379         if (file_attr == FALSE)
 380                 return FALSE;
 381
 382         return ((file_attr & mask) == attrs);
 383 }
 384
 385 /* scandir using glib */
 386 static gint
 387 mono_io_scandir (const gchar *dirname, const gchar *pattern, int attrs,
 388                 int mask, gchar ***namelist)
 389 {
 390         GError *error = NULL;
 391         GDir *dir;
 392         GPtrArray *names;
 393         const gchar *name;
 394         gint result;
 395         GPatternSpec *patspec;
 396         gchar *full_name;
 397
 398         mask = convert_attrs (mask);
 399         *namelist = NULL;
 400         dir = g_dir_open (dirname, 0, &error);
 401         if (dir == NULL) {
 402                 /* g_dir_open returns ENOENT on directories on which we don't
 403                  * have read/x permission */
 404                 gint errnum = get_error_from_g_file_error (error->code);
 405                 g_error_free (error);
 406                 if (errnum == ERROR_FILE_NOT_FOUND && g_file_test (dirname, G_FILE_TEST_IS_DIR))
 407                         errnum = ERROR_ACCESS_DENIED;
 408
 409                 SetLastError (errnum);
 410                 return -1;
 411         }
 412
 413         patspec = g_pattern_spec_new (pattern);
 414         names = g_ptr_array_new ();
 415         while ((name = g_dir_read_name (dir)) != NULL) {
 416                 if (!g_pattern_match_string (patspec, name))
 417                         continue;
 418
 419                 full_name = g_build_filename (dirname, name, NULL);
 420                 if (FALSE == test_file (full_name, attrs, mask)) {
 421                         g_free (full_name);
 422                         continue;
 423                 }
 424
 425                 g_ptr_array_add (names, full_name);
 426         }
 427
 428         g_pattern_spec_free (patspec);
 429         g_dir_close (dir);
 430         result = names->len;
 431         if (result > 0) {
 432                 g_ptr_array_sort (names, file_compare);
 433                 g_ptr_array_set_size (names, result + 1);
 434
 435                 *namelist = (gchar **) g_ptr_array_free (names, FALSE);
 436         } else {
 437                 g_ptr_array_free (names, TRUE);
 438         }
 439
 440         return result;
 441 }
 442
 443 MonoArray *
 444 ves_icall_System_IO_MonoIO_GetFileSystemEntries (MonoString *_path, MonoString *_pattern,
 445                                         gint attrs, gint mask, gint32 *error)
 446 {
 447         MonoDomain *domain;
 448         MonoArray *result;
 449         gchar **namelist;
 450         gchar *path;
 451         gchar *pattern;
 452         int i, nnames;
 453         int removed;
 454         MonoString *str_name;
 455 #ifndef PLATFORM_WIN32
 456         gunichar2 *utf16;
 457         gsize nbytes;
 458 #endif
 459
 460         MONO_ARCH_SAVE_REGS;
 461
 462         *error = ERROR_SUCCESS;
 463
 464         path = mono_string_to_utf8 (_path);
 465         pattern = mono_string_to_utf8 (_pattern);
 466         nnames = mono_io_scandir (path, pattern, attrs, mask, &namelist);
 467         if (nnames < 0) {
 468                 *error = GetLastError ();
 469                 g_free (pattern);
 470                 g_free (path);
 471                 return NULL;
 472         }
 473
 474         domain = mono_domain_get ();
 475         result = mono_array_new (domain, mono_defaults.string_class, nnames);
 476         removed = 0;
 477         for (i = 0; i < nnames; i++) {
 478 #if PLATFORM_WIN32
 479                 str_name = mono_string_new (domain, namelist [i]);
 480 #else
 481                 utf16 = mono_unicode_from_external (namelist [i], &nbytes);
 482                 if (utf16 == NULL) {
 483                         g_message ("Bad encoding for '%s'\nConsider using MONO_EXTERNAL_ENCODINGS\n",
 484                                 namelist [i]);
 485                         removed++;
 486                         continue;
 487                 }
 488                 str_name = mono_string_from_utf16 (utf16);
 489                 g_free (utf16);
 490 #endif
 491                 mono_array_setref (result, i - removed, str_name);
 492         }
 493
 494         if (removed > 0) {
 495                 MonoArray *shrinked;
 496                 shrinked = mono_array_new (domain, mono_defaults.string_class, nnames - removed);
 497                 for (i = 0; i < (nnames - removed); i++) {
 498                         MonoString *str;
 499                         str = mono_array_get (result, MonoString *, i);
 500                         mono_array_setref (shrinked, i, str);
 501                 }
 502                 result = shrinked;
 503         }
 504
 505         g_strfreev (namelist);
 506         g_free (pattern);
 507         g_free (path);
 508         return result;
 509 }
 510
 511 MonoString *
 512 ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *error)
 513 {
 514         MonoString *result;
 515         gunichar2 *buf;
 516         int len;
 517
 518         MONO_ARCH_SAVE_REGS;
 519
 520         len = MAX_PATH + 1;
 521         buf = g_new (gunichar2, len);
 522
 523         *error=ERROR_SUCCESS;
 524         result = NULL;
 525
 526         if (GetCurrentDirectory (len, buf) > 0) {
 527                 len = 0;
 528                 while (buf [len])
 529                         ++ len;
 530
 531                 result = mono_string_new_utf16 (mono_domain_get (), buf, len);
 532         } else {
 533                 *error=GetLastError ();
 534         }
 535
 536         g_free (buf);
 537         return result;
 538 }
 539
 540 MonoBoolean
 541 ves_icall_System_IO_MonoIO_SetCurrentDirectory (MonoString *path,
 542                                                 gint32 *error)
 543 {
 544         gboolean ret;
 545
 546         MONO_ARCH_SAVE_REGS;
 547
 548         *error=ERROR_SUCCESS;
 549
 550         ret=SetCurrentDirectory (mono_string_chars (path));
 551         if(ret==FALSE) {
 552                 *error=GetLastError ();
 553         }
 554
 555         return(ret);
 556 }
 557
 558 MonoBoolean
 559 ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
 560                                      gint32 *error)
 561 {
 562         gboolean ret;
 563
 564         MONO_ARCH_SAVE_REGS;
 565
 566         *error=ERROR_SUCCESS;
 567
 568         ret=MoveFile (mono_string_chars (path), mono_string_chars (dest));
 569         if(ret==FALSE) {
 570                 *error=GetLastError ();
 571         }
 572
 573         return(ret);
 574 }
 575
 576 MonoBoolean
 577 ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
 578                                      MonoBoolean overwrite, gint32 *error)
 579 {
 580         gboolean ret;
 581
 582         MONO_ARCH_SAVE_REGS;
 583
 584         *error=ERROR_SUCCESS;
 585
 586         ret=CopyFile (mono_string_chars (path), mono_string_chars (dest), !overwrite);
 587         if(ret==FALSE) {
 588                 *error=GetLastError ();
 589         }
 590
 591         return(ret);
 592 }
 593
 594 MonoBoolean
 595 ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
 596 {
 597         gboolean ret;
 598
 599         MONO_ARCH_SAVE_REGS;
 600
 601         *error=ERROR_SUCCESS;
 602
 603         ret=DeleteFile (mono_string_chars (path));
 604         if(ret==FALSE) {
 605                 *error=GetLastError ();
 606         }
 607
 608         return(ret);
 609 }
 610
 611 gint32
 612 ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
 613 {
 614         gint32 ret;
 615
 616         MONO_ARCH_SAVE_REGS;
 617
 618         *error=ERROR_SUCCESS;
 619
 620         ret=GetFileAttributes (mono_string_chars (path));
 621
 622         /*
 623          * The definition of INVALID_FILE_ATTRIBUTES in the cygwin win32
 624          * headers is wrong, hence this temporary workaround.
 625          * See
 626          * http://cygwin.com/ml/cygwin/2003-09/msg01771.html
 627          */
 628         if (ret==-1) {
 629           /* if(ret==INVALID_FILE_ATTRIBUTES) { */
 630                 *error=GetLastError ();
 631         }
 632
 633         return(ret);
 634 }
 635
 636 MonoBoolean
 637 ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
 638                                               gint32 *error)
 639 {
 640         gboolean ret;
 641
 642         MONO_ARCH_SAVE_REGS;
 643
 644         *error=ERROR_SUCCESS;
 645
 646         ret=SetFileAttributes (mono_string_chars (path),
 647                                convert_attrs (attrs));
 648         if(ret==FALSE) {
 649                 *error=GetLastError ();
 650         }
 651
 652         return(ret);
 653 }
 654
 655 gint32
 656 ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
 657 {
 658         gboolean ret;
 659
 660         MONO_ARCH_SAVE_REGS;
 661
 662         *error=ERROR_SUCCESS;
 663
 664         ret=GetFileType (handle);
 665         if(ret==FILE_TYPE_UNKNOWN) {
 666                 /* Not necessarily an error, but the caller will have
 667                  * to decide based on the error value.
 668                  */
 669                 *error=GetLastError ();
 670         }
 671
 672         return(ret);
 673 }
 674
 675 MonoBoolean
 676 ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
 677                                         gint32 *error)
 678 {
 679         gboolean result;
 680         WIN32_FILE_ATTRIBUTE_DATA data;
 681
 682         MONO_ARCH_SAVE_REGS;
 683
 684         *error=ERROR_SUCCESS;
 685
 686         result = GetFileAttributesEx (mono_string_chars (path), GetFileExInfoStandard, &data);
 687
 688         if (result) {
 689                 convert_win32_file_attribute_data (&data,
 690                                                    mono_string_chars (path),
 691                                                    stat);
 692         } else {
 693                 *error=GetLastError ();
 694         }
 695
 696         return result;
 697 }
 698
 699 HANDLE
 700 ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode,
 701                                  gint32 access_mode, gint32 share, gint32 options,
 702                                  gint32 *error)
 703 {
 704         HANDLE ret;
 705         int attributes, attrs;
 706         gunichar2 *chars = mono_string_chars (filename);
 707
 708         MONO_ARCH_SAVE_REGS;
 709
 710         *error=ERROR_SUCCESS;
 711
 712         if (options != 0){
 713                 if (options & FileOptions_Encrypted)
 714                         attributes = FILE_ATTRIBUTE_ENCRYPTED;
 715                 else
 716                         attributes = FILE_ATTRIBUTE_NORMAL;
 717                 if (options & FileOptions_DeleteOnClose)
 718                         attributes |= FILE_FLAG_DELETE_ON_CLOSE;
 719                 if (options & FileOptions_SequentialScan)
 720                         attributes |= FILE_FLAG_SEQUENTIAL_SCAN;
 721                 if (options & FileOptions_RandomAccess)
 722                         attributes |= FILE_FLAG_RANDOM_ACCESS;
 723
 724                 /* Not sure if we should set FILE_FLAG_OVERLAPPED, how does this mix with the "Async" bool here? */
 725                 if (options & FileOptions_Asynchronous)
 726                         attributes |= FILE_FLAG_OVERLAPPED;
 727
 728                 if (options & FileOptions_WriteThrough)
 729                         attributes |= FILE_FLAG_WRITE_THROUGH;
 730         } else
 731                 attributes = FILE_ATTRIBUTE_NORMAL;
 732
 733         /* If we're opening a directory we need to set the extra flag
 734          */
 735         attrs = GetFileAttributes (chars);
 736         if (attrs != INVALID_FILE_ATTRIBUTES) {
 737                 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
 738                         attributes |= FILE_FLAG_BACKUP_SEMANTICS;
 739                 }
 740         }
 741
 742         ret=CreateFile (chars, convert_access (access_mode),
 743                         convert_share (share), NULL, convert_mode (mode),
 744                         attributes, NULL);
 745         if(ret==INVALID_HANDLE_VALUE) {
 746                 *error=GetLastError ();
 747         }
 748
 749         return(ret);
 750 }
 751
 752 MonoBoolean
 753 ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
 754 {
 755         gboolean ret;
 756
 757         MONO_ARCH_SAVE_REGS;
 758
 759         *error=ERROR_SUCCESS;
 760
 761         ret=CloseHandle (handle);
 762         if(ret==FALSE) {
 763                 *error=GetLastError ();
 764         }
 765
 766         return(ret);
 767 }
 768
 769 gint32
 770 ves_icall_System_IO_MonoIO_Read (HANDLE handle, MonoArray *dest,
 771                                  gint32 dest_offset, gint32 count,
 772                                  gint32 *error)
 773 {
 774         guchar *buffer;
 775         gboolean result;
 776         guint32 n;
 777
 778         MONO_ARCH_SAVE_REGS;
 779
 780         *error=ERROR_SUCCESS;
 781
 782         if (dest_offset + count > mono_array_length (dest))
 783                 return 0;
 784
 785         buffer = mono_array_addr (dest, guchar, dest_offset);
 786         result = ReadFile (handle, buffer, count, &n, NULL);
 787
 788         if (!result) {
 789                 *error=GetLastError ();
 790                 return -1;
 791         }
 792
 793         return (gint32)n;
 794 }
 795
 796 gint32
 797 ves_icall_System_IO_MonoIO_Write (HANDLE handle, MonoArray *src,
 798                                   gint32 src_offset, gint32 count,
 799                                   gint32 *error)
 800 {
 801         guchar *buffer;
 802         gboolean result;
 803         guint32 n;
 804
 805         MONO_ARCH_SAVE_REGS;
 806
 807         *error=ERROR_SUCCESS;
 808
 809         if (src_offset + count > mono_array_length (src))
 810                 return 0;
 811
 812         buffer = mono_array_addr (src, guchar, src_offset);
 813         result = WriteFile (handle, buffer, count, &n, NULL);
 814
 815         if (!result) {
 816                 *error=GetLastError ();
 817                 return -1;
 818         }
 819
 820         return (gint32)n;
 821 }
 822
 823 gint64
 824 ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
 825                                  gint32 *error)
 826 {
 827         gint32 offset_hi;
 828
 829         MONO_ARCH_SAVE_REGS;
 830
 831         *error=ERROR_SUCCESS;
 832
 833         offset_hi = offset >> 32;
 834         offset = SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
 835                                  convert_seekorigin (origin));
 836
 837         if(offset==INVALID_SET_FILE_POINTER) {
 838                 *error=GetLastError ();
 839         }
 840
 841         return offset | ((gint64)offset_hi << 32);
 842 }
 843
 844 MonoBoolean
 845 ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
 846 {
 847         gboolean ret;
 848
 849         MONO_ARCH_SAVE_REGS;
 850
 851         *error=ERROR_SUCCESS;
 852
 853         ret=FlushFileBuffers (handle);
 854         if(ret==FALSE) {
 855                 *error=GetLastError ();
 856         }
 857
 858         return(ret);
 859 }
 860
 861 gint64
 862 ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
 863 {
 864         gint64 length;
 865         guint32 length_hi;
 866
 867         MONO_ARCH_SAVE_REGS;
 868
 869         *error=ERROR_SUCCESS;
 870
 871         length = GetFileSize (handle, &length_hi);
 872         if(length==INVALID_FILE_SIZE) {
 873                 *error=GetLastError ();
 874         }
 875
 876         return length | ((gint64)length_hi << 32);
 877 }
 878
 879 MonoBoolean
 880 ves_icall_System_IO_MonoIO_SetLength (HANDLE handle, gint64 length,
 881                                       gint32 *error)
 882 {
 883         gint64 offset, offset_set;
 884         gint32 offset_hi;
 885         gint32 length_hi;
 886         gboolean result;
 887
 888         MONO_ARCH_SAVE_REGS;
 889
 890         *error=ERROR_SUCCESS;
 891
 892         /* save file pointer */
 893
 894         offset_hi = 0;
 895         offset = SetFilePointer (handle, 0, &offset_hi, FILE_CURRENT);
 896         if(offset==INVALID_SET_FILE_POINTER) {
 897                 *error=GetLastError ();
 898                 return(FALSE);
 899         }
 900
 901         /* extend or truncate */
 902
 903         length_hi = length >> 32;
 904         offset_set=SetFilePointer (handle, length & 0xFFFFFFFF, &length_hi,
 905                                    FILE_BEGIN);
 906         if(offset_set==INVALID_SET_FILE_POINTER) {
 907                 *error=GetLastError ();
 908                 return(FALSE);
 909         }
 910
 911         result = SetEndOfFile (handle);
 912         if(result==FALSE) {
 913                 *error=GetLastError ();
 914                 return(FALSE);
 915         }
 916
 917         /* restore file pointer */
 918
 919         offset_set=SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
 920                                    FILE_BEGIN);
 921         if(offset_set==INVALID_SET_FILE_POINTER) {
 922                 *error=GetLastError ();
 923                 return(FALSE);
 924         }
 925
 926         return result;
 927 }
 928
 929 MonoBoolean
 930 ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time,
 931                                         gint64 last_access_time,
 932                                         gint64 last_write_time, gint32 *error)
 933 {
 934         gboolean ret;
 935         const FILETIME *creation_filetime;
 936         const FILETIME *last_access_filetime;
 937         const FILETIME *last_write_filetime;
 938
 939         MONO_ARCH_SAVE_REGS;
 940
 941         *error=ERROR_SUCCESS;
 942
 943         if (creation_time < 0)
 944                 creation_filetime = NULL;
 945         else
 946                 creation_filetime = (FILETIME *)&creation_time;
 947
 948         if (last_access_time < 0)
 949                 last_access_filetime = NULL;
 950         else
 951                 last_access_filetime = (FILETIME *)&last_access_time;
 952
 953         if (last_write_time < 0)
 954                 last_write_filetime = NULL;
 955         else
 956                 last_write_filetime = (FILETIME *)&last_write_time;
 957
 958         ret=SetFileTime (handle, creation_filetime, last_access_filetime, last_write_filetime);
 959         if(ret==FALSE) {
 960                 *error=GetLastError ();
 961         }
 962
 963         return(ret);
 964 }
 965
 966 HANDLE
 967 ves_icall_System_IO_MonoIO_get_ConsoleOutput ()
 968 {
 969         MONO_ARCH_SAVE_REGS;
 970
 971         return GetStdHandle (STD_OUTPUT_HANDLE);
 972 }
 973
 974 HANDLE
 975 ves_icall_System_IO_MonoIO_get_ConsoleInput ()
 976 {
 977         MONO_ARCH_SAVE_REGS;
 978
 979         return GetStdHandle (STD_INPUT_HANDLE);
 980 }
 981
 982 HANDLE
 983 ves_icall_System_IO_MonoIO_get_ConsoleError ()
 984 {
 985         MONO_ARCH_SAVE_REGS;
 986
 987         return GetStdHandle (STD_ERROR_HANDLE);
 988 }
 989
 990 MonoBoolean
 991 ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle,
 992                                        HANDLE *write_handle)
 993 {
 994         SECURITY_ATTRIBUTES attr;
 995         gboolean ret;
 996
 997         MONO_ARCH_SAVE_REGS;
 998
 999         attr.nLength=sizeof(SECURITY_ATTRIBUTES);
1000         attr.bInheritHandle=TRUE;
1001         attr.lpSecurityDescriptor=NULL;
1002
1003         ret=CreatePipe (read_handle, write_handle, &attr, 0);
1004         if(ret==FALSE) {
1005                 /* FIXME: throw an exception? */
1006                 return(FALSE);
1007         }
1008
1009         return(TRUE);
1010 }
1011
1012 gunichar2
1013 ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar ()
1014 {
1015 #if defined (PLATFORM_WIN32)
1016         return (gunichar2) ':'; /* colon */
1017 #else
1018         return (gunichar2) '/'; /* forward slash */
1019 #endif
1020 }
1021
1022 gunichar2
1023 ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar ()
1024 {
1025 #if defined (PLATFORM_WIN32)
1026         return (gunichar2) '\\';        /* backslash */
1027 #else
1028         return (gunichar2) '/'; /* forward slash */
1029 #endif
1030 }
1031
1032 gunichar2
1033 ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar ()
1034 {
1035 #if defined (PLATFORM_WIN32)
1036         return (gunichar2) '/'; /* forward slash */
1037 #else
1038         return (gunichar2) '/'; /* slash, same as DirectorySeparatorChar */
1039 #endif
1040 }
1041
1042 gunichar2
1043 ves_icall_System_IO_MonoIO_get_PathSeparator ()
1044 {
1045 #if defined (PLATFORM_WIN32)
1046         return (gunichar2) ';'; /* semicolon */
1047 #else
1048         return (gunichar2) ':'; /* colon */
1049 #endif
1050 }
1051
1052 static const gunichar2
1053 invalid_path_chars [] = {
1054 #if defined (PLATFORM_WIN32)
1055         0x0022,                         /* double quote, which seems allowed in MS.NET but should be rejected */
1056         0x003c,                         /* less than */
1057         0x003e,                         /* greater than */
1058         0x007c,                         /* pipe */
1059         0x0008,
1060         0x0010,
1061         0x0011,
1062         0x0012,
1063         0x0014,
1064         0x0015,
1065         0x0016,
1066         0x0017,
1067         0x0018,
1068         0x0019,
1069 #endif
1070         0x0000                          /* null */
1071 };
1072
1073 MonoArray *
1074 ves_icall_System_IO_MonoIO_get_InvalidPathChars ()
1075 {
1076         MonoArray *chars;
1077         MonoDomain *domain;
1078         int i, n;
1079
1080         MONO_ARCH_SAVE_REGS;
1081
1082         domain = mono_domain_get ();
1083         n = sizeof (invalid_path_chars) / sizeof (gunichar2);
1084         chars = mono_array_new (domain, mono_defaults.char_class, n);
1085
1086         for (i = 0; i < n; ++ i)
1087                 mono_array_set (chars, gunichar2, i, invalid_path_chars [i]);
1088
1089         return chars;
1090 }
1091
1092 gint32
1093 ves_icall_System_IO_MonoIO_GetTempPath (MonoString **mono_name)
1094 {
1095         gunichar2 *name;
1096         int ret;
1097
1098         name=g_new0 (gunichar2, 256);
1099
1100         ret=GetTempPath (256, name);
1101         if(ret>255) {
1102                 /* Buffer was too short. Try again... */
1103                 g_free (name);
1104                 name=g_new0 (gunichar2, ret+2); /* include the terminator */
1105                 ret=GetTempPath (ret, name);
1106         }
1107
1108         if(ret>0) {
1109 #ifdef DEBUG
1110                 g_message (G_GNUC_PRETTY_FUNCTION
1111                            ": Temp path is [%s] (len %d)", name, ret);
1112 #endif
1113
1114                 *mono_name=mono_string_new_utf16 (mono_domain_get (), name,
1115                                                   ret);
1116         }
1117
1118         g_free (name);
1119
1120         return(ret);
1121 }
1122
1123 void ves_icall_System_IO_MonoIO_Lock (HANDLE handle, gint64 position,
1124                                       gint64 length, gint32 *error)
1125 {
1126         gboolean ret;
1127
1128         *error=ERROR_SUCCESS;
1129
1130         ret=LockFile (handle, position & 0xFFFFFFFF, position >> 32,
1131                       length & 0xFFFFFFFF, length >> 32);
1132         if (ret == FALSE) {
1133                 *error = GetLastError ();
1134         }
1135 }
1136
1137 void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position,
1138                                         gint64 length, gint32 *error)
1139 {
1140         gboolean ret;
1141
1142         *error=ERROR_SUCCESS;
1143
1144         ret=UnlockFile (handle, position & 0xFFFFFFFF, position >> 32,
1145                         length & 0xFFFFFFFF, length >> 32);
1146         if (ret == FALSE) {
1147                 *error = GetLastError ();
1148         }
1149 }
1150