#include <config.h>
|
#include <glib.h>
|
|
|
|
#include "Directory-c-api.h"
|
#include "File-c-api.h"
|
#include "w32error.h"
|
#include "w32file.h"
|
#include "utils/strenc.h"
|
#include <mono/metadata/w32handle.h>
|
|
|
#ifdef HOST_WIN32
|
|
gunichar2
|
ves_icall_System_IO_MonoIO_get_VolumeSeparatorChar ()
|
{
|
return (gunichar2) ':'; /* colon */
|
}
|
|
gunichar2
|
ves_icall_System_IO_MonoIO_get_DirectorySeparatorChar ()
|
{
|
return (gunichar2) '\\'; /* backslash */
|
}
|
|
gunichar2
|
ves_icall_System_IO_MonoIO_get_AltDirectorySeparatorChar ()
|
{
|
return (gunichar2) '/'; /* forward slash */
|
}
|
|
gunichar2
|
ves_icall_System_IO_MonoIO_get_PathSeparator ()
|
{
|
return (gunichar2) ';'; /* semicolon */
|
}
|
|
void ves_icall_System_IO_MonoIO_DumpHandles (void)
|
{
|
return;
|
}
|
#endif /* HOST_WIN32 */
|
|
gpointer
|
mono_w32file_create(const gunichar2 *name, guint32 fileaccess, guint32 sharemode, guint32 createmode, guint32 attrs)
|
{
|
int error = 0;
|
gpointer handle;
|
gchar* palPath = mono_unicode_to_external(name);
|
handle = UnityPalOpen(palPath, (int) createmode, (int) fileaccess, (int) sharemode, attrs, &error);
|
mono_w32error_set_last(error);
|
g_free(palPath);
|
|
if (handle == NULL)
|
return INVALID_HANDLE_VALUE;
|
|
return handle;
|
}
|
|
gboolean
|
mono_w32file_close (gpointer handle)
|
{
|
if (handle == NULL)
|
return FALSE;
|
|
int error = 0;
|
gboolean result = UnityPalClose(handle, &error);
|
mono_w32error_set_last(error);
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_read(gpointer handle, gpointer buffer, guint32 numbytes, guint32 *bytesread)
|
{
|
int error = 0;
|
|
*bytesread = UnityPalRead(handle, buffer, numbytes, &error);
|
mono_w32error_set_last(error);
|
|
return TRUE;
|
}
|
|
gboolean
|
mono_w32file_write (gpointer handle, gconstpointer buffer, guint32 numbytes, guint32 *byteswritten)
|
{
|
int error = 0;
|
|
*byteswritten = UnityPalWrite(handle, buffer, numbytes, &error);
|
mono_w32error_set_last(error);
|
|
return (*byteswritten > 0);
|
}
|
|
gboolean
|
mono_w32file_flush (gpointer handle)
|
{
|
int error = 0;
|
|
gboolean result = UnityPalFlush(handle, &error);
|
mono_w32error_set_last(error);
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_truncate (gpointer handle)
|
{
|
int error = 0;
|
|
gboolean result = UnityPalTruncate(handle, &error);
|
mono_w32error_set_last(error);
|
|
return result;
|
}
|
|
guint32
|
mono_w32file_seek (gpointer handle, gint32 movedistance, gint32 *highmovedistance, guint32 method)
|
{
|
int error = 0;
|
|
int32_t result = UnityPalSeek(handle, movedistance, 0, &error);
|
mono_w32error_set_last(error);
|
|
return result;
|
}
|
|
gint
|
mono_w32file_get_type (gpointer handle)
|
{
|
if (handle == NULL)
|
return 0;
|
|
return UnityPalGetFileType(handle);
|
}
|
|
gboolean
|
mono_w32file_get_times (gpointer handle, FILETIME *create_time, FILETIME *access_time, FILETIME *write_time)
|
{
|
/* Not Supported in UnityPAL */
|
g_assert_not_reached();
|
}
|
|
gboolean
|
mono_w32file_set_times (gpointer handle, const FILETIME *create_time, const FILETIME *access_time, const FILETIME *write_time)
|
{
|
int error = 0;
|
|
gboolean result = UnityPalSetFileTime(handle, create_time, access_time, write_time, &error);
|
mono_w32error_set_last(error);
|
|
return result;
|
}
|
|
gpointer
|
mono_w32file_find_first (const gunichar2 *pattern, WIN32_FIND_DATA *find_data)
|
{
|
gchar* palPath = mono_unicode_to_external(pattern);
|
UnityPalFindHandle* findHandle = UnityPalDirectoryFindHandleNew(palPath);
|
int32_t resultAttributes = 0;
|
|
int32_t result = 0;
|
const char* filename;
|
|
result = UnityPalDirectoryFindFirstFile(findHandle, palPath, &filename, &resultAttributes);
|
|
if (result != 0)
|
{
|
mono_w32error_set_last(result);
|
return INVALID_HANDLE_VALUE;
|
}
|
|
find_data->dwFileAttributes = resultAttributes;
|
|
gunichar2 *utf16_basename;
|
glong bytes;
|
utf16_basename = g_utf8_to_utf16 (filename, -1, NULL, &bytes, NULL);
|
|
/* this next section of memset and memcpy is code from mono, the cFileName field is
|
gunichar2 cFileName [MAX_PATH].
|
Notes from mono:
|
Truncating a utf16 string like this might leave the last
|
gchar incomplete
|
utf16 is 2 * utf8
|
*/
|
bytes *= 2;
|
memset (find_data->cFileName, '\0', (MAX_PATH * 2));
|
memcpy (find_data->cFileName, utf16_basename, bytes < (MAX_PATH * 2) - 2 ? bytes : (MAX_PATH * 2) - 2);
|
|
g_free(filename);
|
g_free(palPath);
|
g_free(utf16_basename);
|
|
find_data->dwReserved0 = 0;
|
find_data->dwReserved1 = 0;
|
|
find_data->cAlternateFileName [0] = 0;
|
|
return findHandle;
|
}
|
|
gboolean
|
mono_w32file_find_next (gpointer handle, WIN32_FIND_DATA *find_data)
|
{
|
|
int32_t resultAttributes = 0;
|
int32_t result;
|
const char* filename;
|
|
result = UnityPalDirectoryFindNextFile(handle, &filename, &resultAttributes);
|
|
find_data->dwFileAttributes = resultAttributes;
|
gunichar2 *utf16_basename;
|
glong bytes;
|
utf16_basename = g_utf8_to_utf16 (filename, -1, NULL, &bytes, NULL);
|
bytes *= 2;
|
|
memset (find_data->cFileName, '\0', (MAX_PATH * 2));
|
memcpy (find_data->cFileName, utf16_basename, bytes < (MAX_PATH * 2) - 2 ? bytes : (MAX_PATH * 2) - 2);
|
|
g_free(filename);
|
g_free(utf16_basename);
|
|
find_data->dwReserved0 = 0;
|
find_data->dwReserved1 = 0;
|
|
find_data->cAlternateFileName [0] = 0;
|
|
return (result == 0);
|
}
|
|
gboolean
|
mono_w32file_find_close (gpointer handle)
|
{
|
gboolean result = UnityPalDirectoryCloseOSHandle(handle);
|
UnityPalDirectoryFindHandleDelete(handle);
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_create_directory (const gunichar2 *name)
|
{
|
int error = 0;
|
|
gchar* palPath = mono_unicode_to_external(name);
|
gboolean result = UnityPalDirectoryCreate(palPath, &error);
|
mono_w32error_set_last(error);
|
g_free(palPath);
|
|
return result;
|
}
|
|
guint32
|
mono_w32file_get_attributes (const gunichar2 *name)
|
{
|
int error = 0;
|
|
gchar* palPath = mono_unicode_to_external(name);
|
guint32 result = UnityPalGetFileAttributes(palPath, &error);
|
mono_w32error_set_last(error);
|
g_free(palPath);
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_get_attributes_ex (const gunichar2 *name, MonoIOStat *stat)
|
{
|
gboolean result;
|
UnityPalFileStat palStat;
|
int error = 0;
|
|
gchar* palPath = mono_unicode_to_external(name);
|
result = UnityPalGetFileStat(palPath, &palStat, &error);
|
mono_w32error_set_last(error);
|
|
if (result) {
|
stat->attributes = palStat.attributes;
|
stat->creation_time = palStat.creation_time;
|
stat->last_access_time = palStat.last_access_time;
|
stat->last_write_time = palStat.last_write_time;
|
stat->length = palStat.length;
|
}
|
g_free(palPath);
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_set_attributes (const gunichar2 *name, guint32 attrs)
|
{
|
int error = 0;
|
|
gchar* palPath = mono_unicode_to_external(name);
|
gboolean result = UnityPalSetFileAttributes(palPath, attrs, &error);
|
mono_w32error_set_last(error);
|
g_free(palPath);
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_create_pipe (gpointer *readpipe, gpointer *writepipe, guint32 size)
|
{
|
return UnityPalCreatePipe(*readpipe, *writepipe);
|
}
|
|
gboolean
|
mono_w32file_get_disk_free_space (const gunichar2 *path_name, guint64 *free_bytes_avail, guint64 *total_number_of_bytes, guint64 *total_number_of_free_bytes)
|
{
|
g_assert_not_reached();
|
return FALSE;
|
}
|
|
gboolean
|
mono_w32file_get_volume_information (const gunichar2 *path, gunichar2 *volumename, gint volumesize, gint *outserial, gint *maxcomp, gint *fsflags, gunichar2 *fsbuffer, gint fsbuffersize)
|
{
|
g_assert_not_reached();
|
return FALSE;
|
}
|
|
gboolean
|
mono_w32file_move (const gunichar2 *path, const gunichar2 *dest, gint32 *error)
|
{
|
gboolean result;
|
*error = 0;
|
MONO_ENTER_GC_SAFE;
|
|
gchar* palPath = mono_unicode_to_external(path);
|
gchar* palDest = mono_unicode_to_external(dest);
|
result = UnityPalMoveFile(palPath, palDest, error);
|
mono_w32error_set_last(*error);
|
g_free(palPath);
|
g_free(palDest);
|
|
MONO_EXIT_GC_SAFE;
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_replace (const gunichar2 *destination_file_name, const gunichar2 *source_file_name, const gunichar2 *destination_backup_file_name, guint32 flags, gint32 *error)
|
{
|
gboolean result;
|
gchar* destPath = NULL;
|
gchar* sourcePath = NULL;
|
gchar* destBackupPath = NULL;
|
|
if (destination_file_name != NULL)
|
{
|
destPath = mono_unicode_to_external(destination_file_name);
|
}
|
|
if (source_file_name != NULL)
|
{
|
sourcePath = mono_unicode_to_external(source_file_name);
|
}
|
|
if (destination_backup_file_name != NULL)
|
{
|
destBackupPath = mono_unicode_to_external(destination_backup_file_name);
|
}
|
|
MONO_ENTER_GC_SAFE;
|
|
result = UnityPalReplaceFile(sourcePath, destPath, destBackupPath, 0, error);
|
mono_w32error_set_last(*error);
|
|
MONO_EXIT_GC_SAFE;
|
|
g_free(destPath);
|
g_free(sourcePath);
|
g_free(destBackupPath);
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_copy (const gunichar2 *path, const gunichar2 *dest, gboolean overwrite, gint32 *error)
|
{
|
gboolean result;
|
*error = 0;
|
|
MONO_ENTER_GC_SAFE;
|
|
gchar* palPath = mono_unicode_to_external(path);
|
gchar* palDest = mono_unicode_to_external(dest);
|
result = UnityPalCopyFile(palPath, palDest, overwrite, error);
|
mono_w32error_set_last(*error);
|
g_free(palPath);
|
g_free(palDest);
|
|
MONO_EXIT_GC_SAFE;
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_lock (gpointer handle, gint64 position, gint64 length, gint32 *error)
|
{
|
MONO_ENTER_GC_SAFE;
|
|
UnityPalLock(handle, position, length, error);
|
mono_w32error_set_last(*error);
|
|
MONO_EXIT_GC_SAFE;
|
|
return (*error == 0);
|
}
|
|
gboolean
|
mono_w32file_unlock (gpointer handle, gint64 position, gint64 length, gint32 *error)
|
{
|
MONO_ENTER_GC_SAFE;
|
|
UnityPalUnlock(handle, position, length, error);
|
mono_w32error_set_last(*error);
|
|
MONO_EXIT_GC_SAFE;
|
|
return (*error == 0);
|
}
|
|
gpointer
|
mono_w32file_get_console_input (void)
|
{
|
return UnityPalGetStdInput();
|
}
|
|
gpointer
|
mono_w32file_get_console_output (void)
|
{
|
return UnityPalGetStdOutput();
|
}
|
|
gpointer
|
mono_w32file_get_console_error (void)
|
{
|
return UnityPalGetStdError();
|
}
|
|
gint64
|
mono_w32file_get_file_size (gpointer handle, gint32 *error)
|
{
|
gint64 length;
|
|
MONO_ENTER_GC_SAFE;
|
|
length = UnityPalGetLength(handle, error);
|
mono_w32error_set_last(*error);
|
|
MONO_EXIT_GC_SAFE;
|
|
return length;
|
}
|
|
guint32
|
mono_w32file_get_drive_type (const gunichar2 *root_path_name)
|
{
|
return 0;
|
}
|
|
gint32
|
mono_w32file_get_logical_drive (guint32 len, gunichar2 *buf)
|
{
|
return -1;
|
}
|
|
gboolean
|
mono_w32file_remove_directory (const gunichar2 *name)
|
{
|
int error = 0;
|
|
gchar* palPath = mono_unicode_to_external (name);
|
gboolean result = UnityPalDirectoryRemove(palPath, &error);
|
mono_w32error_set_last(error);
|
g_free(palPath);
|
|
return result;
|
}
|
|
gboolean mono_w32file_delete(const gunichar2 *name)
|
{
|
int error = 0;
|
|
gchar* palPath = mono_unicode_to_external (name);
|
gboolean result = UnityPalDeleteFile(palPath, &error);
|
mono_w32error_set_last (error);
|
g_free(palPath);
|
|
return result;
|
}
|
|
guint32
|
mono_w32file_get_cwd (guint32 length, gunichar2 *buffer)
|
{
|
/* length is the number of characters in buffer, including the null terminator */
|
/* count is the number of characters in the current directory, including the null terminator */
|
gunichar2 *utf16_path;
|
glong count;
|
uintptr_t bytes;
|
int error = 0;
|
|
const char* palPath = UnityPalDirectoryGetCurrent(&error);
|
mono_w32error_set_last (error);
|
utf16_path = mono_unicode_from_external(palPath, &bytes);
|
count = (bytes / 2) + 1;
|
|
if (count <= length) {
|
/* Add the terminator */
|
memset (buffer, '\0', bytes+2);
|
memcpy (buffer, utf16_path, bytes);
|
}
|
|
g_free(utf16_path);
|
g_free(palPath);
|
|
return count;
|
}
|
|
gboolean
|
mono_w32file_set_cwd (const gunichar2 *path)
|
{
|
int error = 0;
|
|
gchar* palPath = mono_unicode_to_external(path);
|
gboolean result = UnityPalDirectorySetCurrent(palPath, &error);
|
mono_w32error_set_last (error);
|
g_free(palPath);
|
|
return result;
|
}
|
|
gboolean
|
mono_w32file_set_length (gpointer handle, gint64 length, gint32 *error)
|
{
|
gboolean result = UnityPalSetLength(handle, length, error);
|
mono_w32error_set_last(*error);
|
|
return result;
|
}
|
|
void
|
mono_w32file_cleanup (void)
|
{
|
}
|
|
void
|
mono_w32file_init (void)
|
{
|
}
|
