mono/metadata/file-io.c

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