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  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   9  * Copyright 2004-2009 Novell, Inc (http://www.novell.com)
  10  * Copyright 2012 Xamarin Inc (http://www.xamarin.com)
  11  */
  12
  13 #include <config.h>
  14
  15 #include <glib.h>
  16 #include <string.h>
  17 #include <errno.h>
  18 #ifdef HAVE_UNISTD_H
  19 #include <unistd.h>
  20 #endif
  21 #ifdef HAVE_SYS_STAT_H
  22 #include <sys/stat.h>
  23 #endif
  24 #ifdef HAVE_SYS_TYPES_H
  25 #include <sys/types.h>
  26 #endif
  27
  28 #include <mono/metadata/object.h>
  29 #include <mono/io-layer/io-layer.h>
  30 #include <mono/metadata/file-io.h>
  31 #include <mono/metadata/exception.h>
  32 #include <mono/metadata/appdomain.h>
  33 #include <mono/metadata/marshal.h>
  34 #include <mono/utils/strenc.h>
  35 #include <utils/mono-io-portability.h>
  36
  37 #undef DEBUG
  38
  39 /* conversion functions */
  40
  41 static guint32 convert_mode(MonoFileMode mono_mode)
  42 {
  43         guint32 mode;
  44
  45         switch(mono_mode) {
  46         case FileMode_CreateNew:
  47                 mode=CREATE_NEW;
  48                 break;
  49         case FileMode_Create:
  50                 mode=CREATE_ALWAYS;
  51                 break;
  52         case FileMode_Open:
  53                 mode=OPEN_EXISTING;
  54                 break;
  55         case FileMode_OpenOrCreate:
  56                 mode=OPEN_ALWAYS;
  57                 break;
  58         case FileMode_Truncate:
  59                 mode=TRUNCATE_EXISTING;
  60                 break;
  61         case FileMode_Append:
  62                 mode=OPEN_ALWAYS;
  63                 break;
  64         default:
  65                 g_warning("System.IO.FileMode has unknown value 0x%x",
  66                           mono_mode);
  67                 /* Safe fallback */
  68                 mode=OPEN_EXISTING;
  69         }
  70
  71         return(mode);
  72 }
  73
  74 static guint32 convert_access(MonoFileAccess mono_access)
  75 {
  76         guint32 access;
  77
  78         switch(mono_access) {
  79         case FileAccess_Read:
  80                 access=GENERIC_READ;
  81                 break;
  82         case FileAccess_Write:
  83                 access=GENERIC_WRITE;
  84                 break;
  85         case FileAccess_ReadWrite:
  86                 access=GENERIC_READ|GENERIC_WRITE;
  87                 break;
  88         default:
  89                 g_warning("System.IO.FileAccess has unknown value 0x%x",
  90                           mono_access);
  91                 /* Safe fallback */
  92                 access=GENERIC_READ;
  93         }
  94
  95         return(access);
  96 }
  97
  98 static guint32 convert_share(MonoFileShare mono_share)
  99 {
 100         guint32 share = 0;
 101
 102         if (mono_share & FileShare_Read) {
 103                 share |= FILE_SHARE_READ;
 104         }
 105         if (mono_share & FileShare_Write) {
 106                 share |= FILE_SHARE_WRITE;
 107         }
 108         if (mono_share & FileShare_Delete) {
 109                 share |= FILE_SHARE_DELETE;
 110         }
 111
 112         if (mono_share & ~(FileShare_Read|FileShare_Write|FileShare_Delete)) {
 113                 g_warning("System.IO.FileShare has unknown value 0x%x",
 114                           mono_share);
 115                 /* Safe fallback */
 116                 share=0;
 117         }
 118
 119         return(share);
 120 }
 121
 122 #if 0
 123 static guint32 convert_stdhandle(guint32 fd)
 124 {
 125         guint32 stdhandle;
 126
 127         switch(fd) {
 128         case 0:
 129                 stdhandle=STD_INPUT_HANDLE;
 130                 break;
 131         case 1:
 132                 stdhandle=STD_OUTPUT_HANDLE;
 133                 break;
 134         case 2:
 135                 stdhandle=STD_ERROR_HANDLE;
 136                 break;
 137         default:
 138                 g_warning("unknown standard file descriptor %d", fd);
 139                 stdhandle=STD_INPUT_HANDLE;
 140         }
 141
 142         return(stdhandle);
 143 }
 144 #endif
 145
 146 static guint32 convert_seekorigin(MonoSeekOrigin origin)
 147 {
 148         guint32 w32origin;
 149
 150         switch(origin) {
 151         case SeekOrigin_Begin:
 152                 w32origin=FILE_BEGIN;
 153                 break;
 154         case SeekOrigin_Current:
 155                 w32origin=FILE_CURRENT;
 156                 break;
 157         case SeekOrigin_End:
 158                 w32origin=FILE_END;
 159                 break;
 160         default:
 161                 g_warning("System.IO.SeekOrigin has unknown value 0x%x",
 162                           origin);
 163                 /* Safe fallback */
 164                 w32origin=FILE_CURRENT;
 165         }
 166
 167         return(w32origin);
 168 }
 169
 170 static gint64 convert_filetime (const FILETIME *filetime)
 171 {
 172         guint64 ticks = filetime->dwHighDateTime;
 173         ticks <<= 32;
 174         ticks += filetime->dwLowDateTime;
 175         return (gint64)ticks;
 176 }
 177
 178 static void convert_win32_file_attribute_data (const WIN32_FILE_ATTRIBUTE_DATA *data, MonoIOStat *stat)
 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
 187 /* Managed file attributes have nearly but not quite the same values
 188  * as the w32 equivalents.
 189  */
 190 static guint32 convert_attrs(MonoFileAttributes attrs)
 191 {
 192         if(attrs & FileAttributes_Encrypted) {
 193                 attrs = (MonoFileAttributes)(attrs | FILE_ATTRIBUTE_ENCRYPTED);
 194         }
 195
 196         return(attrs);
 197 }
 198
 199 /*
 200  * On Win32, GetFileAttributes|Ex () seems to try opening the file,
 201  * which might lead to sharing violation errors, whereas FindFirstFile
 202  * always succeeds. These 2 wrappers resort to FindFirstFile if
 203  * GetFileAttributes|Ex () has failed.
 204  */
 205 static guint32
 206 get_file_attributes (const gunichar2 *path)
 207 {
 208         guint32 res;
 209         WIN32_FIND_DATA find_data;
 210         HANDLE find_handle;
 211         gint32 error;
 212
 213         res = GetFileAttributes (path);
 214         if (res != -1)
 215                 return res;
 216
 217         error = GetLastError ();
 218
 219         if (error != ERROR_SHARING_VIOLATION)
 220                 return res;
 221
 222         find_handle = FindFirstFile (path, &find_data);
 223
 224         if (find_handle == INVALID_HANDLE_VALUE)
 225                 return res;
 226
 227         FindClose (find_handle);
 228
 229         return find_data.dwFileAttributes;
 230 }
 231
 232 static gboolean
 233 get_file_attributes_ex (const gunichar2 *path, WIN32_FILE_ATTRIBUTE_DATA *data)
 234 {
 235         gboolean res;
 236         WIN32_FIND_DATA find_data;
 237         HANDLE find_handle;
 238         gint32 error;
 239
 240         res = GetFileAttributesEx (path, GetFileExInfoStandard, data);
 241         if (res)
 242                 return TRUE;
 243
 244         error = GetLastError ();
 245
 246         if (error != ERROR_SHARING_VIOLATION)
 247                 return FALSE;
 248
 249         find_handle = FindFirstFile (path, &find_data);
 250
 251         if (find_handle == INVALID_HANDLE_VALUE)
 252                 return FALSE;
 253
 254         FindClose (find_handle);
 255
 256         data->dwFileAttributes = find_data.dwFileAttributes;
 257         data->ftCreationTime = find_data.ftCreationTime;
 258         data->ftLastAccessTime = find_data.ftLastAccessTime;
 259         data->ftLastWriteTime = find_data.ftLastWriteTime;
 260         data->nFileSizeHigh = find_data.nFileSizeHigh;
 261         data->nFileSizeLow = find_data.nFileSizeLow;
 262
 263         return TRUE;
 264 }
 265
 266 /* System.IO.MonoIO internal calls */
 267
 268 MonoBoolean
 269 ves_icall_System_IO_MonoIO_CreateDirectory (MonoString *path, gint32 *error)
 270 {
 271         gboolean ret;
 272         MONO_PREPARE_BLOCKING;
 273
 274         *error=ERROR_SUCCESS;
 275
 276         ret=CreateDirectory (mono_string_chars (path), NULL);
 277         if(ret==FALSE) {
 278                 *error=GetLastError ();
 279         }
 280
 281         MONO_FINISH_BLOCKING;
 282         return(ret);
 283 }
 284
 285 MonoBoolean
 286 ves_icall_System_IO_MonoIO_RemoveDirectory (MonoString *path, gint32 *error)
 287 {
 288         gboolean ret;
 289         MONO_PREPARE_BLOCKING;
 290
 291         *error=ERROR_SUCCESS;
 292
 293         ret=RemoveDirectory (mono_string_chars (path));
 294         if(ret==FALSE) {
 295                 *error=GetLastError ();
 296         }
 297
 298         MONO_FINISH_BLOCKING;
 299         return(ret);
 300 }
 301
 302 static gchar *
 303 get_search_dir (const gunichar2 *pattern)
 304 {
 305         gchar *p;
 306         gchar *result;
 307
 308         p = g_utf16_to_utf8 (pattern, -1, NULL, NULL, NULL);
 309         result = g_path_get_dirname (p);
 310         g_free (p);
 311         return result;
 312 }
 313
 314 static GPtrArray *
 315 get_filesystem_entries (const gunichar2 *path,
 316                                                  const gunichar2 *path_with_pattern,
 317                                                  gint attrs, gint mask,
 318                                                  gint32 *error)
 319 {
 320         int i;
 321         WIN32_FIND_DATA data;
 322         HANDLE find_handle;
 323         GPtrArray *names = NULL;
 324         gchar *utf8_path = NULL, *utf8_result, *full_name;
 325         gint32 attributes;
 326
 327         mask = convert_attrs ((MonoFileAttributes)mask);
 328         attributes = get_file_attributes (path);
 329         if (attributes != -1) {
 330                 if ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
 331                         *error = ERROR_INVALID_NAME;
 332                         goto fail;
 333                 }
 334         } else {
 335                 *error = GetLastError ();
 336                 goto fail;
 337         }
 338
 339         find_handle = FindFirstFile (path_with_pattern, &data);
 340         if (find_handle == INVALID_HANDLE_VALUE) {
 341                 gint32 find_error = GetLastError ();
 342
 343                 if (find_error == ERROR_FILE_NOT_FOUND || find_error == ERROR_NO_MORE_FILES) {
 344                         /* No files, so just return an empty array */
 345                         goto fail;
 346                 }
 347
 348                 *error = find_error;
 349                 goto fail;
 350         }
 351
 352         utf8_path = get_search_dir (path_with_pattern);
 353         names = g_ptr_array_new ();
 354
 355         do {
 356                 if ((data.cFileName[0] == '.' && data.cFileName[1] == 0) ||
 357                     (data.cFileName[0] == '.' && data.cFileName[1] == '.' && data.cFileName[2] == 0)) {
 358                         continue;
 359                 }
 360
 361                 if ((data.dwFileAttributes & mask) == attrs) {
 362                         utf8_result = g_utf16_to_utf8 (data.cFileName, -1, NULL, NULL, NULL);
 363                         if (utf8_result == NULL) {
 364                                 continue;
 365                         }
 366
 367                         full_name = g_build_filename (utf8_path, utf8_result, NULL);
 368                         g_ptr_array_add (names, full_name);
 369
 370                         g_free (utf8_result);
 371                 }
 372         } while(FindNextFile (find_handle, &data));
 373
 374         if (FindClose (find_handle) == FALSE) {
 375                 *error = GetLastError ();
 376                 goto fail;
 377         }
 378
 379         g_free (utf8_path);
 380         return names;
 381 fail:
 382         if (names) {
 383                 for (i = 0; i < names->len; i++)
 384                         g_free (g_ptr_array_index (names, i));
 385                 g_ptr_array_free (names, TRUE);
 386         }
 387         g_free (utf8_path);
 388         return FALSE;
 389 }
 390
 391
 392 MonoArray *
 393 ves_icall_System_IO_MonoIO_GetFileSystemEntries (MonoString *path,
 394                                                  MonoString *path_with_pattern,
 395                                                  gint attrs, gint mask,
 396                                                  gint32 *error)
 397 {
 398         MonoDomain *domain = mono_domain_get ();
 399         MonoArray *result;
 400         int i;
 401         GPtrArray *names;
 402
 403         *error = ERROR_SUCCESS;
 404
 405         MONO_PREPARE_BLOCKING;
 406         names = get_filesystem_entries (mono_string_chars (path), mono_string_chars (path_with_pattern), attrs, mask, error);
 407         MONO_FINISH_BLOCKING;
 408
 409         if (!names) {
 410                 // If there's no array and no error, then return an empty array.
 411                 if (*error == ERROR_SUCCESS)
 412                         return mono_array_new (domain, mono_defaults.string_class, 0);
 413                 return NULL;
 414         }
 415
 416         result = mono_array_new (domain, mono_defaults.string_class, names->len);
 417         for (i = 0; i < names->len; i++) {
 418                 mono_array_setref (result, i, mono_string_new (domain, (const char *)g_ptr_array_index (names, i)));
 419                 g_free (g_ptr_array_index (names, i));
 420         }
 421         g_ptr_array_free (names, TRUE);
 422         return result;
 423 }
 424
 425 typedef struct {
 426         MonoDomain *domain;
 427         gchar *utf8_path;
 428         HANDLE find_handle;
 429 } IncrementalFind;
 430
 431 static gboolean
 432 incremental_find_check_match (IncrementalFind *handle, WIN32_FIND_DATA *data, MonoString **result)
 433 {
 434         gchar *utf8_result;
 435         gchar *full_name;
 436
 437         if ((data->cFileName[0] == '.' && data->cFileName[1] == 0) || (data->cFileName[0] == '.' && data->cFileName[1] == '.' && data->cFileName[2] == 0))
 438                 return FALSE;
 439
 440         utf8_result = g_utf16_to_utf8 (data->cFileName, -1, NULL, NULL, NULL);
 441         if (utf8_result == NULL)
 442                 return FALSE;
 443
 444         full_name = g_build_filename (handle->utf8_path, utf8_result, NULL);
 445         g_free (utf8_result);
 446         *result = mono_string_new (mono_domain_get (), full_name);
 447         g_free (full_name);
 448
 449         return TRUE;
 450 }
 451
 452 /* FIXME make gc suspendable */
 453 MonoString *
 454 ves_icall_System_IO_MonoIO_FindFirst (MonoString *path,
 455                                       MonoString *path_with_pattern,
 456                                       gint32 *result_attr, gint32 *error,
 457                                       gpointer *handle)
 458 {
 459         WIN32_FIND_DATA data;
 460         HANDLE find_handle;
 461         IncrementalFind *ifh;
 462         MonoString *result;
 463
 464         *error = ERROR_SUCCESS;
 465
 466         find_handle = FindFirstFile (mono_string_chars (path_with_pattern), &data);
 467
 468         if (find_handle == INVALID_HANDLE_VALUE) {
 469                 gint32 find_error = GetLastError ();
 470                 *handle = NULL;
 471
 472                 if (find_error == ERROR_FILE_NOT_FOUND)
 473                         return NULL;
 474
 475                 *error = find_error;
 476                 return NULL;
 477         }
 478
 479         ifh = g_new (IncrementalFind, 1);
 480         ifh->find_handle = find_handle;
 481         ifh->utf8_path = mono_string_to_utf8 (path);
 482         ifh->domain = mono_domain_get ();
 483         *handle = ifh;
 484
 485         while (incremental_find_check_match (ifh, &data, &result) == 0){
 486                 if (FindNextFile (find_handle, &data) == FALSE){
 487                         int e = GetLastError ();
 488                         if (e != ERROR_NO_MORE_FILES)
 489                                 *error = e;
 490                         return NULL;
 491                 }
 492         }
 493         *result_attr = data.dwFileAttributes;
 494
 495         return result;
 496 }
 497
 498 /* FIXME make gc suspendable */
 499 MonoString *
 500 ves_icall_System_IO_MonoIO_FindNext (gpointer handle, gint32 *result_attr, gint32 *error)
 501 {
 502         IncrementalFind *ifh = (IncrementalFind *)handle;
 503         WIN32_FIND_DATA data;
 504         MonoString *result;
 505
 506         *error = ERROR_SUCCESS;
 507         do {
 508                 if (FindNextFile (ifh->find_handle, &data) == FALSE){
 509                         int e = GetLastError ();
 510                         if (e != ERROR_NO_MORE_FILES)
 511                                 *error = e;
 512                         return NULL;
 513                 }
 514         } while (incremental_find_check_match (ifh, &data, &result) == 0);
 515
 516         *result_attr = data.dwFileAttributes;
 517         return result;
 518 }
 519
 520 int
 521 ves_icall_System_IO_MonoIO_FindClose (gpointer handle)
 522 {
 523         IncrementalFind *ifh = (IncrementalFind *)handle;
 524         gint32 error;
 525
 526         MONO_PREPARE_BLOCKING;
 527         if (FindClose (ifh->find_handle) == FALSE){
 528                 error = GetLastError ();
 529         } else
 530                 error = ERROR_SUCCESS;
 531         g_free (ifh->utf8_path);
 532         g_free (ifh);
 533         MONO_FINISH_BLOCKING;
 534
 535         return error;
 536 }
 537
 538 MonoString *
 539 ves_icall_System_IO_MonoIO_GetCurrentDirectory (gint32 *io_error)
 540 {
 541         MonoError error;
 542         MonoString *result;
 543         gunichar2 *buf;
 544         int len, res_len;
 545
 546         len = MAX_PATH + 1; /*FIXME this is too smal under most unix systems.*/
 547         buf = g_new (gunichar2, len);
 548
 549         mono_error_init (&error);
 550         *io_error=ERROR_SUCCESS;
 551         result = NULL;
 552
 553         res_len = GetCurrentDirectory (len, buf);
 554         if (res_len > len) { /*buf is too small.*/
 555                 int old_res_len = res_len;
 556                 g_free (buf);
 557                 buf = g_new (gunichar2, res_len);
 558                 res_len = GetCurrentDirectory (res_len, buf) == old_res_len;
 559         }
 560
 561         if (res_len) {
 562                 len = 0;
 563                 while (buf [len])
 564                         ++ len;
 565
 566                 result = mono_string_new_utf16_checked (mono_domain_get (), buf, len, &error);
 567         } else {
 568                 *io_error=GetLastError ();
 569         }
 570
 571         g_free (buf);
 572         mono_error_raise_exception (&error);
 573         return result;
 574 }
 575
 576 MonoBoolean
 577 ves_icall_System_IO_MonoIO_SetCurrentDirectory (MonoString *path,
 578                                                 gint32 *error)
 579 {
 580         gboolean ret;
 581
 582         *error=ERROR_SUCCESS;
 583
 584         ret=SetCurrentDirectory (mono_string_chars (path));
 585         if(ret==FALSE) {
 586                 *error=GetLastError ();
 587         }
 588
 589         return(ret);
 590 }
 591
 592 MonoBoolean
 593 ves_icall_System_IO_MonoIO_MoveFile (MonoString *path, MonoString *dest,
 594                                      gint32 *error)
 595 {
 596         gboolean ret;
 597         MONO_PREPARE_BLOCKING;
 598
 599         *error=ERROR_SUCCESS;
 600
 601         ret=MoveFile (mono_string_chars (path), mono_string_chars (dest));
 602         if(ret==FALSE) {
 603                 *error=GetLastError ();
 604         }
 605
 606         MONO_FINISH_BLOCKING;
 607         return(ret);
 608 }
 609
 610 MonoBoolean
 611 ves_icall_System_IO_MonoIO_ReplaceFile (MonoString *sourceFileName, MonoString *destinationFileName,
 612                                         MonoString *destinationBackupFileName, MonoBoolean ignoreMetadataErrors,
 613                                         gint32 *error)
 614 {
 615         gboolean ret;
 616         gunichar2 *utf16_sourceFileName = NULL, *utf16_destinationFileName = NULL, *utf16_destinationBackupFileName = NULL;
 617         guint32 replaceFlags = REPLACEFILE_WRITE_THROUGH;
 618         MONO_PREPARE_BLOCKING;
 619
 620         if (sourceFileName)
 621                 utf16_sourceFileName = mono_string_chars (sourceFileName);
 622         if (destinationFileName)
 623                 utf16_destinationFileName = mono_string_chars (destinationFileName);
 624         if (destinationBackupFileName)
 625                 utf16_destinationBackupFileName = mono_string_chars (destinationBackupFileName);
 626
 627         *error = ERROR_SUCCESS;
 628         if (ignoreMetadataErrors)
 629                 replaceFlags |= REPLACEFILE_IGNORE_MERGE_ERRORS;
 630
 631         /* FIXME: source and destination file names must not be NULL, but apparently they might be! */
 632         ret = ReplaceFile (utf16_destinationFileName, utf16_sourceFileName, utf16_destinationBackupFileName,
 633                          replaceFlags, NULL, NULL);
 634         if (ret == FALSE)
 635                 *error = GetLastError ();
 636
 637         MONO_FINISH_BLOCKING;
 638         return ret;
 639 }
 640
 641 MonoBoolean
 642 ves_icall_System_IO_MonoIO_CopyFile (MonoString *path, MonoString *dest,
 643                                      MonoBoolean overwrite, gint32 *error)
 644 {
 645         gboolean ret;
 646         MONO_PREPARE_BLOCKING;
 647
 648         *error=ERROR_SUCCESS;
 649
 650         ret=CopyFile (mono_string_chars (path), mono_string_chars (dest), !overwrite);
 651         if(ret==FALSE) {
 652                 *error=GetLastError ();
 653         }
 654
 655         MONO_FINISH_BLOCKING;
 656         return(ret);
 657 }
 658
 659 MonoBoolean
 660 ves_icall_System_IO_MonoIO_DeleteFile (MonoString *path, gint32 *error)
 661 {
 662         gboolean ret;
 663         MONO_PREPARE_BLOCKING;
 664
 665         *error=ERROR_SUCCESS;
 666
 667         ret=DeleteFile (mono_string_chars (path));
 668         if(ret==FALSE) {
 669                 *error=GetLastError ();
 670         }
 671
 672         MONO_FINISH_BLOCKING;
 673         return(ret);
 674 }
 675
 676 gint32
 677 ves_icall_System_IO_MonoIO_GetFileAttributes (MonoString *path, gint32 *error)
 678 {
 679         gint32 ret;
 680         MONO_PREPARE_BLOCKING;
 681
 682         *error=ERROR_SUCCESS;
 683
 684         ret=get_file_attributes (mono_string_chars (path));
 685
 686         /*
 687          * The definition of INVALID_FILE_ATTRIBUTES in the cygwin win32
 688          * headers is wrong, hence this temporary workaround.
 689          * See
 690          * http://cygwin.com/ml/cygwin/2003-09/msg01771.html
 691          */
 692         if (ret==-1) {
 693           /* if(ret==INVALID_FILE_ATTRIBUTES) { */
 694                 *error=GetLastError ();
 695         }
 696
 697         MONO_FINISH_BLOCKING;
 698         return(ret);
 699 }
 700
 701 MonoBoolean
 702 ves_icall_System_IO_MonoIO_SetFileAttributes (MonoString *path, gint32 attrs,
 703                                               gint32 *error)
 704 {
 705         gboolean ret;
 706         MONO_PREPARE_BLOCKING;
 707
 708         *error=ERROR_SUCCESS;
 709
 710         ret=SetFileAttributes (mono_string_chars (path),
 711                 convert_attrs ((MonoFileAttributes)attrs));
 712         if(ret==FALSE) {
 713                 *error=GetLastError ();
 714         }
 715
 716         MONO_FINISH_BLOCKING;
 717         return(ret);
 718 }
 719
 720 gint32
 721 ves_icall_System_IO_MonoIO_GetFileType (HANDLE handle, gint32 *error)
 722 {
 723         gboolean ret;
 724         MONO_PREPARE_BLOCKING;
 725
 726         *error=ERROR_SUCCESS;
 727
 728         ret=GetFileType (handle);
 729         if(ret==FILE_TYPE_UNKNOWN) {
 730                 /* Not necessarily an error, but the caller will have
 731                  * to decide based on the error value.
 732                  */
 733                 *error=GetLastError ();
 734         }
 735
 736         MONO_FINISH_BLOCKING;
 737         return(ret);
 738 }
 739
 740 MonoBoolean
 741 ves_icall_System_IO_MonoIO_GetFileStat (MonoString *path, MonoIOStat *stat,
 742                                         gint32 *error)
 743 {
 744         gboolean result;
 745         WIN32_FILE_ATTRIBUTE_DATA data;
 746         MONO_PREPARE_BLOCKING;
 747
 748         *error=ERROR_SUCCESS;
 749
 750         result = get_file_attributes_ex (mono_string_chars (path), &data);
 751
 752         if (result) {
 753                 convert_win32_file_attribute_data (&data, stat);
 754         } else {
 755                 *error=GetLastError ();
 756                 memset (stat, 0, sizeof (MonoIOStat));
 757         }
 758
 759         MONO_FINISH_BLOCKING;
 760         return result;
 761 }
 762
 763 HANDLE
 764 ves_icall_System_IO_MonoIO_Open (MonoString *filename, gint32 mode,
 765                                  gint32 access_mode, gint32 share, gint32 options,
 766                                  gint32 *error)
 767 {
 768         HANDLE ret;
 769         int attributes, attrs;
 770         gunichar2 *chars;
 771         MONO_PREPARE_BLOCKING;
 772
 773         chars = mono_string_chars (filename);
 774         *error=ERROR_SUCCESS;
 775
 776         if (options != 0){
 777                 if (options & FileOptions_Encrypted)
 778                         attributes = FILE_ATTRIBUTE_ENCRYPTED;
 779                 else
 780                         attributes = FILE_ATTRIBUTE_NORMAL;
 781                 if (options & FileOptions_DeleteOnClose)
 782                         attributes |= FILE_FLAG_DELETE_ON_CLOSE;
 783                 if (options & FileOptions_SequentialScan)
 784                         attributes |= FILE_FLAG_SEQUENTIAL_SCAN;
 785                 if (options & FileOptions_RandomAccess)
 786                         attributes |= FILE_FLAG_RANDOM_ACCESS;
 787
 788                 if (options & FileOptions_Temporary)
 789                         attributes |= FILE_ATTRIBUTE_TEMPORARY;
 790
 791                 /* Not sure if we should set FILE_FLAG_OVERLAPPED, how does this mix with the "Async" bool here? */
 792                 if (options & FileOptions_Asynchronous)
 793                         attributes |= FILE_FLAG_OVERLAPPED;
 794
 795                 if (options & FileOptions_WriteThrough)
 796                         attributes |= FILE_FLAG_WRITE_THROUGH;
 797         } else
 798                 attributes = FILE_ATTRIBUTE_NORMAL;
 799
 800         /* If we're opening a directory we need to set the extra flag
 801          */
 802         attrs = get_file_attributes (chars);
 803         if (attrs != INVALID_FILE_ATTRIBUTES) {
 804                 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
 805                         attributes |= FILE_FLAG_BACKUP_SEMANTICS;
 806                 }
 807         }
 808
 809         ret=CreateFile (chars, convert_access ((MonoFileAccess)access_mode),
 810                         convert_share ((MonoFileShare)share), NULL, convert_mode ((MonoFileMode)mode),
 811                         attributes, NULL);
 812         if(ret==INVALID_HANDLE_VALUE) {
 813                 *error=GetLastError ();
 814         }
 815
 816         MONO_FINISH_BLOCKING;
 817         return(ret);
 818 }
 819
 820 MonoBoolean
 821 ves_icall_System_IO_MonoIO_Close (HANDLE handle, gint32 *error)
 822 {
 823         gboolean ret;
 824         MONO_PREPARE_BLOCKING;
 825
 826         *error=ERROR_SUCCESS;
 827
 828         ret=CloseHandle (handle);
 829         if(ret==FALSE) {
 830                 *error=GetLastError ();
 831         }
 832
 833         MONO_FINISH_BLOCKING;
 834         return(ret);
 835 }
 836
 837 gint32
 838 ves_icall_System_IO_MonoIO_Read (HANDLE handle, MonoArray *dest,
 839                                  gint32 dest_offset, gint32 count,
 840                                  gint32 *error)
 841 {
 842         guchar *buffer;
 843         gboolean result;
 844         guint32 n;
 845
 846         *error=ERROR_SUCCESS;
 847
 848         MONO_CHECK_ARG_NULL (dest, 0);
 849
 850         if (dest_offset > mono_array_length (dest) - count) {
 851                 mono_set_pending_exception (mono_get_exception_argument ("array", "array too small. numBytes/offset wrong."));
 852                 return 0;
 853         }
 854
 855         buffer = mono_array_addr (dest, guchar, dest_offset);
 856
 857         MONO_PREPARE_BLOCKING;
 858         result = ReadFile (handle, buffer, count, &n, NULL);
 859         MONO_FINISH_BLOCKING;
 860
 861         if (!result) {
 862                 *error=GetLastError ();
 863                 return -1;
 864         }
 865
 866         return (gint32)n;
 867 }
 868
 869 gint32
 870 ves_icall_System_IO_MonoIO_Write (HANDLE handle, MonoArray *src,
 871                                   gint32 src_offset, gint32 count,
 872                                   gint32 *error)
 873 {
 874         guchar *buffer;
 875         gboolean result;
 876         guint32 n;
 877
 878         *error=ERROR_SUCCESS;
 879
 880         MONO_CHECK_ARG_NULL (src, 0);
 881
 882         if (src_offset > mono_array_length (src) - count) {
 883                 mono_set_pending_exception (mono_get_exception_argument ("array", "array too small. numBytes/offset wrong."));
 884                 return 0;
 885         }
 886
 887         buffer = mono_array_addr (src, guchar, src_offset);
 888         MONO_PREPARE_BLOCKING;
 889         result = WriteFile (handle, buffer, count, &n, NULL);
 890         MONO_FINISH_BLOCKING;
 891
 892         if (!result) {
 893                 *error=GetLastError ();
 894                 return -1;
 895         }
 896
 897         return (gint32)n;
 898 }
 899
 900 gint64
 901 ves_icall_System_IO_MonoIO_Seek (HANDLE handle, gint64 offset, gint32 origin,
 902                                  gint32 *error)
 903 {
 904         gint32 offset_hi;
 905         MONO_PREPARE_BLOCKING;
 906
 907         *error=ERROR_SUCCESS;
 908
 909         offset_hi = offset >> 32;
 910         offset = SetFilePointer (handle, (gint32) (offset & 0xFFFFFFFF), &offset_hi,
 911                                  convert_seekorigin ((MonoSeekOrigin)origin));
 912
 913         if(offset==INVALID_SET_FILE_POINTER) {
 914                 *error=GetLastError ();
 915         }
 916
 917         MONO_FINISH_BLOCKING;
 918         return offset | ((gint64)offset_hi << 32);
 919 }
 920
 921 MonoBoolean
 922 ves_icall_System_IO_MonoIO_Flush (HANDLE handle, gint32 *error)
 923 {
 924         gboolean ret;
 925         MONO_PREPARE_BLOCKING;
 926
 927         *error=ERROR_SUCCESS;
 928
 929         ret=FlushFileBuffers (handle);
 930         if(ret==FALSE) {
 931                 *error=GetLastError ();
 932         }
 933
 934         MONO_FINISH_BLOCKING;
 935         return(ret);
 936 }
 937
 938 gint64
 939 ves_icall_System_IO_MonoIO_GetLength (HANDLE handle, gint32 *error)
 940 {
 941         gint64 length;
 942         guint32 length_hi;
 943         MONO_PREPARE_BLOCKING;
 944
 945         *error=ERROR_SUCCESS;
 946
 947         length = GetFileSize (handle, &length_hi);
 948         if(length==INVALID_FILE_SIZE) {
 949                 *error=GetLastError ();
 950         }
 951
 952         MONO_FINISH_BLOCKING;
 953         return length | ((gint64)length_hi << 32);
 954 }
 955
 956 /* FIXME make gc suspendable */
 957 MonoBoolean
 958 ves_icall_System_IO_MonoIO_SetLength (HANDLE handle, gint64 length,
 959                                       gint32 *error)
 960 {
 961         gint64 offset, offset_set;
 962         gint32 offset_hi;
 963         gint32 length_hi;
 964         gboolean result;
 965
 966         *error=ERROR_SUCCESS;
 967
 968         /* save file pointer */
 969
 970         offset_hi = 0;
 971         offset = SetFilePointer (handle, 0, &offset_hi, FILE_CURRENT);
 972         if(offset==INVALID_SET_FILE_POINTER) {
 973                 *error=GetLastError ();
 974                 return(FALSE);
 975         }
 976
 977         /* extend or truncate */
 978
 979         length_hi = length >> 32;
 980         offset_set=SetFilePointer (handle, length & 0xFFFFFFFF, &length_hi,
 981                                    FILE_BEGIN);
 982         if(offset_set==INVALID_SET_FILE_POINTER) {
 983                 *error=GetLastError ();
 984                 return(FALSE);
 985         }
 986
 987         result = SetEndOfFile (handle);
 988         if(result==FALSE) {
 989                 *error=GetLastError ();
 990                 return(FALSE);
 991         }
 992
 993         /* restore file pointer */
 994
 995         offset_set=SetFilePointer (handle, offset & 0xFFFFFFFF, &offset_hi,
 996                                    FILE_BEGIN);
 997         if(offset_set==INVALID_SET_FILE_POINTER) {
 998                 *error=GetLastError ();
 999                 return(FALSE);
1000         }
1001
1002         return result;
1003 }
1004
1005 MonoBoolean
1006 ves_icall_System_IO_MonoIO_SetFileTime (HANDLE handle, gint64 creation_time,
1007                                         gint64 last_access_time,
1008                                         gint64 last_write_time, gint32 *error)
1009 {
1010         gboolean ret;
1011         const FILETIME *creation_filetime;
1012         const FILETIME *last_access_filetime;
1013         const FILETIME *last_write_filetime;
1014         MONO_PREPARE_BLOCKING;
1015
1016         *error=ERROR_SUCCESS;
1017
1018         if (creation_time < 0)
1019                 creation_filetime = NULL;
1020         else
1021                 creation_filetime = (FILETIME *)&creation_time;
1022
1023         if (last_access_time < 0)
1024                 last_access_filetime = NULL;
1025         else
1026                 last_access_filetime = (FILETIME *)&last_access_time;
1027
1028         if (last_write_time < 0)
1029                 last_write_filetime = NULL;
1030         else
1031                 last_write_filetime = (FILETIME *)&last_write_time;
1032
1033         ret=SetFileTime (handle, creation_filetime, last_access_filetime, last_write_filetime);
1034         if(ret==FALSE) {
1035                 *error=GetLastError ();
1036         }
1037
1038         MONO_FINISH_BLOCKING;
1039         return(ret);
1040 }
1041
1042 HANDLE
1043 ves_icall_System_IO_MonoIO_get_ConsoleOutput ()
1044 {
1045         return GetStdHandle (STD_OUTPUT_HANDLE);
1046 }
1047
1048 HANDLE
1049 ves_icall_System_IO_MonoIO_get_ConsoleInput ()
1050 {
1051         return GetStdHandle (STD_INPUT_HANDLE);
1052 }
1053
1054 HANDLE
1055 ves_icall_System_IO_MonoIO_get_ConsoleError ()
1056 {
1057         return GetStdHandle (STD_ERROR_HANDLE);
1058 }
1059
1060 MonoBoolean
1061 ves_icall_System_IO_MonoIO_CreatePipe (HANDLE *read_handle, HANDLE *write_handle, gint32 *error)
1062 {
1063         SECURITY_ATTRIBUTES attr;
1064         gboolean ret;
1065
1066         attr.nLength=sizeof(SECURITY_ATTRIBUTES);
1067         attr.bInheritHandle=TRUE;
1068         attr.lpSecurityDescriptor=NULL;
1069
1070         MONO_PREPARE_BLOCKING;
1071         ret=CreatePipe (read_handle, write_handle, &attr, 0);
1072         MONO_FINISH_BLOCKING;
1073
1074         if(ret==FALSE) {
1075                 *error = GetLastError ();
1076                 /* FIXME: throw an exception? */
1077                 return(FALSE);
1078         }
1079
1080         return(TRUE);
1081 }
1082
1083 MonoBoolean
1084 ves_icall_System_IO_MonoIO_DuplicateHandle (HANDLE source_process_handle, HANDLE source_handle,
1085                 HANDLE target_process_handle, HANDLE *target_handle, gint32 access, gint32 inherit, gint32 options, gint32 *error)
1086 {
1087         /* This is only used on Windows */
1088         gboolean ret;
1089
1090         MONO_PREPARE_BLOCKING;
1091         ret=DuplicateHandle (source_process_handle, source_handle, target_process_handle, target_handle, access, inherit, options);
1092         MONO_FINISH_BLOCKING;
1093
1094         if(ret==FALSE) {
1095                 *error = GetLastError ();
1096                 /* FIXME: throw an exception? */
1097                 return(FALSE);
1098         }
1099
1100         return(TRUE);
1101 }
1102
1103 gunichar2
1104 ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar ()
1105 {
1106 #if defined (TARGET_WIN32)
1107         return (gunichar2) ':'; /* colon */
1108 #else
1109         return (gunichar2) '/'; /* forward slash */
1110 #endif
1111 }
1112
1113 gunichar2
1114 ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar ()
1115 {
1116 #if defined (TARGET_WIN32)
1117         return (gunichar2) '\\';        /* backslash */
1118 #else
1119         return (gunichar2) '/'; /* forward slash */
1120 #endif
1121 }
1122
1123 gunichar2
1124 ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar ()
1125 {
1126 #if defined (TARGET_WIN32)
1127         return (gunichar2) '/'; /* forward slash */
1128 #else
1129         if (IS_PORTABILITY_SET)
1130                 return (gunichar2) '\\';        /* backslash */
1131         else
1132                 return (gunichar2) '/'; /* forward slash */
1133 #endif
1134 }
1135
1136 gunichar2
1137 ves_icall_System_IO_MonoIO_get_PathSeparator ()
1138 {
1139 #if defined (TARGET_WIN32)
1140         return (gunichar2) ';'; /* semicolon */
1141 #else
1142         return (gunichar2) ':'; /* colon */
1143 #endif
1144 }
1145
1146 static const gunichar2
1147 invalid_path_chars [] = {
1148 #if defined (TARGET_WIN32)
1149         0x0022,                         /* double quote, which seems allowed in MS.NET but should be rejected */
1150         0x003c,                         /* less than */
1151         0x003e,                         /* greater than */
1152         0x007c,                         /* pipe */
1153         0x0008,
1154         0x0010,
1155         0x0011,
1156         0x0012,
1157         0x0014,
1158         0x0015,
1159         0x0016,
1160         0x0017,
1161         0x0018,
1162         0x0019,
1163 #endif
1164         0x0000                          /* null */
1165 };
1166
1167 MonoArray *
1168 ves_icall_System_IO_MonoIO_get_InvalidPathChars ()
1169 {
1170         MonoArray *chars;
1171         MonoDomain *domain;
1172         int i, n;
1173
1174         domain = mono_domain_get ();
1175         n = sizeof (invalid_path_chars) / sizeof (gunichar2);
1176         chars = mono_array_new (domain, mono_defaults.char_class, n);
1177
1178         for (i = 0; i < n; ++ i)
1179                 mono_array_set (chars, gunichar2, i, invalid_path_chars [i]);
1180
1181         return chars;
1182 }
1183
1184 void ves_icall_System_IO_MonoIO_Lock (HANDLE handle, gint64 position,
1185                                       gint64 length, gint32 *error)
1186 {
1187         gboolean ret;
1188         MONO_PREPARE_BLOCKING;
1189
1190         *error=ERROR_SUCCESS;
1191
1192         ret=LockFile (handle, position & 0xFFFFFFFF, position >> 32,
1193                       length & 0xFFFFFFFF, length >> 32);
1194         if (ret == FALSE) {
1195                 *error = GetLastError ();
1196         }
1197
1198         MONO_FINISH_BLOCKING;
1199 }
1200
1201 void ves_icall_System_IO_MonoIO_Unlock (HANDLE handle, gint64 position,
1202                                         gint64 length, gint32 *error)
1203 {
1204         gboolean ret;
1205         MONO_PREPARE_BLOCKING;
1206
1207         *error=ERROR_SUCCESS;
1208
1209         ret=UnlockFile (handle, position & 0xFFFFFFFF, position >> 32,
1210                         length & 0xFFFFFFFF, length >> 32);
1211         if (ret == FALSE) {
1212                 *error = GetLastError ();
1213         }
1214
1215         MONO_FINISH_BLOCKING;
1216 }
1217
1218 //Support for io-layer free mmap'd files.
1219
1220 #if defined (TARGET_IOS) || defined (TARGET_ANDROID)
1221
1222 gint64
1223 mono_filesize_from_path (MonoString *string)
1224 {
1225         struct stat buf;
1226         gint64 res;
1227         char *path = mono_string_to_utf8 (string);
1228
1229         MONO_PREPARE_BLOCKING;
1230         if (stat (path, &buf) == -1)
1231                 res = -1;
1232         else
1233                 res = (gint64)buf.st_size;
1234
1235         g_free (path);
1236
1237         MONO_FINISH_BLOCKING;
1238         return res;
1239 }
1240
1241 gint64
1242 mono_filesize_from_fd (int fd)
1243 {
1244         struct stat buf;
1245         int res;
1246
1247         MONO_PREPARE_BLOCKING;
1248         res = fstat (fd, &buf);
1249         MONO_FINISH_BLOCKING;
1250
1251         if (res == -1)
1252                 return (gint64)-1;
1253
1254         return (gint64)buf.st_size;
1255 }
1256
1257 #endif
1258
1259 void _wapi_handle_dump (void);
1260
1261 void ves_icall_System_IO_MonoIO_DumpHandles (void)
1262 {
1263 #ifndef HOST_WIN32
1264         _wapi_handle_dump ();
1265 #endif
1266 }