| /* |
| * File handling functions |
| * |
| * Copyright 1993 John Burton |
| * Copyright 1996 Alexandre Julliard |
| * |
| * TODO: |
| * Fix the CopyFileEx methods to implement the "extented" functionality. |
| * Right now, they simply call the CopyFile method. |
| */ |
| |
| #include <assert.h> |
| #include <ctype.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/errno.h> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include <sys/mman.h> |
| #include <sys/time.h> |
| #include <time.h> |
| #include <unistd.h> |
| #include <utime.h> |
| |
| #include "windows.h" |
| #include "winerror.h" |
| #include "drive.h" |
| #include "file.h" |
| #include "global.h" |
| #include "heap.h" |
| #include "msdos.h" |
| #include "options.h" |
| #include "ldt.h" |
| #include "process.h" |
| #include "task.h" |
| #include "async.h" |
| #include "debug.h" |
| |
| #include "server/request.h" |
| #include "server.h" |
| |
| #if defined(MAP_ANONYMOUS) && !defined(MAP_ANON) |
| #define MAP_ANON MAP_ANONYMOUS |
| #endif |
| |
| static BOOL32 FILE_Signaled(K32OBJ *ptr, DWORD tid); |
| static BOOL32 FILE_Satisfied(K32OBJ *ptr, DWORD thread_id); |
| static void FILE_AddWait(K32OBJ *ptr, DWORD tid); |
| static void FILE_RemoveWait(K32OBJ *ptr, DWORD thread_id); |
| static BOOL32 FILE_Read(K32OBJ *ptr, LPVOID lpBuffer, DWORD nNumberOfChars, |
| LPDWORD lpNumberOfChars, LPOVERLAPPED lpOverlapped); |
| static BOOL32 FILE_Write(K32OBJ *ptr, LPCVOID lpBuffer, DWORD nNumberOfChars, |
| LPDWORD lpNumberOfChars, LPOVERLAPPED lpOverlapped); |
| static void FILE_Destroy( K32OBJ *obj ); |
| |
| const K32OBJ_OPS FILE_Ops = |
| { |
| FILE_Signaled, /* signaled */ |
| FILE_Satisfied, /* satisfied */ |
| FILE_AddWait, /* add_wait */ |
| FILE_RemoveWait, /* remove_wait */ |
| FILE_Read, /* read */ |
| FILE_Write, /* write */ |
| FILE_Destroy /* destroy */ |
| }; |
| |
| struct DOS_FILE_LOCK { |
| struct DOS_FILE_LOCK * next; |
| DWORD base; |
| DWORD len; |
| DWORD processId; |
| FILE_OBJECT * dos_file; |
| char * unix_name; |
| }; |
| |
| typedef struct DOS_FILE_LOCK DOS_FILE_LOCK; |
| |
| static DOS_FILE_LOCK *locks = NULL; |
| static void DOS_RemoveFileLocks(FILE_OBJECT *file); |
| |
| /*********************************************************************** |
| * FILE_Alloc |
| * |
| * Allocate a file. The unix_handle is closed. |
| */ |
| HFILE32 FILE_Alloc( FILE_OBJECT **file, int unix_handle ) |
| { |
| HFILE32 handle; |
| struct create_file_request req; |
| struct create_file_reply reply; |
| int len; |
| int fd = dup(unix_handle); |
| |
| req.access = FILE_ALL_ACCESS | GENERIC_READ | |
| GENERIC_WRITE | GENERIC_EXECUTE; /* FIXME */ |
| req.inherit = 1; /* FIXME */ |
| CLIENT_SendRequest( REQ_CREATE_FILE, unix_handle, 1, &req, sizeof(req) ); |
| CLIENT_WaitReply( &len, NULL, 1, &reply, sizeof(reply) ); |
| CHECK_LEN( len, sizeof(reply) ); |
| if (reply.handle == -1) return INVALID_HANDLE_VALUE32; |
| |
| *file = HeapAlloc( SystemHeap, 0, sizeof(FILE_OBJECT) ); |
| if (!*file) |
| { |
| DOS_ERROR( ER_TooManyOpenFiles, EC_ProgramError, SA_Abort, EL_Disk ); |
| CLIENT_CloseHandle( reply.handle ); |
| return (HFILE32)NULL; |
| } |
| (*file)->header.type = K32OBJ_FILE; |
| (*file)->header.refcount = 0; |
| (*file)->unix_name = NULL; |
| (*file)->unix_handle = fd; |
| (*file)->type = FILE_TYPE_DISK; |
| (*file)->pos = 0; |
| (*file)->mode = 0; |
| (*file)->wait_queue = NULL; |
| |
| handle = HANDLE_Alloc( PROCESS_Current(), &(*file)->header, req.access, |
| req.inherit, reply.handle ); |
| /* If the allocation failed, the object is already destroyed */ |
| if (handle == INVALID_HANDLE_VALUE32) *file = NULL; |
| return handle; |
| } |
| |
| /*********************************************************************** |
| * FILE_async_handler [internal] |
| */ |
| #if 1 |
| static void |
| FILE_async_handler(int unixfd,void *private) { |
| FILE_OBJECT *file = (FILE_OBJECT*)private; |
| |
| SYNC_WakeUp(&file->wait_queue,INFINITE32); |
| } |
| |
| static BOOL32 FILE_Signaled(K32OBJ *ptr, DWORD thread_id) |
| { |
| fd_set fds,*readfds = NULL,*writefds = NULL; |
| struct timeval tv; |
| FILE_OBJECT *file = (FILE_OBJECT *)ptr; |
| |
| FD_ZERO(&fds); |
| FD_SET(file->unix_handle,&fds); |
| if (file->mode == OF_READ) readfds = &fds; |
| if (file->mode == OF_WRITE) writefds = &fds; |
| if (file->mode == OF_READWRITE) {writefds = &fds; readfds = &fds;} |
| tv.tv_sec = 0; |
| tv.tv_usec = 0; |
| assert(readfds || writefds); |
| if (select(file->unix_handle+1,readfds,writefds,NULL,&tv)>0) |
| return TRUE; /* we triggered one fd. Whereever. */ |
| return FALSE; |
| } |
| |
| static void FILE_AddWait(K32OBJ *ptr, DWORD thread_id) |
| { |
| FILE_OBJECT *file = (FILE_OBJECT*)ptr; |
| if (!file->wait_queue) |
| ASYNC_RegisterFD(file->unix_handle,FILE_async_handler,file); |
| THREAD_AddQueue(&file->wait_queue,thread_id); |
| } |
| |
| static void FILE_RemoveWait(K32OBJ *ptr, DWORD thread_id) |
| { |
| FILE_OBJECT *file = (FILE_OBJECT*)ptr; |
| THREAD_RemoveQueue(&file->wait_queue,thread_id); |
| if (!file->wait_queue) |
| ASYNC_UnregisterFD(file->unix_handle,FILE_async_handler); |
| } |
| |
| static BOOL32 FILE_Satisfied(K32OBJ *ptr, DWORD thread_id) |
| { |
| return FALSE; /* not abandoned. Hmm? */ |
| } |
| #endif |
| |
| /* FIXME: lpOverlapped is ignored */ |
| static BOOL32 FILE_Read(K32OBJ *ptr, LPVOID lpBuffer, DWORD nNumberOfChars, |
| LPDWORD lpNumberOfChars, LPOVERLAPPED lpOverlapped) |
| { |
| FILE_OBJECT *file = (FILE_OBJECT *)ptr; |
| int result; |
| |
| TRACE(file, "%p %p %ld\n", ptr, lpBuffer, |
| nNumberOfChars); |
| |
| if (nNumberOfChars == 0) { |
| *lpNumberOfChars = 0; /* FIXME: does this change */ |
| return TRUE; |
| } |
| |
| if ( (file->pos < 0) || /* workaround, see SetFilePointer */ |
| ((result = read(file->unix_handle, lpBuffer, nNumberOfChars)) == -1) ) |
| { |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| file->pos += result; |
| *lpNumberOfChars = result; |
| return TRUE; |
| } |
| |
| /** |
| * experimentation yields that WriteFile: |
| * o does not truncate on write of 0 |
| * o always changes the *lpNumberOfChars to actual number of |
| * characters written |
| * o write of 0 nNumberOfChars returns TRUE |
| */ |
| static BOOL32 FILE_Write(K32OBJ *ptr, LPCVOID lpBuffer, DWORD nNumberOfChars, |
| LPDWORD lpNumberOfChars, LPOVERLAPPED lpOverlapped) |
| { |
| FILE_OBJECT *file = (FILE_OBJECT *)ptr; |
| int result; |
| |
| TRACE(file, "%p %p %ld\n", ptr, lpBuffer, |
| nNumberOfChars); |
| |
| *lpNumberOfChars = 0; |
| |
| /* |
| * I assume this loop around EAGAIN is here because |
| * win32 doesn't have interrupted system calls |
| */ |
| |
| if (file->pos < 0) { /* workaround, see SetFilePointer */ |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| |
| for (;;) |
| { |
| result = write(file->unix_handle, lpBuffer, nNumberOfChars); |
| if (result != -1) { |
| *lpNumberOfChars = result; |
| file->pos += result; |
| return TRUE; |
| } |
| if (errno != EINTR) { |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| } |
| } |
| |
| |
| |
| /*********************************************************************** |
| * FILE_Destroy |
| * |
| * Destroy a DOS file. |
| */ |
| static void FILE_Destroy( K32OBJ *ptr ) |
| { |
| FILE_OBJECT *file = (FILE_OBJECT *)ptr; |
| assert( ptr->type == K32OBJ_FILE ); |
| |
| DOS_RemoveFileLocks(file); |
| |
| if (file->unix_name) HeapFree( SystemHeap, 0, file->unix_name ); |
| ptr->type = K32OBJ_UNKNOWN; |
| HeapFree( SystemHeap, 0, file ); |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_GetFile |
| * |
| * Return the DOS file associated to a task file handle. FILE_ReleaseFile must |
| * be called to release the file. |
| */ |
| FILE_OBJECT *FILE_GetFile( HFILE32 handle, DWORD access, int *server_handle ) |
| { |
| return (FILE_OBJECT *)HANDLE_GetObjPtr( PROCESS_Current(), handle, |
| K32OBJ_FILE, access, |
| server_handle ); |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_ReleaseFile |
| * |
| * Release a DOS file obtained with FILE_GetFile. |
| */ |
| void FILE_ReleaseFile( FILE_OBJECT *file ) |
| { |
| K32OBJ_DecCount( &file->header ); |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_GetUnixHandle |
| * |
| * Return the Unix handle associated to a file handle. |
| * The Unix handle must be closed after use. |
| */ |
| int FILE_GetUnixHandle( HFILE32 hFile, DWORD access ) |
| { |
| FILE_OBJECT *file; |
| int unix_handle; |
| struct get_unix_handle_request req; |
| |
| file = (FILE_OBJECT *)HANDLE_GetObjPtr( PROCESS_Current(), hFile, |
| K32OBJ_FILE, access, &req.handle ); |
| if (!file) return -1; |
| req.access = access; |
| CLIENT_SendRequest( REQ_GET_UNIX_HANDLE, -1, 1, &req, sizeof(req) ); |
| CLIENT_WaitReply( NULL, &unix_handle, 0 ); |
| K32OBJ_DecCount( &file->header ); |
| return unix_handle; |
| } |
| |
| /*********************************************************************** |
| * FILE_UnixToDosMode |
| * |
| * PARAMS |
| * unixmode[I] |
| * RETURNS |
| * dosmode |
| */ |
| static int FILE_UnixToDosMode(int unixMode) |
| { |
| int dosMode; |
| switch(unixMode & 3) |
| { |
| case O_WRONLY: |
| dosMode = OF_WRITE; |
| break; |
| case O_RDWR: |
| dosMode =OF_READWRITE; |
| break; |
| case O_RDONLY: |
| default: |
| dosMode = OF_READ; |
| break; |
| } |
| return dosMode; |
| } |
| |
| /*********************************************************************** |
| * FILE_DOSToUnixMode |
| * |
| * PARAMS |
| * dosMode[I] |
| * RETURNS |
| * unixmode |
| */ |
| static int FILE_DOSToUnixMode(int dosMode) |
| { |
| int unixMode; |
| switch(dosMode & 3) |
| { |
| case OF_WRITE: |
| unixMode = O_WRONLY; break; |
| case OF_READWRITE: |
| unixMode = O_RDWR; break; |
| case OF_READ: |
| default: |
| unixMode = O_RDONLY; break; |
| } |
| return unixMode; |
| } |
| |
| /*********************************************************************** |
| * FILE_ShareDeny |
| * |
| * PARAMS |
| * oldmode[I] mode how file was first opened |
| * mode[I] mode how the file should get opened |
| * RETURNS |
| * TRUE: deny open |
| * FALSE: allow open |
| * |
| * Look what we have to do with the given SHARE modes |
| * |
| * Ralph Brown's interrupt list gives following explication, I guess |
| * the same holds for Windows, DENY ALL should be OF_SHARE_COMPAT |
| * |
| * FIXME: Validate this function |
| ========from Ralph Brown's list ========= |
| (Table 0750) |
| Values of DOS file sharing behavior: |
| | Second and subsequent Opens |
| First |Compat Deny Deny Deny Deny |
| Open | All Write Read None |
| |R W RW R W RW R W RW R W RW R W RW |
| - - - - -| - - - - - - - - - - - - - - - - - |
| Compat R |Y Y Y N N N 1 N N N N N 1 N N |
| W |Y Y Y N N N N N N N N N N N N |
| RW|Y Y Y N N N N N N N N N N N N |
| - - - - -| |
| Deny R |C C C N N N N N N N N N N N N |
| All W |C C C N N N N N N N N N N N N |
| RW|C C C N N N N N N N N N N N N |
| - - - - -| |
| Deny R |2 C C N N N Y N N N N N Y N N |
| Write W |C C C N N N N N N Y N N Y N N |
| RW|C C C N N N N N N N N N Y N N |
| - - - - -| |
| Deny R |C C C N N N N Y N N N N N Y N |
| Read W |C C C N N N N N N N Y N N Y N |
| RW|C C C N N N N N N N N N N Y N |
| - - - - -| |
| Deny R |2 C C N N N Y Y Y N N N Y Y Y |
| None W |C C C N N N N N N Y Y Y Y Y Y |
| RW|C C C N N N N N N N N N Y Y Y |
| Legend: Y = open succeeds, N = open fails with error code 05h |
| C = open fails, INT 24 generated |
| 1 = open succeeds if file read-only, else fails with error code |
| 2 = open succeeds if file read-only, else fails with INT 24 |
| ========end of description from Ralph Brown's List ===== |
| For every "Y" in the table we return FALSE |
| For every "N" we set the DOS_ERROR and return TRUE |
| For all other cases we barf,set the DOS_ERROR and return TRUE |
| |
| */ |
| static BOOL32 FILE_ShareDeny( int mode, int oldmode) |
| { |
| int oldsharemode = oldmode & 0x70; |
| int sharemode = mode & 0x70; |
| int oldopenmode = oldmode & 3; |
| int openmode = mode & 3; |
| |
| switch (oldsharemode) |
| { |
| case OF_SHARE_COMPAT: |
| if (sharemode == OF_SHARE_COMPAT) return FALSE; |
| if (openmode == OF_READ) goto test_ro_err05 ; |
| goto fail_error05; |
| case OF_SHARE_EXCLUSIVE: |
| if (sharemode == OF_SHARE_COMPAT) goto fail_int24; |
| goto fail_error05; |
| case OF_SHARE_DENY_WRITE: |
| if (openmode != OF_READ) |
| { |
| if (sharemode == OF_SHARE_COMPAT) goto fail_int24; |
| goto fail_error05; |
| } |
| switch (sharemode) |
| { |
| case OF_SHARE_COMPAT: |
| if (oldopenmode == OF_READ) goto test_ro_int24 ; |
| goto fail_int24; |
| case OF_SHARE_DENY_NONE : |
| return FALSE; |
| case OF_SHARE_DENY_WRITE : |
| if (oldopenmode == OF_READ) return FALSE; |
| case OF_SHARE_DENY_READ : |
| if (oldopenmode == OF_WRITE) return FALSE; |
| case OF_SHARE_EXCLUSIVE: |
| default: |
| goto fail_error05; |
| } |
| break; |
| case OF_SHARE_DENY_READ: |
| if (openmode != OF_WRITE) |
| { |
| if (sharemode == OF_SHARE_COMPAT) goto fail_int24; |
| goto fail_error05; |
| } |
| switch (sharemode) |
| { |
| case OF_SHARE_COMPAT: |
| goto fail_int24; |
| case OF_SHARE_DENY_NONE : |
| return FALSE; |
| case OF_SHARE_DENY_WRITE : |
| if (oldopenmode == OF_READ) return FALSE; |
| case OF_SHARE_DENY_READ : |
| if (oldopenmode == OF_WRITE) return FALSE; |
| case OF_SHARE_EXCLUSIVE: |
| default: |
| goto fail_error05; |
| } |
| break; |
| case OF_SHARE_DENY_NONE: |
| switch (sharemode) |
| { |
| case OF_SHARE_COMPAT: |
| goto fail_int24; |
| case OF_SHARE_DENY_NONE : |
| return FALSE; |
| case OF_SHARE_DENY_WRITE : |
| if (oldopenmode == OF_READ) return FALSE; |
| case OF_SHARE_DENY_READ : |
| if (oldopenmode == OF_WRITE) return FALSE; |
| case OF_SHARE_EXCLUSIVE: |
| default: |
| goto fail_error05; |
| } |
| default: |
| ERR(file,"unknown mode\n"); |
| } |
| ERR(file,"shouldn't happen\n"); |
| ERR(file,"Please report to bon@elektron.ikp.physik.tu-darmstadt.de\n"); |
| return TRUE; |
| |
| test_ro_int24: |
| if (oldmode == OF_READ) |
| return FALSE; |
| /* Fall through */ |
| fail_int24: |
| FIXME(file,"generate INT24 missing\n"); |
| /* Is this the right error? */ |
| DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk ); |
| return TRUE; |
| |
| test_ro_err05: |
| if (oldmode == OF_READ) |
| return FALSE; |
| /* fall through */ |
| fail_error05: |
| TRACE(file,"Access Denied, oldmode 0x%02x mode 0x%02x\n",oldmode,mode); |
| DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk ); |
| return TRUE; |
| } |
| |
| |
| |
| /*********************************************************************** |
| * |
| * |
| * Look if the File is in Use For the OF_SHARE_XXX options |
| * |
| * PARAMS |
| * name [I]: full unix name of the file that should be opened |
| * mode [O]: mode how the file was first opened |
| * RETURNS |
| * TRUE if the file was opened before |
| * FALSE if we open the file exclusive for this process |
| * |
| * Scope of the files we look for is only the current pdb |
| * Could we use /proc/self/? on Linux for this? |
| * Should we use flock? Should we create another structure? |
| * Searching through all files seem quite expensive for me, but |
| * I don't see any other way. |
| * |
| * FIXME: Extend scope to the whole Wine process |
| * |
| */ |
| static BOOL32 FILE_InUse(char * name, int * mode) |
| { |
| FILE_OBJECT *file; |
| int i; |
| HGLOBAL16 hPDB = GetCurrentPDB(); |
| PDB *pdb = (PDB *)GlobalLock16( hPDB ); |
| |
| if (!pdb) return 0; |
| for (i=0;i<pdb->nbFiles;i++) |
| { |
| file =FILE_GetFile( (HFILE32)i, 0, NULL ); |
| if(file) |
| { |
| if(file->unix_name) |
| { |
| TRACE(file,"got %s at %d\n",file->unix_name,i); |
| if(!lstrcmp32A(file->unix_name,name)) |
| { |
| *mode = file->mode; |
| FILE_ReleaseFile(file); |
| return TRUE; |
| } |
| } |
| FILE_ReleaseFile(file); |
| } |
| } |
| return FALSE; |
| } |
| |
| /*********************************************************************** |
| * FILE_SetDosError |
| * |
| * Set the DOS error code from errno. |
| */ |
| void FILE_SetDosError(void) |
| { |
| int save_errno = errno; /* errno gets overwritten by printf */ |
| |
| TRACE(file, "errno = %d %s\n", errno, strerror(errno)); |
| switch (save_errno) |
| { |
| case EAGAIN: |
| DOS_ERROR( ER_ShareViolation, EC_Temporary, SA_Retry, EL_Disk ); |
| break; |
| case EBADF: |
| DOS_ERROR( ER_InvalidHandle, EC_ProgramError, SA_Abort, EL_Disk ); |
| break; |
| case ENOSPC: |
| DOS_ERROR( ER_DiskFull, EC_MediaError, SA_Abort, EL_Disk ); |
| break; |
| case EACCES: |
| case EPERM: |
| case EROFS: |
| DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk ); |
| break; |
| case EBUSY: |
| DOS_ERROR( ER_LockViolation, EC_AccessDenied, SA_Abort, EL_Disk ); |
| break; |
| case ENOENT: |
| DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk ); |
| break; |
| case EISDIR: |
| DOS_ERROR( ER_CanNotMakeDir, EC_AccessDenied, SA_Abort, EL_Unknown ); |
| break; |
| case ENFILE: |
| case EMFILE: |
| DOS_ERROR( ER_NoMoreFiles, EC_MediaError, SA_Abort, EL_Unknown ); |
| break; |
| case EEXIST: |
| DOS_ERROR( ER_FileExists, EC_Exists, SA_Abort, EL_Disk ); |
| break; |
| case EINVAL: |
| case ESPIPE: |
| DOS_ERROR( ER_SeekError, EC_NotFound, SA_Ignore, EL_Disk ); |
| break; |
| case ENOTEMPTY: |
| DOS_ERROR( ERROR_DIR_NOT_EMPTY, EC_Exists, SA_Ignore, EL_Disk ); |
| break; |
| default: |
| perror( "int21: unknown errno" ); |
| DOS_ERROR( ER_GeneralFailure, EC_SystemFailure, SA_Abort, EL_Unknown ); |
| break; |
| } |
| errno = save_errno; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_DupUnixHandle |
| * |
| * Duplicate a Unix handle into a task handle. |
| */ |
| HFILE32 FILE_DupUnixHandle( int fd ) |
| { |
| int unix_handle; |
| FILE_OBJECT *file; |
| |
| if ((unix_handle = dup(fd)) == -1) |
| { |
| FILE_SetDosError(); |
| return INVALID_HANDLE_VALUE32; |
| } |
| return FILE_Alloc( &file, unix_handle ); |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_OpenUnixFile |
| */ |
| HFILE32 FILE_OpenUnixFile( const char *name, int mode ) |
| { |
| HFILE32 handle; |
| int unix_handle; |
| FILE_OBJECT *file; |
| struct stat st; |
| |
| if ((unix_handle = open( name, mode, 0666 )) == -1) |
| { |
| if (!Options.failReadOnly && (mode == O_RDWR)) |
| unix_handle = open( name, O_RDONLY ); |
| } |
| if ((unix_handle == -1) || (fstat( unix_handle, &st ) == -1)) |
| { |
| FILE_SetDosError(); |
| return INVALID_HANDLE_VALUE32; |
| } |
| if (S_ISDIR(st.st_mode)) |
| { |
| DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk ); |
| close( unix_handle ); |
| return INVALID_HANDLE_VALUE32; |
| } |
| |
| /* File opened OK, now fill the FILE_OBJECT */ |
| |
| if ((handle = FILE_Alloc( &file, unix_handle )) == INVALID_HANDLE_VALUE32) |
| return INVALID_HANDLE_VALUE32; |
| file->unix_name = HEAP_strdupA( SystemHeap, 0, name ); |
| return handle; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_Open |
| * |
| * path[I] name of file to open |
| * mode[I] mode how to open, in unix notation |
| * shareMode[I] the sharing mode in the win OpenFile notation |
| * |
| */ |
| HFILE32 FILE_Open( LPCSTR path, INT32 mode, INT32 shareMode ) |
| { |
| DOS_FULL_NAME full_name; |
| const char *unixName; |
| int oldMode, dosMode; /* FIXME: Do we really need unixmode as argument for |
| FILE_Open */ |
| FILE_OBJECT *file; |
| HFILE32 hFileRet; |
| BOOL32 fileInUse = FALSE; |
| |
| TRACE(file, "'%s' %04x\n", path, mode ); |
| |
| if (!path) return HFILE_ERROR32; |
| |
| if (DOSFS_GetDevice( path )) |
| { |
| HFILE32 ret; |
| |
| TRACE(file, "opening device '%s'\n", path ); |
| |
| if (HFILE_ERROR32!=(ret=DOSFS_OpenDevice( path, mode ))) |
| return ret; |
| |
| /* Do not silence this please. It is a critical error. -MM */ |
| ERR(file, "Couldn't open device '%s'!\n",path); |
| DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk ); |
| return HFILE_ERROR32; |
| |
| } |
| else /* check for filename, don't check for last entry if creating */ |
| { |
| if (!DOSFS_GetFullName( path, !(mode & O_CREAT), &full_name )) |
| return HFILE_ERROR32; |
| unixName = full_name.long_name; |
| } |
| |
| dosMode = FILE_UnixToDosMode(mode)| shareMode; |
| fileInUse = FILE_InUse(full_name.long_name,&oldMode); |
| if(fileInUse) |
| { |
| TRACE(file, "found another instance with mode 0x%02x\n",oldMode&0x70); |
| if (FILE_ShareDeny(dosMode,oldMode)) return HFILE_ERROR32; |
| } |
| hFileRet = FILE_OpenUnixFile( unixName, mode ); |
| /* we need to save the mode, but only if it is not in use yet*/ |
| if ((hFileRet) && (!fileInUse) && ((file =FILE_GetFile(hFileRet, 0, NULL)))) |
| { |
| file->mode=dosMode; |
| FILE_ReleaseFile(file); |
| } |
| return hFileRet; |
| |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_Create |
| */ |
| static HFILE32 FILE_Create( LPCSTR path, int mode, int unique ) |
| { |
| HFILE32 handle; |
| int unix_handle; |
| FILE_OBJECT *file; |
| DOS_FULL_NAME full_name; |
| BOOL32 fileInUse = FALSE; |
| int oldMode,dosMode; /* FIXME: Do we really need unixmode as argument for |
| FILE_Create */; |
| |
| TRACE(file, "'%s' %04x %d\n", path, mode, unique ); |
| |
| if (!path) return INVALID_HANDLE_VALUE32; |
| |
| if (DOSFS_GetDevice( path )) |
| { |
| WARN(file, "cannot create DOS device '%s'!\n", path); |
| DOS_ERROR( ER_AccessDenied, EC_NotFound, SA_Abort, EL_Disk ); |
| return INVALID_HANDLE_VALUE32; |
| } |
| |
| if (!DOSFS_GetFullName( path, FALSE, &full_name )) return INVALID_HANDLE_VALUE32; |
| |
| dosMode = FILE_UnixToDosMode(mode); |
| fileInUse = FILE_InUse(full_name.long_name,&oldMode); |
| if(fileInUse) |
| { |
| TRACE(file, "found another instance with mode 0x%02x\n",oldMode&0x70); |
| if (FILE_ShareDeny(dosMode,oldMode)) return INVALID_HANDLE_VALUE32; |
| } |
| |
| if ((unix_handle = open( full_name.long_name, |
| O_CREAT | O_TRUNC | O_RDWR | (unique ? O_EXCL : 0), |
| mode )) == -1) |
| { |
| FILE_SetDosError(); |
| return INVALID_HANDLE_VALUE32; |
| } |
| |
| /* File created OK, now fill the FILE_OBJECT */ |
| |
| if ((handle = FILE_Alloc( &file, unix_handle )) == INVALID_HANDLE_VALUE32) |
| return INVALID_HANDLE_VALUE32; |
| file->unix_name = HEAP_strdupA( SystemHeap, 0, full_name.long_name ); |
| file->mode = dosMode; |
| return handle; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_FillInfo |
| * |
| * Fill a file information from a struct stat. |
| */ |
| static void FILE_FillInfo( struct stat *st, BY_HANDLE_FILE_INFORMATION *info ) |
| { |
| if (S_ISDIR(st->st_mode)) |
| info->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY; |
| else |
| info->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE; |
| if (!(st->st_mode & S_IWUSR)) |
| info->dwFileAttributes |= FILE_ATTRIBUTE_READONLY; |
| |
| DOSFS_UnixTimeToFileTime( st->st_mtime, &info->ftCreationTime, 0 ); |
| DOSFS_UnixTimeToFileTime( st->st_mtime, &info->ftLastWriteTime, 0 ); |
| DOSFS_UnixTimeToFileTime( st->st_atime, &info->ftLastAccessTime, 0 ); |
| |
| info->dwVolumeSerialNumber = 0; /* FIXME */ |
| info->nFileSizeHigh = 0; |
| info->nFileSizeLow = S_ISDIR(st->st_mode) ? 0 : st->st_size; |
| info->nNumberOfLinks = st->st_nlink; |
| info->nFileIndexHigh = 0; |
| info->nFileIndexLow = st->st_ino; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_Stat |
| * |
| * Stat a Unix path name. Return TRUE if OK. |
| */ |
| BOOL32 FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info ) |
| { |
| struct stat st; |
| |
| if (!unixName || !info) return FALSE; |
| |
| if (stat( unixName, &st ) == -1) |
| { |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| FILE_FillInfo( &st, info ); |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * GetFileInformationByHandle (KERNEL32.219) |
| */ |
| DWORD WINAPI GetFileInformationByHandle( HFILE32 hFile, |
| BY_HANDLE_FILE_INFORMATION *info ) |
| { |
| FILE_OBJECT *file; |
| struct get_file_info_request req; |
| struct get_file_info_reply reply; |
| int len; |
| |
| if (!info) return 0; |
| if (!(file = FILE_GetFile( hFile, 0, &req.handle ))) return 0; |
| CLIENT_SendRequest( REQ_GET_FILE_INFO, -1, 1, &req, sizeof(req) ); |
| CLIENT_WaitReply( &len, NULL, 1, &reply, sizeof(reply) ); |
| CHECK_LEN( len, sizeof(reply) ); |
| FILE_ReleaseFile( file ); |
| |
| DOSFS_UnixTimeToFileTime( reply.write_time, &info->ftCreationTime, 0 ); |
| DOSFS_UnixTimeToFileTime( reply.write_time, &info->ftLastWriteTime, 0 ); |
| DOSFS_UnixTimeToFileTime( reply.access_time, &info->ftLastAccessTime, 0 ); |
| info->dwFileAttributes = reply.attr; |
| info->dwVolumeSerialNumber = reply.serial; |
| info->nFileSizeHigh = reply.size_high; |
| info->nFileSizeLow = reply.size_low; |
| info->nNumberOfLinks = reply.links; |
| info->nFileIndexHigh = reply.index_high; |
| info->nFileIndexLow = reply.index_low; |
| return 1; |
| } |
| |
| |
| /************************************************************************** |
| * GetFileAttributes16 (KERNEL.420) |
| */ |
| DWORD WINAPI GetFileAttributes16( LPCSTR name ) |
| { |
| return GetFileAttributes32A( name ); |
| } |
| |
| |
| /************************************************************************** |
| * GetFileAttributes32A (KERNEL32.217) |
| */ |
| DWORD WINAPI GetFileAttributes32A( LPCSTR name ) |
| { |
| DOS_FULL_NAME full_name; |
| BY_HANDLE_FILE_INFORMATION info; |
| |
| if (name == NULL || *name=='\0') return -1; |
| |
| if (!DOSFS_GetFullName( name, TRUE, &full_name )) return -1; |
| if (!FILE_Stat( full_name.long_name, &info )) return -1; |
| return info.dwFileAttributes; |
| } |
| |
| |
| /************************************************************************** |
| * GetFileAttributes32W (KERNEL32.218) |
| */ |
| DWORD WINAPI GetFileAttributes32W( LPCWSTR name ) |
| { |
| LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name ); |
| DWORD res = GetFileAttributes32A( nameA ); |
| HeapFree( GetProcessHeap(), 0, nameA ); |
| return res; |
| } |
| |
| |
| /*********************************************************************** |
| * GetFileSize (KERNEL32.220) |
| */ |
| DWORD WINAPI GetFileSize( HFILE32 hFile, LPDWORD filesizehigh ) |
| { |
| BY_HANDLE_FILE_INFORMATION info; |
| if (!GetFileInformationByHandle( hFile, &info )) return 0; |
| if (filesizehigh) *filesizehigh = info.nFileSizeHigh; |
| return info.nFileSizeLow; |
| } |
| |
| |
| /*********************************************************************** |
| * GetFileTime (KERNEL32.221) |
| */ |
| BOOL32 WINAPI GetFileTime( HFILE32 hFile, FILETIME *lpCreationTime, |
| FILETIME *lpLastAccessTime, |
| FILETIME *lpLastWriteTime ) |
| { |
| BY_HANDLE_FILE_INFORMATION info; |
| if (!GetFileInformationByHandle( hFile, &info )) return FALSE; |
| if (lpCreationTime) *lpCreationTime = info.ftCreationTime; |
| if (lpLastAccessTime) *lpLastAccessTime = info.ftLastAccessTime; |
| if (lpLastWriteTime) *lpLastWriteTime = info.ftLastWriteTime; |
| return TRUE; |
| } |
| |
| /*********************************************************************** |
| * CompareFileTime (KERNEL32.28) |
| */ |
| INT32 WINAPI CompareFileTime( LPFILETIME x, LPFILETIME y ) |
| { |
| if (!x || !y) return -1; |
| |
| if (x->dwHighDateTime > y->dwHighDateTime) |
| return 1; |
| if (x->dwHighDateTime < y->dwHighDateTime) |
| return -1; |
| if (x->dwLowDateTime > y->dwLowDateTime) |
| return 1; |
| if (x->dwLowDateTime < y->dwLowDateTime) |
| return -1; |
| return 0; |
| } |
| |
| /*********************************************************************** |
| * FILE_Dup |
| * |
| * dup() function for DOS handles. |
| */ |
| HFILE32 FILE_Dup( HFILE32 hFile ) |
| { |
| HFILE32 handle; |
| |
| TRACE(file, "FILE_Dup for handle %d\n", hFile ); |
| if (!DuplicateHandle( GetCurrentProcess(), hFile, GetCurrentProcess(), |
| &handle, FILE_ALL_ACCESS /* FIXME */, FALSE, 0 )) |
| handle = HFILE_ERROR32; |
| TRACE(file, "FILE_Dup return handle %d\n", handle ); |
| return handle; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_Dup2 |
| * |
| * dup2() function for DOS handles. |
| */ |
| HFILE32 FILE_Dup2( HFILE32 hFile1, HFILE32 hFile2 ) |
| { |
| FILE_OBJECT *file; |
| |
| TRACE(file, "FILE_Dup2 for handle %d\n", hFile1 ); |
| /* FIXME: should use DuplicateHandle */ |
| if (!(file = FILE_GetFile( hFile1, 0, NULL ))) return HFILE_ERROR32; |
| if (!HANDLE_SetObjPtr( PROCESS_Current(), hFile2, &file->header, 0 )) |
| hFile2 = HFILE_ERROR32; |
| FILE_ReleaseFile( file ); |
| return hFile2; |
| } |
| |
| |
| /*********************************************************************** |
| * GetTempFileName16 (KERNEL.97) |
| */ |
| UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique, |
| LPSTR buffer ) |
| { |
| char temppath[144]; |
| |
| if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */ |
| drive |= DRIVE_GetCurrentDrive() + 'A'; |
| |
| if ((drive & TF_FORCEDRIVE) && |
| !DRIVE_IsValid( toupper(drive & ~TF_FORCEDRIVE) - 'A' )) |
| { |
| drive &= ~TF_FORCEDRIVE; |
| WARN(file, "invalid drive %d specified\n", drive ); |
| } |
| |
| if (drive & TF_FORCEDRIVE) |
| sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE ); |
| else |
| GetTempPath32A( 132, temppath ); |
| return (UINT16)GetTempFileName32A( temppath, prefix, unique, buffer ); |
| } |
| |
| |
| /*********************************************************************** |
| * GetTempFileName32A (KERNEL32.290) |
| */ |
| UINT32 WINAPI GetTempFileName32A( LPCSTR path, LPCSTR prefix, UINT32 unique, |
| LPSTR buffer) |
| { |
| static UINT32 unique_temp; |
| DOS_FULL_NAME full_name; |
| int i; |
| LPSTR p; |
| UINT32 num; |
| |
| if ( !path || !prefix || !buffer ) return 0; |
| |
| if (!unique_temp) unique_temp = time(NULL) & 0xffff; |
| num = unique ? (unique & 0xffff) : (unique_temp++ & 0xffff); |
| |
| strcpy( buffer, path ); |
| p = buffer + strlen(buffer); |
| |
| /* add a \, if there isn't one and path is more than just the drive letter ... */ |
| if ( !((strlen(buffer) == 2) && (buffer[1] == ':')) |
| && ((p == buffer) || (p[-1] != '\\'))) *p++ = '\\'; |
| |
| *p++ = '~'; |
| for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++; |
| sprintf( p, "%04x.tmp", num ); |
| |
| /* Now try to create it */ |
| |
| if (!unique) |
| { |
| do |
| { |
| HFILE32 handle = FILE_Create( buffer, 0666, TRUE ); |
| if (handle != INVALID_HANDLE_VALUE32) |
| { /* We created it */ |
| TRACE(file, "created %s\n", |
| buffer); |
| CloseHandle( handle ); |
| break; |
| } |
| if (DOS_ExtendedError != ER_FileExists) |
| break; /* No need to go on */ |
| num++; |
| sprintf( p, "%04x.tmp", num ); |
| } while (num != (unique & 0xffff)); |
| } |
| |
| /* Get the full path name */ |
| |
| if (DOSFS_GetFullName( buffer, FALSE, &full_name )) |
| { |
| /* Check if we have write access in the directory */ |
| if ((p = strrchr( full_name.long_name, '/' ))) *p = '\0'; |
| if (access( full_name.long_name, W_OK ) == -1) |
| WARN(file, "returns '%s', which doesn't seem to be writeable.\n", |
| buffer); |
| } |
| TRACE(file, "returning %s\n", buffer ); |
| return unique ? unique : num; |
| } |
| |
| |
| /*********************************************************************** |
| * GetTempFileName32W (KERNEL32.291) |
| */ |
| UINT32 WINAPI GetTempFileName32W( LPCWSTR path, LPCWSTR prefix, UINT32 unique, |
| LPWSTR buffer ) |
| { |
| LPSTR patha,prefixa; |
| char buffera[144]; |
| UINT32 ret; |
| |
| if (!path) return 0; |
| patha = HEAP_strdupWtoA( GetProcessHeap(), 0, path ); |
| prefixa = HEAP_strdupWtoA( GetProcessHeap(), 0, prefix ); |
| ret = GetTempFileName32A( patha, prefixa, unique, buffera ); |
| lstrcpyAtoW( buffer, buffera ); |
| HeapFree( GetProcessHeap(), 0, patha ); |
| HeapFree( GetProcessHeap(), 0, prefixa ); |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_DoOpenFile |
| * |
| * Implementation of OpenFile16() and OpenFile32(). |
| */ |
| static HFILE32 FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT32 mode, |
| BOOL32 win32 ) |
| { |
| HFILE32 hFileRet; |
| FILETIME filetime; |
| WORD filedatetime[2]; |
| DOS_FULL_NAME full_name; |
| char *p; |
| int unixMode, oldMode; |
| FILE_OBJECT *file; |
| BOOL32 fileInUse = FALSE; |
| |
| if (!ofs) return HFILE_ERROR32; |
| |
| |
| ofs->cBytes = sizeof(OFSTRUCT); |
| ofs->nErrCode = 0; |
| if (mode & OF_REOPEN) name = ofs->szPathName; |
| |
| if (!name) { |
| ERR(file, "called with `name' set to NULL ! Please debug.\n"); |
| return HFILE_ERROR32; |
| } |
| |
| TRACE(file, "%s %04x\n", name, mode ); |
| |
| /* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName |
| Are there any cases where getting the path here is wrong? |
| Uwe Bonnes 1997 Apr 2 */ |
| if (!GetFullPathName32A( name, sizeof(ofs->szPathName), |
| ofs->szPathName, NULL )) goto error; |
| |
| /* OF_PARSE simply fills the structure */ |
| |
| if (mode & OF_PARSE) |
| { |
| ofs->fFixedDisk = (GetDriveType16( ofs->szPathName[0]-'A' ) |
| != DRIVE_REMOVABLE); |
| TRACE(file, "(%s): OF_PARSE, res = '%s'\n", |
| name, ofs->szPathName ); |
| return 0; |
| } |
| |
| /* OF_CREATE is completely different from all other options, so |
| handle it first */ |
| |
| if (mode & OF_CREATE) |
| { |
| if ((hFileRet = FILE_Create(name,0666,FALSE))== INVALID_HANDLE_VALUE32) |
| goto error; |
| goto success; |
| } |
| |
| /* If OF_SEARCH is set, ignore the given path */ |
| |
| if ((mode & OF_SEARCH) && !(mode & OF_REOPEN)) |
| { |
| /* First try the file name as is */ |
| if (DOSFS_GetFullName( name, TRUE, &full_name )) goto found; |
| /* Now remove the path */ |
| if (name[0] && (name[1] == ':')) name += 2; |
| if ((p = strrchr( name, '\\' ))) name = p + 1; |
| if ((p = strrchr( name, '/' ))) name = p + 1; |
| if (!name[0]) goto not_found; |
| } |
| |
| /* Now look for the file */ |
| |
| if (!DIR_SearchPath( NULL, name, NULL, &full_name, win32 )) goto not_found; |
| |
| found: |
| TRACE(file, "found %s = %s\n", |
| full_name.long_name, full_name.short_name ); |
| lstrcpyn32A( ofs->szPathName, full_name.short_name, |
| sizeof(ofs->szPathName) ); |
| |
| fileInUse = FILE_InUse(full_name.long_name,&oldMode); |
| if(fileInUse) |
| { |
| TRACE(file, "found another instance with mode 0x%02x\n",oldMode&0x70); |
| if (FILE_ShareDeny(mode,oldMode)) return HFILE_ERROR32; |
| } |
| |
| if (mode & OF_SHARE_EXCLUSIVE) |
| /* Some InstallShield version uses OF_SHARE_EXCLUSIVE |
| on the file <tempdir>/_ins0432._mp to determine how |
| far installation has proceeded. |
| _ins0432._mp is an executable and while running the |
| application expects the open with OF_SHARE_ to fail*/ |
| /* Probable FIXME: |
| As our loader closes the files after loading the executable, |
| we can't find the running executable with FILE_InUse. |
| Perhaps the loader should keep the file open. |
| Recheck against how Win handles that case */ |
| { |
| char *last = strrchr(full_name.long_name,'/'); |
| if (!last) |
| last = full_name.long_name - 1; |
| if (GetModuleHandle16(last+1)) |
| { |
| TRACE(file,"Denying shared open for %s\n",full_name.long_name); |
| return HFILE_ERROR32; |
| } |
| } |
| |
| if (mode & OF_DELETE) |
| { |
| if (unlink( full_name.long_name ) == -1) goto not_found; |
| TRACE(file, "(%s): OF_DELETE return = OK\n", name); |
| return 1; |
| } |
| |
| unixMode=FILE_DOSToUnixMode(mode); |
| |
| hFileRet = FILE_OpenUnixFile( full_name.long_name, unixMode ); |
| if (hFileRet == HFILE_ERROR32) goto not_found; |
| /* we need to save the mode, but only if it is not in use yet*/ |
| if( (!fileInUse) &&(file =FILE_GetFile(hFileRet,0,NULL))) |
| { |
| file->mode=mode; |
| FILE_ReleaseFile(file); |
| } |
| |
| GetFileTime( hFileRet, NULL, NULL, &filetime ); |
| FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] ); |
| if ((mode & OF_VERIFY) && (mode & OF_REOPEN)) |
| { |
| if (memcmp( ofs->reserved, filedatetime, sizeof(ofs->reserved) )) |
| { |
| CloseHandle( hFileRet ); |
| WARN(file, "(%s): OF_VERIFY failed\n", name ); |
| /* FIXME: what error here? */ |
| DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk ); |
| goto error; |
| } |
| } |
| memcpy( ofs->reserved, filedatetime, sizeof(ofs->reserved) ); |
| |
| success: /* We get here if the open was successful */ |
| TRACE(file, "(%s): OK, return = %d\n", name, hFileRet ); |
| if (mode & OF_EXIST) /* Return the handle, but close it first */ |
| CloseHandle( hFileRet ); |
| return hFileRet; |
| |
| not_found: /* We get here if the file does not exist */ |
| WARN(file, "'%s' not found\n", name ); |
| DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk ); |
| /* fall through */ |
| |
| error: /* We get here if there was an error opening the file */ |
| ofs->nErrCode = DOS_ExtendedError; |
| WARN(file, "(%s): return = HFILE_ERROR error= %d\n", |
| name,ofs->nErrCode ); |
| return HFILE_ERROR32; |
| } |
| |
| |
| /*********************************************************************** |
| * OpenFile16 (KERNEL.74) |
| */ |
| HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode ) |
| { |
| TRACE(file,"OpenFile16(%s,%i)\n", name, mode); |
| return HFILE32_TO_HFILE16(FILE_DoOpenFile( name, ofs, mode, FALSE )); |
| } |
| |
| |
| /*********************************************************************** |
| * OpenFile32 (KERNEL32.396) |
| */ |
| HFILE32 WINAPI OpenFile32( LPCSTR name, OFSTRUCT *ofs, UINT32 mode ) |
| { |
| return FILE_DoOpenFile( name, ofs, mode, TRUE ); |
| } |
| |
| |
| /*********************************************************************** |
| * _lclose16 (KERNEL.81) |
| */ |
| HFILE16 WINAPI _lclose16( HFILE16 hFile ) |
| { |
| TRACE(file, "handle %d\n", hFile ); |
| return CloseHandle( HFILE16_TO_HFILE32( hFile ) ) ? 0 : HFILE_ERROR16; |
| } |
| |
| |
| /*********************************************************************** |
| * _lclose32 (KERNEL32.592) |
| */ |
| HFILE32 WINAPI _lclose32( HFILE32 hFile ) |
| { |
| TRACE(file, "handle %d\n", hFile ); |
| return CloseHandle( hFile ) ? 0 : HFILE_ERROR32; |
| } |
| |
| |
| /*********************************************************************** |
| * WIN16_hread |
| */ |
| LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count ) |
| { |
| LONG maxlen; |
| |
| TRACE(file, "%d %08lx %ld\n", |
| hFile, (DWORD)buffer, count ); |
| |
| /* Some programs pass a count larger than the allocated buffer */ |
| maxlen = GetSelectorLimit( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1; |
| if (count > maxlen) count = maxlen; |
| return _lread32(HFILE16_TO_HFILE32(hFile), PTR_SEG_TO_LIN(buffer), count ); |
| } |
| |
| |
| /*********************************************************************** |
| * WIN16_lread |
| */ |
| UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count ) |
| { |
| return (UINT16)WIN16_hread( hFile, buffer, (LONG)count ); |
| } |
| |
| |
| /*********************************************************************** |
| * _lread32 (KERNEL32.596) |
| */ |
| UINT32 WINAPI _lread32( HFILE32 handle, LPVOID buffer, UINT32 count ) |
| { |
| K32OBJ *ptr; |
| DWORD numWritten; |
| BOOL32 result = FALSE; |
| |
| TRACE( file, "%d %p %d\n", handle, buffer, count); |
| if (!(ptr = HANDLE_GetObjPtr( PROCESS_Current(), handle, |
| K32OBJ_UNKNOWN, 0, NULL))) return -1; |
| if (K32OBJ_OPS(ptr)->read) |
| result = K32OBJ_OPS(ptr)->read(ptr, buffer, count, &numWritten, NULL); |
| K32OBJ_DecCount( ptr ); |
| if (!result) return -1; |
| return (UINT32)numWritten; |
| } |
| |
| |
| /*********************************************************************** |
| * _lread16 (KERNEL.82) |
| */ |
| UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count ) |
| { |
| return (UINT16)_lread32(HFILE16_TO_HFILE32(hFile), buffer, (LONG)count ); |
| } |
| |
| |
| /*********************************************************************** |
| * _lcreat16 (KERNEL.83) |
| */ |
| HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr ) |
| { |
| int mode = (attr & 1) ? 0444 : 0666; |
| TRACE(file, "%s %02x\n", path, attr ); |
| return (HFILE16) HFILE32_TO_HFILE16(FILE_Create( path, mode, FALSE )); |
| } |
| |
| |
| /*********************************************************************** |
| * _lcreat32 (KERNEL32.593) |
| */ |
| HFILE32 WINAPI _lcreat32( LPCSTR path, INT32 attr ) |
| { |
| int mode = (attr & 1) ? 0444 : 0666; |
| TRACE(file, "%s %02x\n", path, attr ); |
| return FILE_Create( path, mode, FALSE ); |
| } |
| |
| |
| /*********************************************************************** |
| * _lcreat_uniq (Not a Windows API) |
| */ |
| HFILE32 _lcreat_uniq( LPCSTR path, INT32 attr ) |
| { |
| int mode = (attr & 1) ? 0444 : 0666; |
| TRACE(file, "%s %02x\n", path, attr ); |
| return FILE_Create( path, mode, TRUE ); |
| } |
| |
| |
| /*********************************************************************** |
| * SetFilePointer (KERNEL32.492) |
| */ |
| DWORD WINAPI SetFilePointer( HFILE32 hFile, LONG distance, LONG *highword, |
| DWORD method ) |
| { |
| FILE_OBJECT *file; |
| DWORD result = 0xffffffff; |
| int unix_handle; |
| |
| if (highword && *highword) |
| { |
| FIXME(file, "64-bit offsets not supported yet\n"); |
| SetLastError( ERROR_INVALID_PARAMETER ); |
| return 0xffffffff; |
| } |
| TRACE(file, "handle %d offset %ld origin %ld\n", |
| hFile, distance, method ); |
| |
| if (!(file = FILE_GetFile( hFile, 0, NULL ))) return 0xffffffff; |
| if ((unix_handle = FILE_GetUnixHandle( hFile, 0 )) == -1) |
| { |
| FILE_ReleaseFile( file ); |
| return 0xffffffff; |
| } |
| |
| /* the pointer may be positioned before the start of the file; |
| no error is returned in that case, |
| but subsequent attempts at I/O will produce errors. |
| This is not allowed with Unix lseek(), |
| so we'll need some emulation here */ |
| switch(method) |
| { |
| case FILE_CURRENT: |
| distance += file->pos; /* fall through */ |
| case FILE_BEGIN: |
| if ((result = lseek(unix_handle, distance, SEEK_SET)) == -1) |
| { |
| if ((INT32)distance < 0) |
| file->pos = result = distance; |
| } |
| else |
| file->pos = result; |
| break; |
| case FILE_END: |
| if ((result = lseek(unix_handle, distance, SEEK_END)) == -1) |
| { |
| if ((INT32)distance < 0) |
| { |
| /* get EOF */ |
| result = lseek(unix_handle, 0, SEEK_END); |
| |
| /* return to the old pos, as the first lseek failed */ |
| lseek(unix_handle, file->pos, SEEK_END); |
| |
| file->pos = (result += distance); |
| } |
| else |
| ERR(file, "lseek: unknown error. Please report.\n"); |
| } |
| else file->pos = result; |
| break; |
| default: |
| ERR(file, "Unknown origin %ld !\n", method); |
| } |
| |
| if (result == -1) |
| FILE_SetDosError(); |
| |
| close( unix_handle ); |
| FILE_ReleaseFile( file ); |
| return result; |
| } |
| |
| |
| /*********************************************************************** |
| * _llseek16 (KERNEL.84) |
| */ |
| LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin ) |
| { |
| return SetFilePointer( HFILE16_TO_HFILE32(hFile), lOffset, NULL, nOrigin ); |
| } |
| |
| |
| /*********************************************************************** |
| * _llseek32 (KERNEL32.594) |
| */ |
| LONG WINAPI _llseek32( HFILE32 hFile, LONG lOffset, INT32 nOrigin ) |
| { |
| return SetFilePointer( hFile, lOffset, NULL, nOrigin ); |
| } |
| |
| |
| /*********************************************************************** |
| * _lopen16 (KERNEL.85) |
| */ |
| HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode ) |
| { |
| return HFILE32_TO_HFILE16(_lopen32( path, mode )); |
| } |
| |
| |
| /*********************************************************************** |
| * _lopen32 (KERNEL32.595) |
| */ |
| HFILE32 WINAPI _lopen32( LPCSTR path, INT32 mode ) |
| { |
| INT32 unixMode; |
| |
| TRACE(file, "('%s',%04x)\n", path, mode ); |
| |
| unixMode= FILE_DOSToUnixMode(mode); |
| return FILE_Open( path, unixMode , (mode & 0x70)); |
| } |
| |
| |
| /*********************************************************************** |
| * _lwrite16 (KERNEL.86) |
| */ |
| UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count ) |
| { |
| return (UINT16)_hwrite32( HFILE16_TO_HFILE32(hFile), buffer, (LONG)count ); |
| } |
| |
| /*********************************************************************** |
| * _lwrite32 (KERNEL.86) |
| */ |
| UINT32 WINAPI _lwrite32( HFILE32 hFile, LPCSTR buffer, UINT32 count ) |
| { |
| return (UINT32)_hwrite32( hFile, buffer, (LONG)count ); |
| } |
| |
| |
| /*********************************************************************** |
| * _hread16 (KERNEL.349) |
| */ |
| LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count) |
| { |
| return _lread32( HFILE16_TO_HFILE32(hFile), buffer, count ); |
| } |
| |
| |
| /*********************************************************************** |
| * _hread32 (KERNEL32.590) |
| */ |
| LONG WINAPI _hread32( HFILE32 hFile, LPVOID buffer, LONG count) |
| { |
| return _lread32( hFile, buffer, count ); |
| } |
| |
| |
| /*********************************************************************** |
| * _hwrite16 (KERNEL.350) |
| */ |
| LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count ) |
| { |
| return _hwrite32( HFILE16_TO_HFILE32(hFile), buffer, count ); |
| } |
| |
| |
| /*********************************************************************** |
| * _hwrite32 (KERNEL32.591) |
| * |
| * experimenation yields that _lwrite: |
| * o truncates the file at the current position with |
| * a 0 len write |
| * o returns 0 on a 0 length write |
| * o works with console handles |
| * |
| */ |
| LONG WINAPI _hwrite32( HFILE32 handle, LPCSTR buffer, LONG count ) |
| { |
| K32OBJ *ioptr; |
| DWORD result; |
| BOOL32 status = FALSE; |
| |
| TRACE(file, "%d %p %ld\n", handle, buffer, count ); |
| |
| if (count == 0) { /* Expand or truncate at current position */ |
| int unix_handle = FILE_GetUnixHandle( handle, GENERIC_WRITE ); |
| if ((unix_handle != -1) && |
| (ftruncate(unix_handle, |
| lseek( unix_handle, 0, SEEK_CUR)) == 0 )) |
| { |
| close( unix_handle ); |
| return 0; |
| } else { |
| FILE_SetDosError(); |
| close( unix_handle ); |
| return HFILE_ERROR32; |
| } |
| } |
| |
| if (!(ioptr = HANDLE_GetObjPtr( PROCESS_Current(), handle, |
| K32OBJ_UNKNOWN, 0, NULL ))) |
| return HFILE_ERROR32; |
| if (K32OBJ_OPS(ioptr)->write) |
| status = K32OBJ_OPS(ioptr)->write(ioptr, buffer, count, &result, NULL); |
| K32OBJ_DecCount( ioptr ); |
| if (!status) result = HFILE_ERROR32; |
| return result; |
| } |
| |
| |
| /*********************************************************************** |
| * SetHandleCount16 (KERNEL.199) |
| */ |
| UINT16 WINAPI SetHandleCount16( UINT16 count ) |
| { |
| HGLOBAL16 hPDB = GetCurrentPDB(); |
| PDB *pdb = (PDB *)GlobalLock16( hPDB ); |
| BYTE *files = PTR_SEG_TO_LIN( pdb->fileHandlesPtr ); |
| |
| TRACE(file, "(%d)\n", count ); |
| |
| if (count < 20) count = 20; /* No point in going below 20 */ |
| else if (count > 254) count = 254; |
| |
| if (count == 20) |
| { |
| if (pdb->nbFiles > 20) |
| { |
| memcpy( pdb->fileHandles, files, 20 ); |
| GlobalFree16( pdb->hFileHandles ); |
| pdb->fileHandlesPtr = (SEGPTR)MAKELONG( 0x18, |
| GlobalHandleToSel( hPDB ) ); |
| pdb->hFileHandles = 0; |
| pdb->nbFiles = 20; |
| } |
| } |
| else /* More than 20, need a new file handles table */ |
| { |
| BYTE *newfiles; |
| HGLOBAL16 newhandle = GlobalAlloc16( GMEM_MOVEABLE, count ); |
| if (!newhandle) |
| { |
| DOS_ERROR( ER_OutOfMemory, EC_OutOfResource, SA_Abort, EL_Memory ); |
| return pdb->nbFiles; |
| } |
| newfiles = (BYTE *)GlobalLock16( newhandle ); |
| |
| if (count > pdb->nbFiles) |
| { |
| memcpy( newfiles, files, pdb->nbFiles ); |
| memset( newfiles + pdb->nbFiles, 0xff, count - pdb->nbFiles ); |
| } |
| else memcpy( newfiles, files, count ); |
| if (pdb->nbFiles > 20) GlobalFree16( pdb->hFileHandles ); |
| pdb->fileHandlesPtr = WIN16_GlobalLock16( newhandle ); |
| pdb->hFileHandles = newhandle; |
| pdb->nbFiles = count; |
| } |
| return pdb->nbFiles; |
| } |
| |
| |
| /************************************************************************* |
| * SetHandleCount32 (KERNEL32.494) |
| */ |
| UINT32 WINAPI SetHandleCount32( UINT32 count ) |
| { |
| return MIN( 256, count ); |
| } |
| |
| |
| /*********************************************************************** |
| * FlushFileBuffers (KERNEL32.133) |
| */ |
| BOOL32 WINAPI FlushFileBuffers( HFILE32 hFile ) |
| { |
| int unix_handle; |
| BOOL32 ret; |
| |
| TRACE(file, "(%d)\n", hFile ); |
| if ((unix_handle = FILE_GetUnixHandle( hFile, 0)) == -1) return FALSE; |
| if (fsync( unix_handle ) != -1) ret = TRUE; |
| else |
| { |
| FILE_SetDosError(); |
| ret = FALSE; |
| } |
| close( unix_handle ); |
| return ret; |
| } |
| |
| |
| /************************************************************************** |
| * SetEndOfFile (KERNEL32.483) |
| */ |
| BOOL32 WINAPI SetEndOfFile( HFILE32 hFile ) |
| { |
| int unix_handle; |
| BOOL32 ret = TRUE; |
| |
| TRACE(file, "(%d)\n", hFile ); |
| if ((unix_handle = FILE_GetUnixHandle( hFile, GENERIC_WRITE )) == -1) return FALSE; |
| if (ftruncate( unix_handle, |
| lseek( unix_handle, 0, SEEK_CUR ) )) |
| { |
| FILE_SetDosError(); |
| ret = FALSE; |
| } |
| close( unix_handle ); |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * DeleteFile16 (KERNEL.146) |
| */ |
| BOOL16 WINAPI DeleteFile16( LPCSTR path ) |
| { |
| return DeleteFile32A( path ); |
| } |
| |
| |
| /*********************************************************************** |
| * DeleteFile32A (KERNEL32.71) |
| */ |
| BOOL32 WINAPI DeleteFile32A( LPCSTR path ) |
| { |
| DOS_FULL_NAME full_name; |
| |
| TRACE(file, "'%s'\n", path ); |
| |
| if (DOSFS_GetDevice( path )) |
| { |
| WARN(file, "cannot remove DOS device '%s'!\n", path); |
| DOS_ERROR( ER_FileNotFound, EC_NotFound, SA_Abort, EL_Disk ); |
| return FALSE; |
| } |
| |
| if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE; |
| if (unlink( full_name.long_name ) == -1) |
| { |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * DeleteFile32W (KERNEL32.72) |
| */ |
| BOOL32 WINAPI DeleteFile32W( LPCWSTR path ) |
| { |
| LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path ); |
| BOOL32 ret = DeleteFile32A( xpath ); |
| HeapFree( GetProcessHeap(), 0, xpath ); |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_SetFileType |
| */ |
| BOOL32 FILE_SetFileType( HFILE32 hFile, DWORD type ) |
| { |
| FILE_OBJECT *file = FILE_GetFile( hFile, 0, NULL ); |
| if (!file) return FALSE; |
| file->type = type; |
| FILE_ReleaseFile( file ); |
| return TRUE; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_mmap |
| */ |
| LPVOID FILE_mmap( HFILE32 hFile, LPVOID start, |
| DWORD size_high, DWORD size_low, |
| DWORD offset_high, DWORD offset_low, |
| int prot, int flags ) |
| { |
| LPVOID ret; |
| int unix_handle; |
| FILE_OBJECT *file = FILE_GetFile( hFile, 0, NULL ); |
| if (!file) return (LPVOID)-1; |
| if ((unix_handle = FILE_GetUnixHandle( hFile, 0 )) == -1) ret = (LPVOID)-1; |
| else |
| { |
| ret = FILE_dommap( file, unix_handle, start, size_high, size_low, |
| offset_high, offset_low, prot, flags ); |
| close( unix_handle ); |
| } |
| FILE_ReleaseFile( file ); |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_dommap |
| */ |
| LPVOID FILE_dommap( FILE_OBJECT *file, int unix_handle, LPVOID start, |
| DWORD size_high, DWORD size_low, |
| DWORD offset_high, DWORD offset_low, |
| int prot, int flags ) |
| { |
| int fd = -1; |
| int pos; |
| LPVOID ret; |
| |
| if (size_high || offset_high) |
| FIXME(file, "offsets larger than 4Gb not supported\n"); |
| |
| if (!file) |
| { |
| #ifdef MAP_ANON |
| flags |= MAP_ANON; |
| #else |
| static int fdzero = -1; |
| |
| if (fdzero == -1) |
| { |
| if ((fdzero = open( "/dev/zero", O_RDONLY )) == -1) |
| { |
| perror( "/dev/zero: open" ); |
| exit(1); |
| } |
| } |
| fd = fdzero; |
| #endif /* MAP_ANON */ |
| /* Linux EINVAL's on us if we don't pass MAP_PRIVATE to an anon mmap */ |
| #ifdef MAP_SHARED |
| flags &= ~MAP_SHARED; |
| #endif |
| #ifdef MAP_PRIVATE |
| flags |= MAP_PRIVATE; |
| #endif |
| } |
| else fd = unix_handle; |
| |
| if ((ret = mmap( start, size_low, prot, |
| flags, fd, offset_low )) != (LPVOID)-1) |
| return ret; |
| |
| /* mmap() failed; if this is because the file offset is not */ |
| /* page-aligned (EINVAL), or because the underlying filesystem */ |
| /* does not support mmap() (ENOEXEC), we do it by hand. */ |
| |
| if (!file) return ret; |
| if ((errno != ENOEXEC) && (errno != EINVAL)) return ret; |
| if (prot & PROT_WRITE) |
| { |
| /* We cannot fake shared write mappings */ |
| #ifdef MAP_SHARED |
| if (flags & MAP_SHARED) return ret; |
| #endif |
| #ifdef MAP_PRIVATE |
| if (!(flags & MAP_PRIVATE)) return ret; |
| #endif |
| } |
| /* printf( "FILE_mmap: mmap failed (%d), faking it\n", errno );*/ |
| /* Reserve the memory with an anonymous mmap */ |
| ret = FILE_dommap( NULL, -1, start, size_high, size_low, 0, 0, |
| PROT_READ | PROT_WRITE, flags ); |
| if (ret == (LPVOID)-1) return ret; |
| /* Now read in the file */ |
| if ((pos = lseek( fd, offset_low, SEEK_SET )) == -1) |
| { |
| FILE_munmap( ret, size_high, size_low ); |
| return (LPVOID)-1; |
| } |
| read( fd, ret, size_low ); |
| lseek( fd, pos, SEEK_SET ); /* Restore the file pointer */ |
| mprotect( ret, size_low, prot ); /* Set the right protection */ |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * FILE_munmap |
| */ |
| int FILE_munmap( LPVOID start, DWORD size_high, DWORD size_low ) |
| { |
| if (size_high) |
| FIXME(file, "offsets larger than 4Gb not supported\n"); |
| return munmap( start, size_low ); |
| } |
| |
| |
| /*********************************************************************** |
| * GetFileType (KERNEL32.222) |
| */ |
| DWORD WINAPI GetFileType( HFILE32 hFile ) |
| { |
| FILE_OBJECT *file = FILE_GetFile(hFile, 0, NULL); |
| if (!file) return FILE_TYPE_UNKNOWN; /* FIXME: correct? */ |
| FILE_ReleaseFile( file ); |
| return file->type; |
| } |
| |
| |
| /************************************************************************** |
| * MoveFileEx32A (KERNEL32.???) |
| */ |
| BOOL32 WINAPI MoveFileEx32A( LPCSTR fn1, LPCSTR fn2, DWORD flag ) |
| { |
| DOS_FULL_NAME full_name1, full_name2; |
| int mode=0; /* mode == 1: use copy */ |
| |
| TRACE(file, "(%s,%s,%04lx)\n", fn1, fn2, flag); |
| |
| if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE; |
| if (fn2) { /* !fn2 means delete fn1 */ |
| if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE; |
| /* Source name and target path are valid */ |
| if ( full_name1.drive != full_name2.drive) |
| { |
| /* use copy, if allowed */ |
| if (!(flag & MOVEFILE_COPY_ALLOWED)) { |
| /* FIXME: Use right error code */ |
| DOS_ERROR( ER_FileExists, EC_Exists, SA_Abort, EL_Disk ); |
| return FALSE; |
| } |
| else mode =1; |
| } |
| if (DOSFS_GetFullName( fn2, TRUE, &full_name2 )) |
| /* target exists, check if we may overwrite */ |
| if (!(flag & MOVEFILE_REPLACE_EXISTING)) { |
| /* FIXME: Use right error code */ |
| DOS_ERROR( ER_AccessDenied, EC_AccessDenied, SA_Abort, EL_Disk ); |
| return FALSE; |
| } |
| } |
| else /* fn2 == NULL means delete source */ |
| if (flag & MOVEFILE_DELAY_UNTIL_REBOOT) { |
| if (flag & MOVEFILE_COPY_ALLOWED) { |
| WARN(file, "Illegal flag\n"); |
| DOS_ERROR( ER_GeneralFailure, EC_SystemFailure, SA_Abort, |
| EL_Unknown ); |
| return FALSE; |
| } |
| /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706) |
| Perhaps we should queue these command and execute it |
| when exiting... What about using on_exit(2) |
| */ |
| FIXME(file, "Please delete file '%s' when Wine has finished\n", |
| full_name1.long_name); |
| return TRUE; |
| } |
| else if (unlink( full_name1.long_name ) == -1) |
| { |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| else return TRUE; /* successfully deleted */ |
| |
| if (flag & MOVEFILE_DELAY_UNTIL_REBOOT) { |
| /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706) |
| Perhaps we should queue these command and execute it |
| when exiting... What about using on_exit(2) |
| */ |
| FIXME(file,"Please move existing file '%s' to file '%s'" |
| "when Wine has finished\n", |
| full_name1.long_name, full_name2.long_name); |
| return TRUE; |
| } |
| |
| if (!mode) /* move the file */ |
| if (rename( full_name1.long_name, full_name2.long_name ) == -1) |
| { |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| else return TRUE; |
| else /* copy File */ |
| return CopyFile32A(fn1, fn2, (!(flag & MOVEFILE_REPLACE_EXISTING))); |
| |
| } |
| |
| /************************************************************************** |
| * MoveFileEx32W (KERNEL32.???) |
| */ |
| BOOL32 WINAPI MoveFileEx32W( LPCWSTR fn1, LPCWSTR fn2, DWORD flag ) |
| { |
| LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 ); |
| LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 ); |
| BOOL32 res = MoveFileEx32A( afn1, afn2, flag ); |
| HeapFree( GetProcessHeap(), 0, afn1 ); |
| HeapFree( GetProcessHeap(), 0, afn2 ); |
| return res; |
| } |
| |
| |
| /************************************************************************** |
| * MoveFile32A (KERNEL32.387) |
| * |
| * Move file or directory |
| */ |
| BOOL32 WINAPI MoveFile32A( LPCSTR fn1, LPCSTR fn2 ) |
| { |
| DOS_FULL_NAME full_name1, full_name2; |
| struct stat fstat; |
| |
| TRACE(file, "(%s,%s)\n", fn1, fn2 ); |
| |
| if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE; |
| if (DOSFS_GetFullName( fn2, TRUE, &full_name2 )) |
| /* The new name must not already exist */ |
| return FALSE; |
| if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE; |
| |
| if (full_name1.drive == full_name2.drive) /* move */ |
| if (rename( full_name1.long_name, full_name2.long_name ) == -1) |
| { |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| else return TRUE; |
| else /*copy */ { |
| if (stat( full_name1.long_name, &fstat )) |
| { |
| WARN(file, "Invalid source file %s\n", |
| full_name1.long_name); |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| if (S_ISDIR(fstat.st_mode)) { |
| /* No Move for directories across file systems */ |
| /* FIXME: Use right error code */ |
| DOS_ERROR( ER_GeneralFailure, EC_SystemFailure, SA_Abort, |
| EL_Unknown ); |
| return FALSE; |
| } |
| else |
| return CopyFile32A(fn1, fn2, TRUE); /*fail, if exist */ |
| } |
| } |
| |
| |
| /************************************************************************** |
| * MoveFile32W (KERNEL32.390) |
| */ |
| BOOL32 WINAPI MoveFile32W( LPCWSTR fn1, LPCWSTR fn2 ) |
| { |
| LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 ); |
| LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 ); |
| BOOL32 res = MoveFile32A( afn1, afn2 ); |
| HeapFree( GetProcessHeap(), 0, afn1 ); |
| HeapFree( GetProcessHeap(), 0, afn2 ); |
| return res; |
| } |
| |
| |
| /************************************************************************** |
| * CopyFile32A (KERNEL32.36) |
| */ |
| BOOL32 WINAPI CopyFile32A( LPCSTR source, LPCSTR dest, BOOL32 fail_if_exists ) |
| { |
| HFILE32 h1, h2; |
| BY_HANDLE_FILE_INFORMATION info; |
| UINT32 count; |
| BOOL32 ret = FALSE; |
| int mode; |
| char buffer[2048]; |
| |
| if ((h1 = _lopen32( source, OF_READ )) == HFILE_ERROR32) return FALSE; |
| if (!GetFileInformationByHandle( h1, &info )) |
| { |
| CloseHandle( h1 ); |
| return FALSE; |
| } |
| mode = (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? 0444 : 0666; |
| if ((h2 = FILE_Create( dest, mode, fail_if_exists )) == HFILE_ERROR32) |
| { |
| CloseHandle( h1 ); |
| return FALSE; |
| } |
| while ((count = _lread32( h1, buffer, sizeof(buffer) )) > 0) |
| { |
| char *p = buffer; |
| while (count > 0) |
| { |
| INT32 res = _lwrite32( h2, p, count ); |
| if (res <= 0) goto done; |
| p += res; |
| count -= res; |
| } |
| } |
| ret = TRUE; |
| done: |
| CloseHandle( h1 ); |
| CloseHandle( h2 ); |
| return ret; |
| } |
| |
| |
| /************************************************************************** |
| * CopyFile32W (KERNEL32.37) |
| */ |
| BOOL32 WINAPI CopyFile32W( LPCWSTR source, LPCWSTR dest, BOOL32 fail_if_exists) |
| { |
| LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, source ); |
| LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, dest ); |
| BOOL32 ret = CopyFile32A( sourceA, destA, fail_if_exists ); |
| HeapFree( GetProcessHeap(), 0, sourceA ); |
| HeapFree( GetProcessHeap(), 0, destA ); |
| return ret; |
| } |
| |
| |
| /************************************************************************** |
| * CopyFileEx32A (KERNEL32.858) |
| * |
| * This implementation ignores most of the extra parameters passed-in into |
| * the "ex" version of the method and calls the CopyFile method. |
| * It will have to be fixed eventually. |
| */ |
| BOOL32 WINAPI CopyFileEx32A(LPCSTR sourceFilename, |
| LPCSTR destFilename, |
| LPPROGRESS_ROUTINE progressRoutine, |
| LPVOID appData, |
| LPBOOL32 cancelFlagPointer, |
| DWORD copyFlags) |
| { |
| BOOL32 failIfExists = FALSE; |
| |
| /* |
| * Interpret the only flag that CopyFile can interpret. |
| */ |
| if ( (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0) |
| { |
| failIfExists = TRUE; |
| } |
| |
| return CopyFile32A(sourceFilename, destFilename, failIfExists); |
| } |
| |
| /************************************************************************** |
| * CopyFileEx32W (KERNEL32.859) |
| */ |
| BOOL32 WINAPI CopyFileEx32W(LPCWSTR sourceFilename, |
| LPCWSTR destFilename, |
| LPPROGRESS_ROUTINE progressRoutine, |
| LPVOID appData, |
| LPBOOL32 cancelFlagPointer, |
| DWORD copyFlags) |
| { |
| LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, sourceFilename ); |
| LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, destFilename ); |
| |
| BOOL32 ret = CopyFileEx32A(sourceA, |
| destA, |
| progressRoutine, |
| appData, |
| cancelFlagPointer, |
| copyFlags); |
| |
| HeapFree( GetProcessHeap(), 0, sourceA ); |
| HeapFree( GetProcessHeap(), 0, destA ); |
| |
| return ret; |
| } |
| |
| |
| /*********************************************************************** |
| * SetFileTime (KERNEL32.650) |
| */ |
| BOOL32 WINAPI SetFileTime( HFILE32 hFile, |
| const FILETIME *lpCreationTime, |
| const FILETIME *lpLastAccessTime, |
| const FILETIME *lpLastWriteTime ) |
| { |
| FILE_OBJECT *file = FILE_GetFile(hFile, 0, NULL); |
| struct utimbuf utimbuf; |
| |
| if (!file) return FILE_TYPE_UNKNOWN; /* FIXME: correct? */ |
| TRACE(file,"('%s',%p,%p,%p)\n", |
| file->unix_name, |
| lpCreationTime, |
| lpLastAccessTime, |
| lpLastWriteTime |
| ); |
| if (lpLastAccessTime) |
| utimbuf.actime = DOSFS_FileTimeToUnixTime(lpLastAccessTime, NULL); |
| else |
| utimbuf.actime = 0; /* FIXME */ |
| if (lpLastWriteTime) |
| utimbuf.modtime = DOSFS_FileTimeToUnixTime(lpLastWriteTime, NULL); |
| else |
| utimbuf.modtime = 0; /* FIXME */ |
| if (-1==utime(file->unix_name,&utimbuf)) |
| { |
| MSG("Couldn't set the time for file '%s'. Insufficient permissions !?\n", file->unix_name); |
| FILE_ReleaseFile( file ); |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| FILE_ReleaseFile( file ); |
| return TRUE; |
| } |
| |
| /* Locks need to be mirrored because unix file locking is based |
| * on the pid. Inside of wine there can be multiple WINE processes |
| * that share the same unix pid. |
| * Read's and writes should check these locks also - not sure |
| * how critical that is at this point (FIXME). |
| */ |
| |
| static BOOL32 DOS_AddLock(FILE_OBJECT *file, struct flock *f) |
| { |
| DOS_FILE_LOCK *curr; |
| DWORD processId; |
| |
| processId = GetCurrentProcessId(); |
| |
| /* check if lock overlaps a current lock for the same file */ |
| for (curr = locks; curr; curr = curr->next) { |
| if (strcmp(curr->unix_name, file->unix_name) == 0) { |
| if ((f->l_start == curr->base) && (f->l_len == curr->len)) |
| return TRUE;/* region is identic */ |
| if ((f->l_start < (curr->base + curr->len)) && |
| ((f->l_start + f->l_len) > curr->base)) { |
| /* region overlaps */ |
| return FALSE; |
| } |
| } |
| } |
| |
| curr = HeapAlloc( SystemHeap, 0, sizeof(DOS_FILE_LOCK) ); |
| curr->processId = GetCurrentProcessId(); |
| curr->base = f->l_start; |
| curr->len = f->l_len; |
| curr->unix_name = HEAP_strdupA( SystemHeap, 0, file->unix_name); |
| curr->next = locks; |
| curr->dos_file = file; |
| locks = curr; |
| return TRUE; |
| } |
| |
| static void DOS_RemoveFileLocks(FILE_OBJECT *file) |
| { |
| DWORD processId; |
| DOS_FILE_LOCK **curr; |
| DOS_FILE_LOCK *rem; |
| |
| processId = GetCurrentProcessId(); |
| curr = &locks; |
| while (*curr) { |
| if ((*curr)->dos_file == file) { |
| rem = *curr; |
| *curr = (*curr)->next; |
| HeapFree( SystemHeap, 0, rem->unix_name ); |
| HeapFree( SystemHeap, 0, rem ); |
| } |
| else |
| curr = &(*curr)->next; |
| } |
| } |
| |
| static BOOL32 DOS_RemoveLock(FILE_OBJECT *file, struct flock *f) |
| { |
| DWORD processId; |
| DOS_FILE_LOCK **curr; |
| DOS_FILE_LOCK *rem; |
| |
| processId = GetCurrentProcessId(); |
| for (curr = &locks; *curr; curr = &(*curr)->next) { |
| if ((*curr)->processId == processId && |
| (*curr)->dos_file == file && |
| (*curr)->base == f->l_start && |
| (*curr)->len == f->l_len) { |
| /* this is the same lock */ |
| rem = *curr; |
| *curr = (*curr)->next; |
| HeapFree( SystemHeap, 0, rem->unix_name ); |
| HeapFree( SystemHeap, 0, rem ); |
| return TRUE; |
| } |
| } |
| /* no matching lock found */ |
| return FALSE; |
| } |
| |
| |
| /************************************************************************** |
| * LockFile (KERNEL32.511) |
| */ |
| BOOL32 WINAPI LockFile( |
| HFILE32 hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh, |
| DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh ) |
| { |
| struct flock f; |
| FILE_OBJECT *file; |
| |
| TRACE(file, "handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n", |
| hFile, dwFileOffsetLow, dwFileOffsetHigh, |
| nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh); |
| |
| if (dwFileOffsetHigh || nNumberOfBytesToLockHigh) { |
| FIXME(file, "Unimplemented bytes > 32bits\n"); |
| return FALSE; |
| } |
| |
| f.l_start = dwFileOffsetLow; |
| f.l_len = nNumberOfBytesToLockLow; |
| f.l_whence = SEEK_SET; |
| f.l_pid = 0; |
| f.l_type = F_WRLCK; |
| |
| if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE; |
| |
| /* shadow locks internally */ |
| if (!DOS_AddLock(file, &f)) { |
| DOS_ERROR( ER_LockViolation, EC_AccessDenied, SA_Ignore, EL_Disk ); |
| return FALSE; |
| } |
| |
| /* FIXME: Unix locking commented out for now, doesn't work with Excel */ |
| #ifdef USE_UNIX_LOCKS |
| if (fcntl(file->unix_handle, F_SETLK, &f) == -1) { |
| if (errno == EACCES || errno == EAGAIN) { |
| DOS_ERROR( ER_LockViolation, EC_AccessDenied, SA_Ignore, EL_Disk ); |
| } |
| else { |
| FILE_SetDosError(); |
| } |
| /* remove our internal copy of the lock */ |
| DOS_RemoveLock(file, &f); |
| return FALSE; |
| } |
| #endif |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * UnlockFile (KERNEL32.703) |
| */ |
| BOOL32 WINAPI UnlockFile( |
| HFILE32 hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh, |
| DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh ) |
| { |
| FILE_OBJECT *file; |
| struct flock f; |
| |
| TRACE(file, "handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n", |
| hFile, dwFileOffsetLow, dwFileOffsetHigh, |
| nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh); |
| |
| if (dwFileOffsetHigh || nNumberOfBytesToUnlockHigh) { |
| WARN(file, "Unimplemented bytes > 32bits\n"); |
| return FALSE; |
| } |
| |
| f.l_start = dwFileOffsetLow; |
| f.l_len = nNumberOfBytesToUnlockLow; |
| f.l_whence = SEEK_SET; |
| f.l_pid = 0; |
| f.l_type = F_UNLCK; |
| |
| if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE; |
| |
| DOS_RemoveLock(file, &f); /* ok if fails - may be another wine */ |
| |
| /* FIXME: Unix locking commented out for now, doesn't work with Excel */ |
| #ifdef USE_UNIX_LOCKS |
| if (fcntl(file->unix_handle, F_SETLK, &f) == -1) { |
| FILE_SetDosError(); |
| return FALSE; |
| } |
| #endif |
| return TRUE; |
| } |
| |
| /************************************************************************** |
| * GetFileAttributesEx32A [KERNEL32.874] |
| */ |
| BOOL32 WINAPI GetFileAttributesEx32A( |
| LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, |
| LPVOID lpFileInformation) |
| { |
| DOS_FULL_NAME full_name; |
| BY_HANDLE_FILE_INFORMATION info; |
| |
| if (lpFileName == NULL) return FALSE; |
| if (lpFileInformation == NULL) return FALSE; |
| |
| if (fInfoLevelId == GetFileExInfoStandard) { |
| LPWIN32_FILE_ATTRIBUTE_DATA lpFad = |
| (LPWIN32_FILE_ATTRIBUTE_DATA) lpFileInformation; |
| if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name )) return FALSE; |
| if (!FILE_Stat( full_name.long_name, &info )) return FALSE; |
| |
| lpFad->dwFileAttributes = info.dwFileAttributes; |
| lpFad->ftCreationTime = info.ftCreationTime; |
| lpFad->ftLastAccessTime = info.ftLastAccessTime; |
| lpFad->ftLastWriteTime = info.ftLastWriteTime; |
| lpFad->nFileSizeHigh = info.nFileSizeHigh; |
| lpFad->nFileSizeLow = info.nFileSizeLow; |
| } |
| else { |
| FIXME (file, "invalid info level %d!\n", fInfoLevelId); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| |
| /************************************************************************** |
| * GetFileAttributesEx32W [KERNEL32.875] |
| */ |
| BOOL32 WINAPI GetFileAttributesEx32W( |
| LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, |
| LPVOID lpFileInformation) |
| { |
| LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName ); |
| BOOL32 res = |
| GetFileAttributesEx32A( nameA, fInfoLevelId, lpFileInformation); |
| HeapFree( GetProcessHeap(), 0, nameA ); |
| return res; |
| } |
| |
| |