1520 lines
46 KiB
C
1520 lines
46 KiB
C
/*
|
|
* File handling functions
|
|
*
|
|
* Copyright 1993 John Burton
|
|
* Copyright 1996 Alexandre Julliard
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* TODO:
|
|
* Fix the CopyFileEx methods to implement the "extended" functionality.
|
|
* Right now, they simply call the CopyFile method.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#ifdef HAVE_SYS_ERRNO_H
|
|
#include <sys/errno.h>
|
|
#endif
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#ifdef HAVE_SYS_MMAN_H
|
|
#include <sys/mman.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_TIME_H
|
|
# include <sys/time.h>
|
|
#endif
|
|
#ifdef HAVE_SYS_POLL_H
|
|
# include <sys/poll.h>
|
|
#endif
|
|
#include <time.h>
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
#ifdef HAVE_UTIME_H
|
|
# include <utime.h>
|
|
#endif
|
|
|
|
#define NONAMELESSUNION
|
|
#define NONAMELESSSTRUCT
|
|
#include "winerror.h"
|
|
#include "ntstatus.h"
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winreg.h"
|
|
#include "winternl.h"
|
|
#include "wine/winbase16.h"
|
|
#include "wine/server.h"
|
|
|
|
#include "file.h"
|
|
#include "wincon.h"
|
|
#include "kernel_private.h"
|
|
|
|
#include "smb.h"
|
|
#include "wine/unicode.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(file);
|
|
|
|
#if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
|
|
#define MAP_ANON MAP_ANONYMOUS
|
|
#endif
|
|
|
|
#define IS_OPTION_TRUE(ch) ((ch) == 'y' || (ch) == 'Y' || (ch) == 't' || (ch) == 'T' || (ch) == '1')
|
|
|
|
#define SECSPERDAY 86400
|
|
#define SECS_1601_TO_1970 ((369 * 365 + 89) * (ULONGLONG)SECSPERDAY)
|
|
|
|
/***********************************************************************
|
|
* FILE_ConvertOFMode
|
|
*
|
|
* Convert OF_* mode into flags for CreateFile.
|
|
*/
|
|
void FILE_ConvertOFMode( INT mode, DWORD *access, DWORD *sharing )
|
|
{
|
|
switch(mode & 0x03)
|
|
{
|
|
case OF_READ: *access = GENERIC_READ; break;
|
|
case OF_WRITE: *access = GENERIC_WRITE; break;
|
|
case OF_READWRITE: *access = GENERIC_READ | GENERIC_WRITE; break;
|
|
default: *access = 0; break;
|
|
}
|
|
switch(mode & 0x70)
|
|
{
|
|
case OF_SHARE_EXCLUSIVE: *sharing = 0; break;
|
|
case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
|
|
case OF_SHARE_DENY_READ: *sharing = FILE_SHARE_WRITE; break;
|
|
case OF_SHARE_DENY_NONE:
|
|
case OF_SHARE_COMPAT:
|
|
default: *sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* FILE_SetDosError
|
|
*
|
|
* Set the DOS error code from errno.
|
|
*/
|
|
void FILE_SetDosError(void)
|
|
{
|
|
int save_errno = errno; /* errno gets overwritten by printf */
|
|
|
|
TRACE("errno = %d %s\n", errno, strerror(errno));
|
|
switch (save_errno)
|
|
{
|
|
case EAGAIN:
|
|
SetLastError( ERROR_SHARING_VIOLATION );
|
|
break;
|
|
case EBADF:
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
break;
|
|
case ENOSPC:
|
|
SetLastError( ERROR_HANDLE_DISK_FULL );
|
|
break;
|
|
case EACCES:
|
|
case EPERM:
|
|
case EROFS:
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
break;
|
|
case EBUSY:
|
|
SetLastError( ERROR_LOCK_VIOLATION );
|
|
break;
|
|
case ENOENT:
|
|
SetLastError( ERROR_FILE_NOT_FOUND );
|
|
break;
|
|
case EISDIR:
|
|
SetLastError( ERROR_CANNOT_MAKE );
|
|
break;
|
|
case ENFILE:
|
|
case EMFILE:
|
|
SetLastError( ERROR_NO_MORE_FILES );
|
|
break;
|
|
case EEXIST:
|
|
SetLastError( ERROR_FILE_EXISTS );
|
|
break;
|
|
case EINVAL:
|
|
case ESPIPE:
|
|
SetLastError( ERROR_SEEK );
|
|
break;
|
|
case ENOTEMPTY:
|
|
SetLastError( ERROR_DIR_NOT_EMPTY );
|
|
break;
|
|
case ENOEXEC:
|
|
SetLastError( ERROR_BAD_FORMAT );
|
|
break;
|
|
default:
|
|
WARN("unknown file error: %s\n", strerror(save_errno) );
|
|
SetLastError( ERROR_GEN_FAILURE );
|
|
break;
|
|
}
|
|
errno = save_errno;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* FILE_CreateFile
|
|
*
|
|
* Implementation of CreateFile. Takes a Unix path name.
|
|
* Returns 0 on failure.
|
|
*/
|
|
HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
|
|
LPSECURITY_ATTRIBUTES sa, DWORD creation,
|
|
DWORD attributes, HANDLE template )
|
|
{
|
|
unsigned int err;
|
|
UINT disp, options;
|
|
HANDLE ret;
|
|
|
|
switch (creation)
|
|
{
|
|
case CREATE_ALWAYS: disp = FILE_OVERWRITE_IF; break;
|
|
case CREATE_NEW: disp = FILE_CREATE; break;
|
|
case OPEN_ALWAYS: disp = FILE_OPEN_IF; break;
|
|
case OPEN_EXISTING: disp = FILE_OPEN; break;
|
|
case TRUNCATE_EXISTING: disp = FILE_OVERWRITE; break;
|
|
default:
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
|
|
options = 0;
|
|
if (attributes & FILE_FLAG_BACKUP_SEMANTICS)
|
|
options |= FILE_OPEN_FOR_BACKUP_INTENT;
|
|
else
|
|
options |= FILE_NON_DIRECTORY_FILE;
|
|
if (attributes & FILE_FLAG_DELETE_ON_CLOSE)
|
|
options |= FILE_DELETE_ON_CLOSE;
|
|
if (!(attributes & FILE_FLAG_OVERLAPPED))
|
|
options |= FILE_SYNCHRONOUS_IO_ALERT;
|
|
if (attributes & FILE_FLAG_RANDOM_ACCESS)
|
|
options |= FILE_RANDOM_ACCESS;
|
|
attributes &= FILE_ATTRIBUTE_VALID_FLAGS;
|
|
|
|
SERVER_START_REQ( create_file )
|
|
{
|
|
req->access = access;
|
|
req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
|
|
req->sharing = sharing;
|
|
req->create = disp;
|
|
req->options = options;
|
|
req->attrs = attributes;
|
|
wine_server_add_data( req, filename, strlen(filename) );
|
|
SetLastError(0);
|
|
err = wine_server_call( req );
|
|
ret = reply->handle;
|
|
}
|
|
SERVER_END_REQ;
|
|
|
|
if (err)
|
|
{
|
|
/* In the case file creation was rejected due to CREATE_NEW flag
|
|
* was specified and file with that name already exists, correct
|
|
* last error is ERROR_FILE_EXISTS and not ERROR_ALREADY_EXISTS.
|
|
* Note: RtlNtStatusToDosError is not the subject to blame here.
|
|
*/
|
|
if (err == STATUS_OBJECT_NAME_COLLISION)
|
|
SetLastError( ERROR_FILE_EXISTS );
|
|
else
|
|
SetLastError( RtlNtStatusToDosError(err) );
|
|
}
|
|
|
|
if (!ret) WARN("Unable to create file '%s' (GLE %ld)\n", filename, GetLastError());
|
|
return ret;
|
|
}
|
|
|
|
|
|
static HANDLE FILE_OpenPipe(LPCWSTR name, DWORD access, LPSECURITY_ATTRIBUTES sa )
|
|
{
|
|
HANDLE ret;
|
|
DWORD len = 0;
|
|
|
|
if (name && (len = strlenW(name)) > MAX_PATH)
|
|
{
|
|
SetLastError( ERROR_FILENAME_EXCED_RANGE );
|
|
return 0;
|
|
}
|
|
SERVER_START_REQ( open_named_pipe )
|
|
{
|
|
req->access = access;
|
|
req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
|
|
SetLastError(0);
|
|
wine_server_add_data( req, name, len * sizeof(WCHAR) );
|
|
wine_server_call_err( req );
|
|
ret = reply->handle;
|
|
}
|
|
SERVER_END_REQ;
|
|
TRACE("Returned %p\n",ret);
|
|
return ret;
|
|
}
|
|
|
|
/*************************************************************************
|
|
* CreateFileW [KERNEL32.@] Creates or opens a file or other object
|
|
*
|
|
* Creates or opens an object, and returns a handle that can be used to
|
|
* access that object.
|
|
*
|
|
* PARAMS
|
|
*
|
|
* filename [in] pointer to filename to be accessed
|
|
* access [in] access mode requested
|
|
* sharing [in] share mode
|
|
* sa [in] pointer to security attributes
|
|
* creation [in] how to create the file
|
|
* attributes [in] attributes for newly created file
|
|
* template [in] handle to file with extended attributes to copy
|
|
*
|
|
* RETURNS
|
|
* Success: Open handle to specified file
|
|
* Failure: INVALID_HANDLE_VALUE
|
|
*
|
|
* NOTES
|
|
* Should call SetLastError() on failure.
|
|
*
|
|
* BUGS
|
|
*
|
|
* Doesn't support character devices, template files, or a
|
|
* lot of the 'attributes' flags yet.
|
|
*/
|
|
HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
|
|
LPSECURITY_ATTRIBUTES sa, DWORD creation,
|
|
DWORD attributes, HANDLE template )
|
|
{
|
|
DOS_FULL_NAME full_name;
|
|
HANDLE ret;
|
|
DWORD dosdev;
|
|
static const WCHAR bkslashes_with_question_markW[] = {'\\','\\','?','\\',0};
|
|
static const WCHAR bkslashes_with_dotW[] = {'\\','\\','.','\\',0};
|
|
static const WCHAR bkslashesW[] = {'\\','\\',0};
|
|
static const WCHAR coninW[] = {'C','O','N','I','N','$',0};
|
|
static const WCHAR conoutW[] = {'C','O','N','O','U','T','$',0};
|
|
|
|
if (!filename || !filename[0])
|
|
{
|
|
SetLastError( ERROR_PATH_NOT_FOUND );
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
TRACE("%s %s%s%s%s%s%s%s attributes 0x%lx\n", debugstr_w(filename),
|
|
((access & GENERIC_READ)==GENERIC_READ)?"GENERIC_READ ":"",
|
|
((access & GENERIC_WRITE)==GENERIC_WRITE)?"GENERIC_WRITE ":"",
|
|
(!access)?"QUERY_ACCESS ":"",
|
|
((sharing & FILE_SHARE_READ)==FILE_SHARE_READ)?"FILE_SHARE_READ ":"",
|
|
((sharing & FILE_SHARE_WRITE)==FILE_SHARE_WRITE)?"FILE_SHARE_WRITE ":"",
|
|
((sharing & FILE_SHARE_DELETE)==FILE_SHARE_DELETE)?"FILE_SHARE_DELETE ":"",
|
|
(creation ==CREATE_NEW)?"CREATE_NEW":
|
|
(creation ==CREATE_ALWAYS)?"CREATE_ALWAYS ":
|
|
(creation ==OPEN_EXISTING)?"OPEN_EXISTING ":
|
|
(creation ==OPEN_ALWAYS)?"OPEN_ALWAYS ":
|
|
(creation ==TRUNCATE_EXISTING)?"TRUNCATE_EXISTING ":"", attributes);
|
|
|
|
/* Open a console for CONIN$ or CONOUT$ */
|
|
if (!strcmpiW(filename, coninW) || !strcmpiW(filename, conoutW))
|
|
{
|
|
ret = OpenConsoleW(filename, access, (sa && sa->bInheritHandle), creation);
|
|
goto done;
|
|
}
|
|
|
|
/* If the name starts with '\\?\', ignore the first 4 chars. */
|
|
if (!strncmpW(filename, bkslashes_with_question_markW, 4))
|
|
{
|
|
static const WCHAR uncW[] = {'U','N','C','\\',0};
|
|
filename += 4;
|
|
if (!strncmpiW(filename, uncW, 4))
|
|
{
|
|
FIXME("UNC name (%s) not supported.\n", debugstr_w(filename) );
|
|
SetLastError( ERROR_PATH_NOT_FOUND );
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
|
|
if (!strncmpW(filename, bkslashes_with_dotW, 4))
|
|
{
|
|
static const WCHAR pipeW[] = {'P','I','P','E','\\',0};
|
|
if(!strncmpiW(filename + 4, pipeW, 5))
|
|
{
|
|
TRACE("Opening a pipe: %s\n", debugstr_w(filename));
|
|
ret = FILE_OpenPipe( filename, access, sa );
|
|
goto done;
|
|
}
|
|
else if (isalphaW(filename[4]) && filename[5] == ':' && filename[6] == '\0')
|
|
{
|
|
const char *device = DRIVE_GetDevice( toupperW(filename[4]) - 'A' );
|
|
if (device)
|
|
{
|
|
ret = FILE_CreateFile( device, access, sharing, sa, creation,
|
|
attributes, template );
|
|
}
|
|
else
|
|
{
|
|
SetLastError( ERROR_ACCESS_DENIED );
|
|
ret = INVALID_HANDLE_VALUE;
|
|
}
|
|
goto done;
|
|
}
|
|
else if ((dosdev = RtlIsDosDeviceName_U( filename + 4 )))
|
|
{
|
|
dosdev += MAKELONG( 0, 4*sizeof(WCHAR) ); /* adjust position to start of filename */
|
|
}
|
|
else
|
|
{
|
|
ret = VXD_Open( filename+4, access, sa );
|
|
goto done;
|
|
}
|
|
}
|
|
else dosdev = RtlIsDosDeviceName_U( filename );
|
|
|
|
if (dosdev)
|
|
{
|
|
static const WCHAR conW[] = {'C','O','N',0};
|
|
WCHAR dev[5];
|
|
|
|
memcpy( dev, filename + HIWORD(dosdev)/sizeof(WCHAR), LOWORD(dosdev) );
|
|
dev[LOWORD(dosdev)/sizeof(WCHAR)] = 0;
|
|
|
|
TRACE("opening device %s\n", debugstr_w(dev) );
|
|
|
|
if (!strcmpiW( dev, conW ))
|
|
{
|
|
switch (access & (GENERIC_READ|GENERIC_WRITE))
|
|
{
|
|
case GENERIC_READ:
|
|
ret = OpenConsoleW(coninW, access, (sa && sa->bInheritHandle), creation);
|
|
goto done;
|
|
case GENERIC_WRITE:
|
|
ret = OpenConsoleW(conoutW, access, (sa && sa->bInheritHandle), creation);
|
|
goto done;
|
|
default:
|
|
FIXME("can't open CON read/write\n");
|
|
SetLastError( ERROR_FILE_NOT_FOUND );
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
}
|
|
|
|
ret = VOLUME_OpenDevice( dev, access, sharing, sa, attributes );
|
|
goto done;
|
|
}
|
|
|
|
/* If the name still starts with '\\', it's a UNC name. */
|
|
if (!strncmpW(filename, bkslashesW, 2))
|
|
{
|
|
ret = SMB_CreateFileW(filename, access, sharing, sa, creation, attributes, template );
|
|
goto done;
|
|
}
|
|
|
|
/* If the name contains a DOS wild card (* or ?), do no create a file */
|
|
if(strchrW(filename, '*') || strchrW(filename, '?'))
|
|
{
|
|
SetLastError(ERROR_BAD_PATHNAME);
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
/* check for filename, don't check for last entry if creating */
|
|
if (!DOSFS_GetFullName( filename,
|
|
(creation == OPEN_EXISTING) ||
|
|
(creation == TRUNCATE_EXISTING),
|
|
&full_name )) {
|
|
WARN("Unable to get full filename from %s (GLE %ld)\n",
|
|
debugstr_w(filename), GetLastError());
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
ret = FILE_CreateFile( full_name.long_name, access, sharing,
|
|
sa, creation, attributes, template );
|
|
done:
|
|
if (!ret) ret = INVALID_HANDLE_VALUE;
|
|
TRACE("returning %p\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
* CreateFileA (KERNEL32.@)
|
|
*/
|
|
HANDLE WINAPI CreateFileA( LPCSTR filename, DWORD access, DWORD sharing,
|
|
LPSECURITY_ATTRIBUTES sa, DWORD creation,
|
|
DWORD attributes, HANDLE template)
|
|
{
|
|
UNICODE_STRING filenameW;
|
|
HANDLE ret = INVALID_HANDLE_VALUE;
|
|
|
|
if (!filename)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
if (RtlCreateUnicodeStringFromAsciiz(&filenameW, filename))
|
|
{
|
|
ret = CreateFileW(filenameW.Buffer, access, sharing, sa, creation,
|
|
attributes, template);
|
|
RtlFreeUnicodeString(&filenameW);
|
|
}
|
|
else
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* 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;
|
|
|
|
RtlSecondsSince1970ToTime( st->st_mtime, (LARGE_INTEGER *)&info->ftCreationTime );
|
|
RtlSecondsSince1970ToTime( st->st_mtime, (LARGE_INTEGER *)&info->ftLastWriteTime );
|
|
RtlSecondsSince1970ToTime( st->st_atime, (LARGE_INTEGER *)&info->ftLastAccessTime );
|
|
|
|
info->dwVolumeSerialNumber = 0; /* FIXME */
|
|
if (S_ISDIR(st->st_mode))
|
|
{
|
|
info->nFileSizeHigh = 0;
|
|
info->nFileSizeLow = 0;
|
|
info->nNumberOfLinks = 1;
|
|
}
|
|
else
|
|
{
|
|
info->nFileSizeHigh = st->st_size >> 32;
|
|
info->nFileSizeLow = (DWORD)st->st_size;
|
|
info->nNumberOfLinks = st->st_nlink;
|
|
}
|
|
info->nFileIndexHigh = st->st_ino >> 32;
|
|
info->nFileIndexLow = (DWORD)st->st_ino;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* get_show_dot_files_option
|
|
*/
|
|
static BOOL get_show_dot_files_option(void)
|
|
{
|
|
static const WCHAR WineW[] = {'M','a','c','h','i','n','e','\\',
|
|
'S','o','f','t','w','a','r','e','\\',
|
|
'W','i','n','e','\\','W','i','n','e','\\',
|
|
'C','o','n','f','i','g','\\','W','i','n','e',0};
|
|
static const WCHAR ShowDotFilesW[] = {'S','h','o','w','D','o','t','F','i','l','e','s',0};
|
|
|
|
char tmp[80];
|
|
HKEY hkey;
|
|
DWORD dummy;
|
|
OBJECT_ATTRIBUTES attr;
|
|
UNICODE_STRING nameW;
|
|
BOOL ret = FALSE;
|
|
|
|
attr.Length = sizeof(attr);
|
|
attr.RootDirectory = 0;
|
|
attr.ObjectName = &nameW;
|
|
attr.Attributes = 0;
|
|
attr.SecurityDescriptor = NULL;
|
|
attr.SecurityQualityOfService = NULL;
|
|
RtlInitUnicodeString( &nameW, WineW );
|
|
|
|
if (!NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr ))
|
|
{
|
|
RtlInitUnicodeString( &nameW, ShowDotFilesW );
|
|
if (!NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation, tmp, sizeof(tmp), &dummy ))
|
|
{
|
|
WCHAR *str = (WCHAR *)((KEY_VALUE_PARTIAL_INFORMATION *)tmp)->Data;
|
|
ret = IS_OPTION_TRUE( str[0] );
|
|
}
|
|
NtClose( hkey );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* FILE_Stat
|
|
*
|
|
* Stat a Unix path name. Return TRUE if OK.
|
|
*/
|
|
BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info, BOOL *is_symlink_ptr )
|
|
{
|
|
struct stat st;
|
|
int is_symlink;
|
|
LPCSTR p;
|
|
|
|
if (lstat( unixName, &st ) == -1)
|
|
{
|
|
FILE_SetDosError();
|
|
return FALSE;
|
|
}
|
|
is_symlink = S_ISLNK(st.st_mode);
|
|
if (is_symlink)
|
|
{
|
|
/* do a "real" stat to find out
|
|
about the type of the symlink destination */
|
|
if (stat( unixName, &st ) == -1)
|
|
{
|
|
FILE_SetDosError();
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* fill in the information we gathered so far */
|
|
FILE_FillInfo( &st, info );
|
|
|
|
/* and now see if this is a hidden file, based on the name */
|
|
p = strrchr( unixName, '/');
|
|
p = p ? p + 1 : unixName;
|
|
if (*p == '.' && *(p+1) && (*(p+1) != '.' || *(p+2)))
|
|
{
|
|
static int show_dot_files = -1;
|
|
if (show_dot_files == -1)
|
|
show_dot_files = get_show_dot_files_option();
|
|
if (!show_dot_files)
|
|
info->dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;
|
|
}
|
|
if (is_symlink_ptr) *is_symlink_ptr = is_symlink;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetFileInformationByHandle (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI GetFileInformationByHandle( HANDLE hFile, BY_HANDLE_FILE_INFORMATION *info )
|
|
{
|
|
NTSTATUS status;
|
|
int fd;
|
|
BOOL ret = FALSE;
|
|
|
|
TRACE("%p,%p\n", hFile, info);
|
|
|
|
if (!info) return 0;
|
|
|
|
if (!(status = wine_server_handle_to_fd( hFile, 0, &fd, NULL, NULL )))
|
|
{
|
|
struct stat st;
|
|
|
|
if (fstat( fd, &st ) == -1)
|
|
FILE_SetDosError();
|
|
else if (!S_ISREG(st.st_mode) && !S_ISDIR(st.st_mode))
|
|
SetLastError( ERROR_INVALID_FUNCTION );
|
|
else
|
|
{
|
|
FILE_FillInfo( &st, info );
|
|
ret = TRUE;
|
|
}
|
|
wine_server_release_fd( hFile, fd );
|
|
}
|
|
else SetLastError( RtlNtStatusToDosError(status) );
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetFileTime (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI GetFileTime( HANDLE 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;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetTempFileNameA (KERNEL32.@)
|
|
*/
|
|
UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique,
|
|
LPSTR buffer)
|
|
{
|
|
UNICODE_STRING pathW, prefixW;
|
|
WCHAR bufferW[MAX_PATH];
|
|
UINT ret;
|
|
|
|
if ( !path || !prefix || !buffer )
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
|
|
RtlCreateUnicodeStringFromAsciiz(&pathW, path);
|
|
RtlCreateUnicodeStringFromAsciiz(&prefixW, prefix);
|
|
|
|
ret = GetTempFileNameW(pathW.Buffer, prefixW.Buffer, unique, bufferW);
|
|
if (ret)
|
|
WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
|
|
|
|
RtlFreeUnicodeString(&pathW);
|
|
RtlFreeUnicodeString(&prefixW);
|
|
return ret;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* GetTempFileNameW (KERNEL32.@)
|
|
*/
|
|
UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique,
|
|
LPWSTR buffer )
|
|
{
|
|
static const WCHAR formatW[] = {'%','x','.','t','m','p',0};
|
|
|
|
DOS_FULL_NAME full_name;
|
|
int i;
|
|
LPWSTR p;
|
|
|
|
if ( !path || !prefix || !buffer )
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return 0;
|
|
}
|
|
|
|
strcpyW( buffer, path );
|
|
p = buffer + strlenW(buffer);
|
|
|
|
/* add a \, if there isn't one */
|
|
if ((p == buffer) || (p[-1] != '\\')) *p++ = '\\';
|
|
|
|
for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
|
|
|
|
unique &= 0xffff;
|
|
|
|
if (unique) sprintfW( p, formatW, unique );
|
|
else
|
|
{
|
|
/* get a "random" unique number and try to create the file */
|
|
HANDLE handle;
|
|
UINT num = GetTickCount() & 0xffff;
|
|
|
|
if (!num) num = 1;
|
|
unique = num;
|
|
do
|
|
{
|
|
sprintfW( p, formatW, unique );
|
|
handle = CreateFileW( buffer, GENERIC_WRITE, 0, NULL,
|
|
CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
|
|
if (handle != INVALID_HANDLE_VALUE)
|
|
{ /* We created it */
|
|
TRACE("created %s\n", debugstr_w(buffer) );
|
|
CloseHandle( handle );
|
|
break;
|
|
}
|
|
if (GetLastError() != ERROR_FILE_EXISTS &&
|
|
GetLastError() != ERROR_SHARING_VIOLATION)
|
|
break; /* No need to go on */
|
|
if (!(++unique & 0xffff)) unique = 1;
|
|
} while (unique != num);
|
|
}
|
|
|
|
/* Get the full path name */
|
|
|
|
if (DOSFS_GetFullName( buffer, FALSE, &full_name ))
|
|
{
|
|
char *slash;
|
|
/* Check if we have write access in the directory */
|
|
if ((slash = strrchr( full_name.long_name, '/' ))) *slash = '\0';
|
|
if (access( full_name.long_name, W_OK ) == -1)
|
|
WARN("returns %s, which doesn't seem to be writeable.\n",
|
|
debugstr_w(buffer) );
|
|
}
|
|
TRACE("returning %s\n", debugstr_w(buffer) );
|
|
return unique;
|
|
}
|
|
|
|
|
|
/******************************************************************
|
|
* FILE_ReadWriteApc (internal)
|
|
*
|
|
*
|
|
*/
|
|
static void WINAPI FILE_ReadWriteApc(void* apc_user, PIO_STATUS_BLOCK io_status, ULONG len)
|
|
{
|
|
LPOVERLAPPED_COMPLETION_ROUTINE cr = (LPOVERLAPPED_COMPLETION_ROUTINE)apc_user;
|
|
|
|
cr(RtlNtStatusToDosError(io_status->u.Status), len, (LPOVERLAPPED)io_status);
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ReadFileEx (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
|
|
LPOVERLAPPED overlapped,
|
|
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
|
|
{
|
|
LARGE_INTEGER offset;
|
|
NTSTATUS status;
|
|
PIO_STATUS_BLOCK io_status;
|
|
|
|
if (!overlapped)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
offset.u.LowPart = overlapped->Offset;
|
|
offset.u.HighPart = overlapped->OffsetHigh;
|
|
io_status = (PIO_STATUS_BLOCK)overlapped;
|
|
io_status->u.Status = STATUS_PENDING;
|
|
|
|
status = NtReadFile(hFile, NULL, FILE_ReadWriteApc, lpCompletionRoutine,
|
|
io_status, buffer, bytesToRead, &offset, NULL);
|
|
|
|
if (status)
|
|
{
|
|
SetLastError( RtlNtStatusToDosError(status) );
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* ReadFile (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
|
|
LPDWORD bytesRead, LPOVERLAPPED overlapped )
|
|
{
|
|
LARGE_INTEGER offset;
|
|
PLARGE_INTEGER poffset = NULL;
|
|
IO_STATUS_BLOCK iosb;
|
|
PIO_STATUS_BLOCK io_status = &iosb;
|
|
HANDLE hEvent = 0;
|
|
NTSTATUS status;
|
|
|
|
TRACE("%p %p %ld %p %p\n", hFile, buffer, bytesToRead,
|
|
bytesRead, overlapped );
|
|
|
|
if (bytesRead) *bytesRead = 0; /* Do this before anything else */
|
|
if (!bytesToRead) return TRUE;
|
|
|
|
if (IsBadReadPtr(buffer, bytesToRead))
|
|
{
|
|
SetLastError(ERROR_WRITE_FAULT); /* FIXME */
|
|
return FALSE;
|
|
}
|
|
if (is_console_handle(hFile))
|
|
return ReadConsoleA(hFile, buffer, bytesToRead, bytesRead, NULL);
|
|
|
|
if (overlapped != NULL)
|
|
{
|
|
offset.u.LowPart = overlapped->Offset;
|
|
offset.u.HighPart = overlapped->OffsetHigh;
|
|
poffset = &offset;
|
|
hEvent = overlapped->hEvent;
|
|
io_status = (PIO_STATUS_BLOCK)overlapped;
|
|
}
|
|
io_status->u.Status = STATUS_PENDING;
|
|
io_status->Information = 0;
|
|
|
|
status = NtReadFile(hFile, hEvent, NULL, NULL, io_status, buffer, bytesToRead, poffset, NULL);
|
|
|
|
if (status != STATUS_PENDING && bytesRead)
|
|
*bytesRead = io_status->Information;
|
|
|
|
if (status && status != STATUS_END_OF_FILE)
|
|
{
|
|
SetLastError( RtlNtStatusToDosError(status) );
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* WriteFileEx (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
|
|
LPOVERLAPPED overlapped,
|
|
LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
|
|
{
|
|
LARGE_INTEGER offset;
|
|
NTSTATUS status;
|
|
PIO_STATUS_BLOCK io_status;
|
|
|
|
TRACE("%p %p %ld %p %p\n",
|
|
hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine);
|
|
|
|
if (overlapped == NULL)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
offset.u.LowPart = overlapped->Offset;
|
|
offset.u.HighPart = overlapped->OffsetHigh;
|
|
|
|
io_status = (PIO_STATUS_BLOCK)overlapped;
|
|
io_status->u.Status = STATUS_PENDING;
|
|
|
|
status = NtWriteFile(hFile, NULL, FILE_ReadWriteApc, lpCompletionRoutine,
|
|
io_status, buffer, bytesToWrite, &offset, NULL);
|
|
|
|
if (status) SetLastError( RtlNtStatusToDosError(status) );
|
|
return !status;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* WriteFile (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
|
|
LPDWORD bytesWritten, LPOVERLAPPED overlapped )
|
|
{
|
|
HANDLE hEvent = NULL;
|
|
LARGE_INTEGER offset;
|
|
PLARGE_INTEGER poffset = NULL;
|
|
NTSTATUS status;
|
|
IO_STATUS_BLOCK iosb;
|
|
PIO_STATUS_BLOCK piosb = &iosb;
|
|
|
|
TRACE("%p %p %ld %p %p\n",
|
|
hFile, buffer, bytesToWrite, bytesWritten, overlapped );
|
|
|
|
if (is_console_handle(hFile))
|
|
return WriteConsoleA(hFile, buffer, bytesToWrite, bytesWritten, NULL);
|
|
|
|
if (IsBadReadPtr(buffer, bytesToWrite))
|
|
{
|
|
SetLastError(ERROR_READ_FAULT); /* FIXME */
|
|
return FALSE;
|
|
}
|
|
|
|
if (overlapped)
|
|
{
|
|
offset.u.LowPart = overlapped->Offset;
|
|
offset.u.HighPart = overlapped->OffsetHigh;
|
|
poffset = &offset;
|
|
hEvent = overlapped->hEvent;
|
|
piosb = (PIO_STATUS_BLOCK)overlapped;
|
|
}
|
|
piosb->u.Status = STATUS_PENDING;
|
|
piosb->Information = 0;
|
|
|
|
status = NtWriteFile(hFile, hEvent, NULL, NULL, piosb,
|
|
buffer, bytesToWrite, poffset, NULL);
|
|
if (status)
|
|
{
|
|
SetLastError( RtlNtStatusToDosError(status) );
|
|
return FALSE;
|
|
}
|
|
if (bytesWritten) *bytesWritten = piosb->Information;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* SetFilePointer (KERNEL32.@)
|
|
*/
|
|
DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
|
|
DWORD method )
|
|
{
|
|
static const int whence[3] = { SEEK_SET, SEEK_CUR, SEEK_END };
|
|
DWORD ret = INVALID_SET_FILE_POINTER;
|
|
NTSTATUS status;
|
|
int fd;
|
|
|
|
TRACE("handle %p offset %ld high %ld origin %ld\n",
|
|
hFile, distance, highword?*highword:0, method );
|
|
|
|
if (method > FILE_END)
|
|
{
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
return ret;
|
|
}
|
|
|
|
if (!(status = wine_server_handle_to_fd( hFile, 0, &fd, NULL, NULL )))
|
|
{
|
|
off_t pos, res;
|
|
|
|
if (highword) pos = ((off_t)*highword << 32) | (ULONG)distance;
|
|
else pos = (off_t)distance;
|
|
if ((res = lseek( fd, pos, whence[method] )) == (off_t)-1)
|
|
{
|
|
/* also check EPERM due to SuSE7 2.2.16 lseek() EPERM kernel bug */
|
|
if (((errno == EINVAL) || (errno == EPERM)) && (method != FILE_BEGIN) && (pos < 0))
|
|
SetLastError( ERROR_NEGATIVE_SEEK );
|
|
else
|
|
FILE_SetDosError();
|
|
}
|
|
else
|
|
{
|
|
ret = (DWORD)res;
|
|
if (highword) *highword = (res >> 32);
|
|
if (ret == INVALID_SET_FILE_POINTER) SetLastError( 0 );
|
|
}
|
|
wine_server_release_fd( hFile, fd );
|
|
}
|
|
else SetLastError( RtlNtStatusToDosError(status) );
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
* SetHandleCount (KERNEL32.@)
|
|
*/
|
|
UINT WINAPI SetHandleCount( UINT count )
|
|
{
|
|
return min( 256, count );
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* SetEndOfFile (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI SetEndOfFile( HANDLE hFile )
|
|
{
|
|
BOOL ret;
|
|
SERVER_START_REQ( truncate_file )
|
|
{
|
|
req->handle = hFile;
|
|
ret = !wine_server_call_err( req );
|
|
}
|
|
SERVER_END_REQ;
|
|
return ret;
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* GetFileType (KERNEL32.@)
|
|
*/
|
|
DWORD WINAPI GetFileType( HANDLE hFile )
|
|
{
|
|
NTSTATUS status;
|
|
int fd;
|
|
DWORD ret = FILE_TYPE_UNKNOWN;
|
|
|
|
if (is_console_handle( hFile ))
|
|
return FILE_TYPE_CHAR;
|
|
|
|
if (!(status = wine_server_handle_to_fd( hFile, 0, &fd, NULL, NULL )))
|
|
{
|
|
struct stat st;
|
|
|
|
if (fstat( fd, &st ) == -1)
|
|
FILE_SetDosError();
|
|
else if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode))
|
|
ret = FILE_TYPE_PIPE;
|
|
else if (S_ISCHR(st.st_mode))
|
|
ret = FILE_TYPE_CHAR;
|
|
else
|
|
ret = FILE_TYPE_DISK;
|
|
wine_server_release_fd( hFile, fd );
|
|
}
|
|
else SetLastError( RtlNtStatusToDosError(status) );
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/* check if a file name is for an executable file (.exe or .com) */
|
|
inline static BOOL is_executable( const char *name )
|
|
{
|
|
int len = strlen(name);
|
|
|
|
if (len < 4) return FALSE;
|
|
return (!strcasecmp( name + len - 4, ".exe" ) ||
|
|
!strcasecmp( name + len - 4, ".com" ));
|
|
}
|
|
|
|
|
|
/***********************************************************************
|
|
* FILE_AddBootRenameEntry
|
|
*
|
|
* Adds an entry to the registry that is loaded when windows boots and
|
|
* checks if there are some files to be removed or renamed/moved.
|
|
* <fn1> has to be valid and <fn2> may be NULL. If both pointers are
|
|
* non-NULL then the file is moved, otherwise it is deleted. The
|
|
* entry of the registrykey is always appended with two zero
|
|
* terminated strings. If <fn2> is NULL then the second entry is
|
|
* simply a single 0-byte. Otherwise the second filename goes
|
|
* there. The entries are prepended with \??\ before the path and the
|
|
* second filename gets also a '!' as the first character if
|
|
* MOVEFILE_REPLACE_EXISTING is set. After the final string another
|
|
* 0-byte follows to indicate the end of the strings.
|
|
* i.e.:
|
|
* \??\D:\test\file1[0]
|
|
* !\??\D:\test\file1_renamed[0]
|
|
* \??\D:\Test|delete[0]
|
|
* [0] <- file is to be deleted, second string empty
|
|
* \??\D:\test\file2[0]
|
|
* !\??\D:\test\file2_renamed[0]
|
|
* [0] <- indicates end of strings
|
|
*
|
|
* or:
|
|
* \??\D:\test\file1[0]
|
|
* !\??\D:\test\file1_renamed[0]
|
|
* \??\D:\Test|delete[0]
|
|
* [0] <- file is to be deleted, second string empty
|
|
* [0] <- indicates end of strings
|
|
*
|
|
*/
|
|
static BOOL FILE_AddBootRenameEntry( LPCWSTR fn1, LPCWSTR fn2, DWORD flags )
|
|
{
|
|
static const WCHAR PreString[] = {'\\','?','?','\\',0};
|
|
static const WCHAR ValueName[] = {'P','e','n','d','i','n','g',
|
|
'F','i','l','e','R','e','n','a','m','e',
|
|
'O','p','e','r','a','t','i','o','n','s',0};
|
|
static const WCHAR SessionW[] = {'M','a','c','h','i','n','e','\\',
|
|
'S','y','s','t','e','m','\\',
|
|
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
|
|
'C','o','n','t','r','o','l','\\',
|
|
'S','e','s','s','i','o','n',' ','M','a','n','a','g','e','r',0};
|
|
static const int info_size = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data );
|
|
|
|
OBJECT_ATTRIBUTES attr;
|
|
UNICODE_STRING nameW;
|
|
KEY_VALUE_PARTIAL_INFORMATION *info;
|
|
BOOL rc = FALSE;
|
|
HKEY Reboot = 0;
|
|
DWORD len0, len1, len2;
|
|
DWORD DataSize = 0;
|
|
BYTE *Buffer = NULL;
|
|
WCHAR *p;
|
|
|
|
attr.Length = sizeof(attr);
|
|
attr.RootDirectory = 0;
|
|
attr.ObjectName = &nameW;
|
|
attr.Attributes = 0;
|
|
attr.SecurityDescriptor = NULL;
|
|
attr.SecurityQualityOfService = NULL;
|
|
RtlInitUnicodeString( &nameW, SessionW );
|
|
|
|
if (NtCreateKey( &Reboot, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS)
|
|
{
|
|
WARN("Error creating key for reboot managment [%s]\n",
|
|
"SYSTEM\\CurrentControlSet\\Control\\Session Manager");
|
|
return FALSE;
|
|
}
|
|
|
|
len0 = strlenW(PreString);
|
|
len1 = strlenW(fn1) + len0 + 1;
|
|
if (fn2)
|
|
{
|
|
len2 = strlenW(fn2) + len0 + 1;
|
|
if (flags & MOVEFILE_REPLACE_EXISTING) len2++; /* Plus 1 because of the leading '!' */
|
|
}
|
|
else len2 = 1; /* minimum is the 0 characters for the empty second string */
|
|
|
|
/* convert characters to bytes */
|
|
len0 *= sizeof(WCHAR);
|
|
len1 *= sizeof(WCHAR);
|
|
len2 *= sizeof(WCHAR);
|
|
|
|
RtlInitUnicodeString( &nameW, ValueName );
|
|
|
|
/* First we check if the key exists and if so how many bytes it already contains. */
|
|
if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
|
|
NULL, 0, &DataSize ) == STATUS_BUFFER_OVERFLOW)
|
|
{
|
|
if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
|
|
goto Quit;
|
|
if (NtQueryValueKey( Reboot, &nameW, KeyValuePartialInformation,
|
|
Buffer, DataSize, &DataSize )) goto Quit;
|
|
info = (KEY_VALUE_PARTIAL_INFORMATION *)Buffer;
|
|
if (info->Type != REG_MULTI_SZ) goto Quit;
|
|
if (DataSize > sizeof(info)) DataSize -= sizeof(WCHAR); /* remove terminating null (will be added back later) */
|
|
}
|
|
else
|
|
{
|
|
DataSize = info_size;
|
|
if (!(Buffer = HeapAlloc( GetProcessHeap(), 0, DataSize + len1 + len2 + sizeof(WCHAR) )))
|
|
goto Quit;
|
|
}
|
|
|
|
p = (WCHAR *)(Buffer + DataSize);
|
|
strcpyW( p, PreString );
|
|
strcatW( p, fn1 );
|
|
DataSize += len1;
|
|
if (fn2)
|
|
{
|
|
p = (WCHAR *)(Buffer + DataSize);
|
|
if (flags & MOVEFILE_REPLACE_EXISTING)
|
|
*p++ = '!';
|
|
strcpyW( p, PreString );
|
|
strcatW( p, fn2 );
|
|
DataSize += len2;
|
|
}
|
|
else
|
|
{
|
|
p = (WCHAR *)(Buffer + DataSize);
|
|
*p = 0;
|
|
DataSize += sizeof(WCHAR);
|
|
}
|
|
|
|
/* add final null */
|
|
p = (WCHAR *)(Buffer + DataSize);
|
|
*p = 0;
|
|
DataSize += sizeof(WCHAR);
|
|
|
|
rc = !NtSetValueKey(Reboot, &nameW, 0, REG_MULTI_SZ, Buffer + info_size, DataSize - info_size);
|
|
|
|
Quit:
|
|
if (Reboot) NtClose(Reboot);
|
|
if (Buffer) HeapFree( GetProcessHeap(), 0, Buffer );
|
|
return(rc);
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* MoveFileExW (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI MoveFileExW( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
|
|
{
|
|
DOS_FULL_NAME full_name1, full_name2;
|
|
HANDLE hFile;
|
|
DWORD attr = INVALID_FILE_ATTRIBUTES;
|
|
|
|
TRACE("(%s,%s,%04lx)\n", debugstr_w(fn1), debugstr_w(fn2), flag);
|
|
|
|
/* FIXME: <Gerhard W. Gruber>sparhawk@gmx.at
|
|
In case of W9x and lesser this function should return 120 (ERROR_CALL_NOT_IMPLEMENTED)
|
|
to be really compatible. Most programs won't have any problems though. In case
|
|
you encounter one, this is what you should return here. I don't know what's up
|
|
with NT 3.5. Is this function available there or not?
|
|
Does anybody really care about 3.5? :)
|
|
*/
|
|
|
|
/* Filename1 has to be always set to a valid path. Filename2 may be NULL
|
|
if the source file has to be deleted.
|
|
*/
|
|
if (!fn1) {
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
/* This function has to be run through in order to process the name properly.
|
|
If the BOOTDELAY flag is set, the file doesn't need to exist though. At least
|
|
that is the behaviour on NT 4.0. The operation accepts the filenames as
|
|
they are given but it can't reply with a reasonable returncode. Success
|
|
means in that case success for entering the values into the registry.
|
|
*/
|
|
if(!DOSFS_GetFullName( fn1, TRUE, &full_name1 ))
|
|
{
|
|
if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
|
|
return FALSE;
|
|
}
|
|
|
|
if (fn2) /* !fn2 means delete fn1 */
|
|
{
|
|
if (DOSFS_GetFullName( fn2, TRUE, &full_name2 ))
|
|
{
|
|
if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
|
|
{
|
|
/* target exists, check if we may overwrite */
|
|
if (!(flag & MOVEFILE_REPLACE_EXISTING))
|
|
{
|
|
SetLastError( ERROR_ALREADY_EXISTS );
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 ))
|
|
{
|
|
if(!(flag & MOVEFILE_DELAY_UNTIL_REBOOT))
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/* Source name and target path are valid */
|
|
|
|
if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
|
|
{
|
|
return FILE_AddBootRenameEntry( fn1, fn2, flag );
|
|
}
|
|
|
|
attr = GetFileAttributesW( fn1 );
|
|
if ( attr == INVALID_FILE_ATTRIBUTES ) return FALSE;
|
|
|
|
/* check if we are allowed to rename the source */
|
|
hFile = FILE_CreateFile( full_name1.long_name, 0, 0,
|
|
NULL, OPEN_EXISTING, 0, 0 );
|
|
if (!hFile)
|
|
{
|
|
if (GetLastError() != ERROR_ACCESS_DENIED) return FALSE;
|
|
if ( !(attr & FILE_ATTRIBUTE_DIRECTORY) ) return FALSE;
|
|
/* if it's a directory we can continue */
|
|
}
|
|
else CloseHandle(hFile);
|
|
|
|
/* check, if we are allowed to delete the destination,
|
|
** (but the file not being there is fine) */
|
|
hFile = FILE_CreateFile( full_name2.long_name, GENERIC_READ|GENERIC_WRITE, 0,
|
|
NULL, OPEN_EXISTING, 0, 0 );
|
|
if(!hFile && GetLastError() != ERROR_FILE_NOT_FOUND) return FALSE;
|
|
CloseHandle(hFile);
|
|
|
|
if (full_name1.drive != full_name2.drive)
|
|
{
|
|
if (!(flag & MOVEFILE_COPY_ALLOWED))
|
|
{
|
|
SetLastError( ERROR_NOT_SAME_DEVICE );
|
|
return FALSE;
|
|
}
|
|
else if ( attr & FILE_ATTRIBUTE_DIRECTORY )
|
|
{
|
|
/* Strange, but that's what Windows returns */
|
|
SetLastError ( ERROR_ACCESS_DENIED );
|
|
return FALSE;
|
|
}
|
|
}
|
|
if (rename( full_name1.long_name, full_name2.long_name ) == -1)
|
|
/* Try copy/delete unless it's a directory. */
|
|
/* FIXME: This does not handle the (unlikely) case that the two locations
|
|
are on the same Wine drive, but on different Unix file systems. */
|
|
{
|
|
if ( attr & FILE_ATTRIBUTE_DIRECTORY )
|
|
{
|
|
FILE_SetDosError();
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if ( ! CopyFileW( fn1, fn2, !(flag & MOVEFILE_REPLACE_EXISTING) ))
|
|
return FALSE;
|
|
if ( ! DeleteFileW ( fn1 ) )
|
|
return FALSE;
|
|
}
|
|
}
|
|
if (is_executable( full_name1.long_name ) != is_executable( full_name2.long_name ))
|
|
{
|
|
struct stat fstat;
|
|
if (stat( full_name2.long_name, &fstat ) != -1)
|
|
{
|
|
if (is_executable( full_name2.long_name ))
|
|
/* set executable bit where read bit is set */
|
|
fstat.st_mode |= (fstat.st_mode & 0444) >> 2;
|
|
else
|
|
fstat.st_mode &= ~0111;
|
|
chmod( full_name2.long_name, fstat.st_mode );
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
else /* fn2 == NULL means delete source */
|
|
{
|
|
if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
|
|
{
|
|
if (flag & MOVEFILE_COPY_ALLOWED) {
|
|
WARN("Illegal flag\n");
|
|
SetLastError( ERROR_GEN_FAILURE );
|
|
return FALSE;
|
|
}
|
|
|
|
return FILE_AddBootRenameEntry( fn1, NULL, flag );
|
|
}
|
|
|
|
if (unlink( full_name1.long_name ) == -1)
|
|
{
|
|
FILE_SetDosError();
|
|
return FALSE;
|
|
}
|
|
return TRUE; /* successfully deleted */
|
|
}
|
|
}
|
|
|
|
/**************************************************************************
|
|
* MoveFileExA (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI MoveFileExA( LPCSTR fn1, LPCSTR fn2, DWORD flag )
|
|
{
|
|
UNICODE_STRING fn1W, fn2W;
|
|
BOOL ret;
|
|
|
|
if (!fn1)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
RtlCreateUnicodeStringFromAsciiz(&fn1W, fn1);
|
|
if (fn2) RtlCreateUnicodeStringFromAsciiz(&fn2W, fn2);
|
|
else fn2W.Buffer = NULL;
|
|
|
|
ret = MoveFileExW( fn1W.Buffer, fn2W.Buffer, flag );
|
|
|
|
RtlFreeUnicodeString(&fn1W);
|
|
RtlFreeUnicodeString(&fn2W);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* MoveFileW (KERNEL32.@)
|
|
*
|
|
* Move file or directory
|
|
*/
|
|
BOOL WINAPI MoveFileW( LPCWSTR fn1, LPCWSTR fn2 )
|
|
{
|
|
return MoveFileExW( fn1, fn2, MOVEFILE_COPY_ALLOWED );
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* MoveFileA (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI MoveFileA( LPCSTR fn1, LPCSTR fn2 )
|
|
{
|
|
return MoveFileExA( fn1, fn2, MOVEFILE_COPY_ALLOWED );
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* CopyFileW (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists )
|
|
{
|
|
HANDLE h1, h2;
|
|
BY_HANDLE_FILE_INFORMATION info;
|
|
DWORD count;
|
|
BOOL ret = FALSE;
|
|
char buffer[2048];
|
|
|
|
if (!source || !dest)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
TRACE("%s -> %s\n", debugstr_w(source), debugstr_w(dest));
|
|
|
|
if ((h1 = CreateFileW(source, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
|
|
{
|
|
WARN("Unable to open source %s\n", debugstr_w(source));
|
|
return FALSE;
|
|
}
|
|
|
|
if (!GetFileInformationByHandle( h1, &info ))
|
|
{
|
|
WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source));
|
|
CloseHandle( h1 );
|
|
return FALSE;
|
|
}
|
|
|
|
if ((h2 = CreateFileW( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
|
|
fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
|
|
info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
|
|
{
|
|
WARN("Unable to open dest %s\n", debugstr_w(dest));
|
|
CloseHandle( h1 );
|
|
return FALSE;
|
|
}
|
|
|
|
while (ReadFile( h1, buffer, sizeof(buffer), &count, NULL ) && count)
|
|
{
|
|
char *p = buffer;
|
|
while (count != 0)
|
|
{
|
|
DWORD res;
|
|
if (!WriteFile( h2, p, count, &res, NULL ) || !res) goto done;
|
|
p += res;
|
|
count -= res;
|
|
}
|
|
}
|
|
ret = TRUE;
|
|
done:
|
|
CloseHandle( h1 );
|
|
CloseHandle( h2 );
|
|
return ret;
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* CopyFileA (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists)
|
|
{
|
|
UNICODE_STRING sourceW, destW;
|
|
BOOL ret;
|
|
|
|
if (!source || !dest)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
RtlCreateUnicodeStringFromAsciiz(&sourceW, source);
|
|
RtlCreateUnicodeStringFromAsciiz(&destW, dest);
|
|
|
|
ret = CopyFileW(sourceW.Buffer, destW.Buffer, fail_if_exists);
|
|
|
|
RtlFreeUnicodeString(&sourceW);
|
|
RtlFreeUnicodeString(&destW);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* CopyFileExW (KERNEL32.@)
|
|
*
|
|
* 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.
|
|
*/
|
|
BOOL WINAPI CopyFileExW(LPCWSTR sourceFilename, LPCWSTR destFilename,
|
|
LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
|
|
LPBOOL cancelFlagPointer, DWORD copyFlags)
|
|
{
|
|
/*
|
|
* Interpret the only flag that CopyFile can interpret.
|
|
*/
|
|
return CopyFileW(sourceFilename, destFilename, (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0);
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* CopyFileExA (KERNEL32.@)
|
|
*/
|
|
BOOL WINAPI CopyFileExA(LPCSTR sourceFilename, LPCSTR destFilename,
|
|
LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
|
|
LPBOOL cancelFlagPointer, DWORD copyFlags)
|
|
{
|
|
UNICODE_STRING sourceW, destW;
|
|
BOOL ret;
|
|
|
|
if (!sourceFilename || !destFilename)
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
RtlCreateUnicodeStringFromAsciiz(&sourceW, sourceFilename);
|
|
RtlCreateUnicodeStringFromAsciiz(&destW, destFilename);
|
|
|
|
ret = CopyFileExW(sourceW.Buffer, destW.Buffer, progressRoutine, appData,
|
|
cancelFlagPointer, copyFlags);
|
|
|
|
RtlFreeUnicodeString(&sourceW);
|
|
RtlFreeUnicodeString(&destW);
|
|
return ret;
|
|
}
|