Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-04 08:15:41 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fixed ANSI/OEM <--> Unicode conversions

Browse source 
svn path=/trunk/; revision=1056
This commit is contained in:
Eric Kohl 2000-03-14 23:09:23 +00:00
parent fbfce3bc03
commit 1c5d2b7204
7 changed files with 775 additions and 618 deletions
Download patch file Download diff file Expand all files Collapse all files

160
reactos/lib/kernel32/file/copy.c
View file

@ -1,9 +1,10 @@
/* /* $Id: copy.c,v 1.6 2000/03/14 23:09:23 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
* FILE: lib/kernel32/file/copy.c * FILE: lib/kernel32/file/copy.c
* PURPOSE: Copying files * PURPOSE: Copying files
* PROGRAMMER: Ariadne ( ariadne@xs4all.nl) * PROGRAMMER: Ariadne (ariadne@xs4all.nl)
* UPDATE HISTORY: * UPDATE HISTORY:
* 01/11/98 Created * 01/11/98 Created
* 07/02/99 Moved to seperate file * 07/02/99 Moved to seperate file
@ -13,22 +14,26 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <windows.h> #include <windows.h>
#include <wchar.h>
#include <string.h>
#define NDEBUG #define NDEBUG
#include <kernel32/kernel32.h> #include <kernel32/kernel32.h>
#define LPPROGRESS_ROUTINE void* #define LPPROGRESS_ROUTINE void*
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
WINBOOL STDCALL CopyFileExW(LPCWSTR lpExistingFileName, WINBOOL
LPCWSTR lpNewFileName, STDCALL
LPPROGRESS_ROUTINE lpProgressRoutine, CopyFileExW (
LPVOID lpData, LPCWSTR lpExistingFileName,
WINBOOL * pbCancel, LPCWSTR lpNewFileName,
DWORD dwCopyFlags) LPPROGRESS_ROUTINE lpProgressRoutine,
LPVOID lpData,
WINBOOL *pbCancel,
DWORD dwCopyFlags
)
{ {
NTSTATUS errCode = 0; NTSTATUS errCode = 0;
HANDLE FileHandleSource, FileHandleDest; HANDLE FileHandleSource, FileHandleDest;
@ -79,7 +84,7 @@ WINBOOL STDCALL CopyFileExW(LPCWSTR lpExistingFileName,
GENERIC_WRITE, GENERIC_WRITE,
FILE_SHARE_WRITE, FILE_SHARE_WRITE,
NULL, NULL,
dwCopyFlags ? CREATE_NEW : CREATE_ALWAYS , dwCopyFlags ? CREATE_NEW : CREATE_ALWAYS,
FileBasic.FileAttributes|FILE_FLAG_NO_BUFFERING, FileBasic.FileAttributes|FILE_FLAG_NO_BUFFERING,
NULL); NULL);
if (FileHandleDest == NULL) if (FileHandleDest == NULL)
@ -180,56 +185,99 @@ WINBOOL STDCALL CopyFileExW(LPCWSTR lpExistingFileName,
return TRUE; return TRUE;
} }
WINBOOL STDCALL CopyFileExA(LPCSTR lpExistingFileName,
LPCSTR lpNewFileName,
LPPROGRESS_ROUTINE lpProgressRoutine,
LPVOID lpData,
WINBOOL* pbCancel,
DWORD dwCopyFlags)
{
WCHAR ExistingFileNameW[MAX_PATH];
WCHAR NewFileNameW[MAX_PATH];
if (!KERNEL32_AnsiToUnicode(ExistingFileNameW, WINBOOL
lpExistingFileName, STDCALL
MAX_PATH)) CopyFileExA (
{ LPCSTR lpExistingFileName,
return(FALSE); LPCSTR lpNewFileName,
} LPPROGRESS_ROUTINE lpProgressRoutine,
if (!KERNEL32_AnsiToUnicode(NewFileNameW, LPVOID lpData,
lpNewFileName, WINBOOL *pbCancel,
MAX_PATH)) DWORD dwCopyFlags
{ )
return(FALSE); {
} UNICODE_STRING ExistingFileNameU;
return(CopyFileExW(ExistingFileNameW, UNICODE_STRING NewFileNameU;
NewFileNameW, ANSI_STRING ExistingFileName;
lpProgressRoutine, ANSI_STRING NewFileName;
lpData, WINBOOL Result;
pbCancel,
dwCopyFlags)); RtlInitAnsiString (&ExistingFileName,
(LPSTR)lpExistingFileName);
RtlInitAnsiString (&NewFileName,
(LPSTR)lpNewFileName);
/* convert ansi (or oem) string to unicode */
if (bIsFileApiAnsi)
{
RtlAnsiStringToUnicodeString (&ExistingFileNameU,
&ExistingFileName,
TRUE);
RtlAnsiStringToUnicodeString (&NewFileNameU,
&NewFileName,
TRUE);
}
else
{
RtlOemStringToUnicodeString (&ExistingFileNameU,
&ExistingFileName,
TRUE);
RtlOemStringToUnicodeString (&NewFileNameU,
&NewFileName,
TRUE);
}
Result = CopyFileExW (ExistingFileNameU.Buffer,
NewFileNameU.Buffer,
lpProgressRoutine,
lpData,
pbCancel,
dwCopyFlags);
RtlFreeHeap (RtlGetProcessHeap (),
0,
ExistingFileNameU.Buffer);
RtlFreeHeap (RtlGetProcessHeap (),
0,
NewFileNameU.Buffer);
return Result;
} }
WINBOOL STDCALL CopyFileA(LPCSTR lpExistingFileName, WINBOOL
LPCSTR lpNewFileName, STDCALL
WINBOOL bFailIfExists) CopyFileA (
LPCSTR lpExistingFileName,
LPCSTR lpNewFileName,
WINBOOL bFailIfExists
)
{ {
return CopyFileExA(lpExistingFileName, return CopyFileExA (lpExistingFileName,
lpNewFileName, lpNewFileName,
NULL, NULL,
NULL, NULL,
FALSE, NULL,
bFailIfExists); bFailIfExists);
} }
WINBOOL STDCALL CopyFileW(LPCWSTR lpExistingFileName,
LPCWSTR lpNewFileName,
WINBOOL bFailIfExists) WINBOOL
STDCALL
CopyFileW (
LPCWSTR lpExistingFileName,
LPCWSTR lpNewFileName,
WINBOOL bFailIfExists
)
{ {
return CopyFileExW(lpExistingFileName, return CopyFileExW (lpExistingFileName,
lpNewFileName, lpNewFileName,
NULL, NULL,
NULL, NULL,
NULL, NULL,
bFailIfExists); bFailIfExists);
} }
/* EOF */

252
reactos/lib/kernel32/file/create.c
View file

@ -1,4 +1,4 @@
/* $Id: create.c,v 1.18 2000/01/21 23:27:47 phreak Exp $ /* $Id: create.c,v 1.19 2000/03/14 23:09:23 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -14,9 +14,8 @@
/* INCLUDES *****************************************************************/ /* INCLUDES *****************************************************************/
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <ntdll/rtl.h>
#include <windows.h> #include <windows.h>
#include <wchar.h>
#include <string.h>
#define NDEBUG #define NDEBUG
#include <kernel32/kernel32.h> #include <kernel32/kernel32.h>
@ -24,163 +23,140 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
HANDLE STDCALL CreateFileA(LPCSTR lpFileName, HANDLE
DWORD dwDesiredAccess, STDCALL
DWORD dwShareMode, CreateFileA (
LPSECURITY_ATTRIBUTES lpSecurityAttributes, LPCSTR lpFileName,
DWORD dwCreationDisposition, DWORD dwDesiredAccess,
DWORD dwFlagsAndAttributes, DWORD dwShareMode,
HANDLE hTemplateFile) LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile
)
{ {
WCHAR FileNameW[MAX_PATH]; UNICODE_STRING FileNameU;
ULONG i = 0; ANSI_STRING FileName;
HANDLE FileHandle;
DPRINT("CreateFileA(lpFileName %s)\n",lpFileName); DPRINT("CreateFileA(lpFileName %s)\n",lpFileName);
while ((*lpFileName)!=0 && i < MAX_PATH) RtlInitAnsiString (&FileName,
{ (LPSTR)lpFileName);
FileNameW[i] = *lpFileName;
lpFileName++;
i++;
}
FileNameW[i] = 0;
return CreateFileW(FileNameW,dwDesiredAccess, /* convert ansi (or oem) string to unicode */
dwShareMode, if (bIsFileApiAnsi)
lpSecurityAttributes, RtlAnsiStringToUnicodeString (&FileNameU,
dwCreationDisposition, &FileName,
dwFlagsAndAttributes, TRUE);
hTemplateFile); else
RtlOemStringToUnicodeString (&FileNameU,
&FileName,
TRUE);
FileHandle = CreateFileW (FileNameU.Buffer,
dwDesiredAccess,
dwShareMode,
lpSecurityAttributes,
dwCreationDisposition,
dwFlagsAndAttributes,
hTemplateFile);
RtlFreeHeap (RtlGetProcessHeap (),
0,
FileNameU.Buffer);
return FileHandle;
} }
HANDLE STDCALL CreateFileW(LPCWSTR lpFileName, HANDLE
DWORD dwDesiredAccess, STDCALL
DWORD dwShareMode, CreateFileW (
LPSECURITY_ATTRIBUTES lpSecurityAttributes, LPCWSTR lpFileName,
DWORD dwCreationDisposition, DWORD dwDesiredAccess,
DWORD dwFlagsAndAttributes, DWORD dwShareMode,
HANDLE hTemplateFile) LPSECURITY_ATTRIBUTES lpSecurityAttributes,
DWORD dwCreationDisposition,
DWORD dwFlagsAndAttributes,
HANDLE hTemplateFile
)
{ {
HANDLE FileHandle; OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS Status; IO_STATUS_BLOCK IoStatusBlock;
OBJECT_ATTRIBUTES ObjectAttributes; UNICODE_STRING NtPathU;
IO_STATUS_BLOCK IoStatusBlock; HANDLE FileHandle;
UNICODE_STRING FileNameString; NTSTATUS Status;
ULONG Flags = 0; ULONG Flags = 0;
WCHAR PathNameW[MAX_PATH];
WCHAR FileNameW[MAX_PATH];
UINT Len = 0;
switch (dwCreationDisposition) switch (dwCreationDisposition)
{ {
case CREATE_NEW: case CREATE_NEW:
dwCreationDisposition = FILE_CREATE; dwCreationDisposition = FILE_CREATE;
break; break;
case CREATE_ALWAYS: case CREATE_ALWAYS:
dwCreationDisposition = FILE_OVERWRITE_IF; dwCreationDisposition = FILE_OVERWRITE_IF;
break; break;
case OPEN_EXISTING: case OPEN_EXISTING:
dwCreationDisposition = FILE_OPEN; dwCreationDisposition = FILE_OPEN;
break; break;
case OPEN_ALWAYS: case OPEN_ALWAYS:
dwCreationDisposition = OPEN_ALWAYS; dwCreationDisposition = OPEN_ALWAYS;
break; break;
case TRUNCATE_EXISTING: case TRUNCATE_EXISTING:
dwCreationDisposition = FILE_OVERWRITE; dwCreationDisposition = FILE_OVERWRITE;
}
DPRINT("CreateFileW(lpFileName %S)\n",lpFileName);
if (dwDesiredAccess & GENERIC_READ)
dwDesiredAccess |= FILE_GENERIC_READ;
if (dwDesiredAccess & GENERIC_WRITE)
dwDesiredAccess |= FILE_GENERIC_WRITE;
if (!(dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))
{
Flags |= FILE_SYNCHRONOUS_IO_ALERT;
}
if (lpFileName[1] == (WCHAR)':')
{
wcscpy(PathNameW, lpFileName);
}
else if (wcslen(lpFileName) > 4 &&
lpFileName[0] == (WCHAR)'\\' &&
lpFileName[1] == (WCHAR)'\\' &&
lpFileName[2] == (WCHAR)'.' &&
lpFileName[3] == (WCHAR)'\\')
{
wcscpy(PathNameW, lpFileName+4);
}
else if (lpFileName[0] == (WCHAR)'\\')
{
GetCurrentDirectoryW(MAX_PATH,PathNameW);
PathNameW[3] = 0;
wcscat(PathNameW, lpFileName);
}
else
{
Len = GetCurrentDirectoryW(MAX_PATH,PathNameW);
if ( Len == 0 )
return NULL;
if ( PathNameW[Len-1] != L'\\' ) {
PathNameW[Len] = L'\\';
PathNameW[Len+1] = 0;
} }
wcscat(PathNameW,lpFileName);
}
FileNameW[0] = '\\'; DPRINT("CreateFileW(lpFileName %S)\n",lpFileName);
FileNameW[1] = '?';
FileNameW[2] = '?';
FileNameW[3] = '\\';
FileNameW[4] = 0;
wcscat(FileNameW,PathNameW);
FileNameString.Length = wcslen( FileNameW)*sizeof(WCHAR); if (dwDesiredAccess & GENERIC_READ)
dwDesiredAccess |= FILE_GENERIC_READ;
if ( FileNameString.Length == 0 ) if (dwDesiredAccess & GENERIC_WRITE)
return NULL; dwDesiredAccess |= FILE_GENERIC_WRITE;
if ( FileNameString.Length > MAX_PATH*sizeof(WCHAR) ) if (!(dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))
return NULL; {
Flags |= FILE_SYNCHRONOUS_IO_ALERT;
}
FileNameString.Buffer = (WCHAR *)FileNameW; if (!RtlDosPathNameToNtPathName_U ((LPWSTR)lpFileName,
FileNameString.MaximumLength = FileNameString.Length + sizeof(WCHAR); &NtPathU,
NULL,
NULL))
return FALSE;
ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES); DPRINT("NtPathU \'%S\'\n", NtPathU.Buffer);
ObjectAttributes.RootDirectory = NULL;
ObjectAttributes.ObjectName = &FileNameString;
ObjectAttributes.Attributes = OBJ_CASE_INSENSITIVE;
ObjectAttributes.SecurityDescriptor = NULL;
ObjectAttributes.SecurityQualityOfService = NULL;
DPRINT("File Name %S\n",FileNameW); ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
ObjectAttributes.RootDirectory = NULL;
ObjectAttributes.ObjectName = &NtPathU;
ObjectAttributes.Attributes = OBJ_CASE_INSENSITIVE;
ObjectAttributes.SecurityDescriptor = NULL;
ObjectAttributes.SecurityQualityOfService = NULL;
Status = ZwCreateFile(&FileHandle, Status = NtCreateFile (&FileHandle,
dwDesiredAccess, dwDesiredAccess,
&ObjectAttributes, &ObjectAttributes,
&IoStatusBlock, &IoStatusBlock,
NULL, NULL,
dwFlagsAndAttributes, dwFlagsAndAttributes,
dwShareMode, dwShareMode,
dwCreationDisposition, dwCreationDisposition,
Flags, Flags,
NULL, NULL,
0); 0);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError (RtlNtStatusToDosError (Status));
return INVALID_HANDLE_VALUE; return INVALID_HANDLE_VALUE;
} }
return(FileHandle);
return FileHandle;
} }
/* EOF */ /* EOF */

276
reactos/lib/kernel32/file/curdir.c
View file

@ -1,4 +1,4 @@
/* $Id: curdir.c,v 1.20 2000/02/18 00:49:39 ekohl Exp $ /* $Id: curdir.c,v 1.21 2000/03/14 23:09:23 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -21,8 +21,9 @@
/* GLOBAL VARIABLES **********************************************************/ /* GLOBAL VARIABLES **********************************************************/
static WCHAR SystemDirectoryW[MAX_PATH]; /* FIXME initialize them on startup !! */
static WCHAR WindowsDirectoryW[MAX_PATH]; UNICODE_STRING SystemDirectory;
UNICODE_STRING WindowsDirectory;
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
@ -150,107 +151,206 @@ SetCurrentDirectoryW (
} }
DWORD STDCALL GetTempPathA (DWORD nBufferLength, LPSTR lpBuffer) DWORD
STDCALL
GetTempPathA (
DWORD nBufferLength,
LPSTR lpBuffer
)
{ {
WCHAR BufferW[MAX_PATH]; UNICODE_STRING UnicodeString;
DWORD retCode; ANSI_STRING AnsiString;
UINT i;
retCode = GetTempPathW(nBufferLength,BufferW); AnsiString.Length = 0;
i = 0; AnsiString.MaximumLength = nBufferLength;
while ((BufferW[i])!=0 && i < MAX_PATH) AnsiString.Buffer = lpBuffer;
/* initialize allocate unicode string */
UnicodeString.Length = 0;
UnicodeString.MaximumLength = nBufferLength * sizeof(WCHAR);
UnicodeString.Buffer = RtlAllocateHeap (RtlGetProcessHeap(),
0,
UnicodeString.MaximumLength);
UnicodeString.Length = GetTempPathW (nBufferLength,
UnicodeString.Buffer) * sizeof(WCHAR);
/* convert unicode string to ansi (or oem) */
if (bIsFileApiAnsi)
RtlUnicodeStringToAnsiString (&AnsiString,
&UnicodeString,
FALSE);
else
RtlUnicodeStringToOemString (&AnsiString,
&UnicodeString,
FALSE);
/* free unicode string buffer */
RtlFreeHeap (RtlGetProcessHeap (),
0,
UnicodeString.Buffer);
return AnsiString.Length;
}
DWORD
STDCALL
GetTempPathW (
DWORD nBufferLength,
LPWSTR lpBuffer
)
{
UNICODE_STRING Name;
UNICODE_STRING Value;
NTSTATUS Status;
Value.Length = 0;
Value.MaximumLength = nBufferLength * sizeof(WCHAR);
Value.Buffer = lpBuffer;
RtlInitUnicodeString (&Name,
L"TMP");
Status = RtlQueryEnvironmentVariable_U (NULL,
&Name,
&Value);
if (!NT_SUCCESS(Status))
{ {
lpBuffer[i] = (unsigned char)BufferW[i]; RtlInitUnicodeString (&Name,
i++; L"TEMP");
Status = RtlQueryEnvironmentVariable_U (NULL,
&Name,
&Value);
if (!NT_SUCCESS(Status))
{
Value.Length = RtlGetCurrentDirectory_U (Value.MaximumLength,
Value.Buffer);
}
} }
lpBuffer[i] = 0;
return retCode; return Value.Length / sizeof(WCHAR);
} }
DWORD STDCALL GetTempPathW(DWORD nBufferLength, LPWSTR lpBuffer)
{
WCHAR EnvironmentBufferW[MAX_PATH];
UINT i;
EnvironmentBufferW[0] = 0;
i = GetEnvironmentVariableW(L"TMP",EnvironmentBufferW,MAX_PATH);
if ( i==0 )
i = GetEnvironmentVariableW(L"TEMP",EnvironmentBufferW,MAX_PATH);
if ( i==0 )
i = GetCurrentDirectoryW(MAX_PATH,EnvironmentBufferW);
return i;
}
UINT STDCALL GetSystemDirectoryA(LPSTR lpBuffer, UINT uSize)
{
UINT uPathSize,i;
if ( lpBuffer == NULL )
return 0;
uPathSize = lstrlenW(SystemDirectoryW);
if ( uSize > uPathSize ) {
i = 0;
while ((SystemDirectoryW[i])!=0 && i < uSize)
{
lpBuffer[i] = (unsigned char)SystemDirectoryW[i];
i++;
}
lpBuffer[i] = 0;
}
return uPathSize;
}
UINT STDCALL GetWindowsDirectoryA(LPSTR lpBuffer, UINT uSize)
{
UINT uPathSize,i;
if ( lpBuffer == NULL )
return 0;
uPathSize = lstrlenW(WindowsDirectoryW);
if ( uSize > uPathSize ) {
i = 0;
while ((WindowsDirectoryW[i])!=0 && i < uSize)
{
lpBuffer[i] = (unsigned char)WindowsDirectoryW[i];
i++;
}
lpBuffer[i] = 0;
}
return uPathSize;
}
UINT UINT
STDCALL STDCALL
GetSystemDirectoryW( GetSystemDirectoryA (
LPWSTR lpBuffer, LPSTR lpBuffer,
UINT uSize UINT uSize
) )
{ {
UINT uPathSize; ANSI_STRING String;
if ( lpBuffer == NULL ) ULONG Length;
return 0;
uPathSize = lstrlenW(SystemDirectoryW);
if ( uSize > uPathSize )
lstrcpynW(lpBuffer,SystemDirectoryW,uPathSize);
return uPathSize; if (lpBuffer == NULL)
return 0;
Length = RtlUnicodeStringToAnsiSize (&SystemDirectory);
if (uSize > Length)
{
String.Length = 0;
String.MaximumLength = uSize;
String.Buffer = lpBuffer;
/* convert unicode string to ansi (or oem) */
if (bIsFileApiAnsi)
RtlUnicodeStringToAnsiString (&String,
&SystemDirectory,
FALSE);
else
RtlUnicodeStringToOemString (&String,
&SystemDirectory,
FALSE);
}
return Length;
} }
UINT UINT
STDCALL STDCALL
GetWindowsDirectoryW( GetSystemDirectoryW (
LPWSTR lpBuffer, LPWSTR lpBuffer,
UINT uSize UINT uSize
) )
{ {
UINT uPathSize; ULONG Length;
if ( lpBuffer == NULL )
return 0;
uPathSize = lstrlenW(WindowsDirectoryW);
if ( uSize > uPathSize );
lstrcpynW(lpBuffer,WindowsDirectoryW,uPathSize);
return uPathSize; if (lpBuffer == NULL)
return 0;
Length = SystemDirectory.Length / sizeof (WCHAR);
if (uSize > Length)
{
memmove (lpBuffer,
SystemDirectory.Buffer,
Length);
lpBuffer[Length] = 0;
}
return Length;
}
UINT
STDCALL
GetWindowsDirectoryA (
LPSTR lpBuffer,
UINT uSize
)
{
ANSI_STRING String;
ULONG Length;
if (lpBuffer == NULL)
return 0;
Length = RtlUnicodeStringToAnsiSize (&SystemDirectory);
if (uSize > Length)
{
String.Length = 0;
String.MaximumLength = uSize;
String.Buffer = lpBuffer;
/* convert unicode string to ansi (or oem) */
if (bIsFileApiAnsi)
RtlUnicodeStringToAnsiString (&String,
&WindowsDirectory,
FALSE);
else
RtlUnicodeStringToOemString (&String,
&WindowsDirectory,
FALSE);
}
return Length;
}
UINT
STDCALL
GetWindowsDirectoryW (
LPWSTR lpBuffer,
UINT uSize
)
{
ULONG Length;
if (lpBuffer == NULL)
return 0;
Length = SystemDirectory.Length / sizeof (WCHAR);
if (uSize > Length)
{
memmove (lpBuffer,
SystemDirectory.Buffer,
Length);
lpBuffer[Length] = 0;
}
return Length;
} }
/* EOF */ /* EOF */

221
reactos/lib/kernel32/file/delete.c
View file

@ -1,10 +1,10 @@
/* $Id: delete.c,v 1.5 2000/01/11 17:30:16 ekohl Exp $ /* $Id: delete.c,v 1.6 2000/03/14 23:09:23 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
* FILE: lib/kernel32/file/delete.c * FILE: lib/kernel32/file/delete.c
* PURPOSE: Deleting files * PURPOSE: Deleting files
* PROGRAMMER: Ariadne ( ariadne@xs4all.nl) * PROGRAMMER: Ariadne (ariadne@xs4all.nl)
* UPDATE HISTORY: * UPDATE HISTORY:
* Created 01/11/98 * Created 01/11/98
*/ */
@ -12,9 +12,8 @@
/* INCLUDES ****************************************************************/ /* INCLUDES ****************************************************************/
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <ntdll/rtl.h>
#include <windows.h> #include <windows.h>
#include <wchar.h>
#include <string.h>
#define NDEBUG #define NDEBUG
#include <kernel32/kernel32.h> #include <kernel32/kernel32.h>
@ -22,138 +21,112 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
WINBOOL STDCALL DeleteFileA(LPCSTR lpFileName) WINBOOL
STDCALL
DeleteFileA (
LPCSTR lpFileName
)
{ {
ULONG i; UNICODE_STRING FileNameU;
WCHAR FileNameW[MAX_PATH]; ANSI_STRING FileName;
WINBOOL Result;
i = 0; RtlInitAnsiString (&FileName,
while ((*lpFileName)!=0 && i < MAX_PATH) (LPSTR)lpFileName);
{
FileNameW[i] = *lpFileName; /* convert ansi (or oem) string to unicode */
lpFileName++; if (bIsFileApiAnsi)
i++; RtlAnsiStringToUnicodeString (&FileNameU,
} &FileName,
FileNameW[i] = 0; TRUE);
return DeleteFileW(FileNameW); else
RtlOemStringToUnicodeString (&FileNameU,
&FileName,
TRUE);
Result = DeleteFileW (FileNameU.Buffer);
RtlFreeHeap (RtlGetProcessHeap (),
0,
FileNameU.Buffer);
return Result;
} }
WINBOOL STDCALL DeleteFileW(LPCWSTR lpFileName)
WINBOOL
STDCALL
DeleteFileW (
LPCWSTR lpFileName
)
{ {
OBJECT_ATTRIBUTES ObjectAttributes; FILE_DISPOSITION_INFORMATION FileDispInfo;
UNICODE_STRING FileNameString; OBJECT_ATTRIBUTES ObjectAttributes;
NTSTATUS errCode; IO_STATUS_BLOCK IoStatusBlock;
WCHAR PathNameW[MAX_PATH]; UNICODE_STRING NtPathU;
WCHAR FileNameW[MAX_PATH]; HANDLE FileHandle;
HANDLE FileHandle; NTSTATUS Status;
FILE_DISPOSITION_INFORMATION FileDispInfo;
IO_STATUS_BLOCK IoStatusBlock;
UINT Len;
DPRINT("DeleteFileW (lpFileName %S)\n",lpFileName); DPRINT("DeleteFileW (lpFileName %S)\n",lpFileName);
if (lpFileName[1] == (WCHAR)':') if (!RtlDosPathNameToNtPathName_U ((LPWSTR)lpFileName,
{ &NtPathU,
wcscpy(PathNameW, lpFileName); NULL,
} NULL))
else if (wcslen(lpFileName) > 4 && return FALSE;
lpFileName[0] == (WCHAR)'\\' &&
lpFileName[1] == (WCHAR)'\\' && DPRINT("NtPathU \'%wZ\'\n", &NtPathU);
lpFileName[2] == (WCHAR)'.' &&
lpFileName[3] == (WCHAR)'\\') ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
{ ObjectAttributes.RootDirectory = NULL;
wcscpy(PathNameW, lpFileName); ObjectAttributes.ObjectName = &NtPathU;
} ObjectAttributes.Attributes = OBJ_CASE_INSENSITIVE| OBJ_INHERIT;
else if (lpFileName[0] == (WCHAR)'\\') ObjectAttributes.SecurityDescriptor = NULL;
{ ObjectAttributes.SecurityQualityOfService = NULL;
GetCurrentDirectoryW(MAX_PATH,PathNameW);
PathNameW[3] = 0; Status = NtCreateFile (&FileHandle,
wcscat(PathNameW, lpFileName); FILE_WRITE_ATTRIBUTES,
} &ObjectAttributes,
else &IoStatusBlock,
{ NULL,
Len = GetCurrentDirectoryW(MAX_PATH,PathNameW); FILE_ATTRIBUTE_NORMAL,
if ( Len == 0 ) 0,
return FALSE; FILE_OPEN,
if ( PathNameW[Len-1] != L'\\' ) { FILE_DIRECTORY_FILE,
PathNameW[Len] = L'\\'; NULL,
PathNameW[Len+1] = 0; 0);
if (!NT_SUCCESS(Status))
{
CHECKPOINT;
SetLastError (RtlNtStatusToDosError (Status));
return FALSE;
} }
wcscat(PathNameW,lpFileName);
}
FileNameW[0] = '\\'; FileDispInfo.DeleteFile = TRUE;
FileNameW[1] = '?';
FileNameW[2] = '?';
FileNameW[3] = '\\';
FileNameW[4] = 0;
wcscat(FileNameW,PathNameW);
FileNameString.Length = wcslen( FileNameW)*sizeof(WCHAR); Status = NtSetInformationFile (FileHandle,
&IoStatusBlock,
&FileDispInfo,
sizeof(FILE_DISPOSITION_INFORMATION),
FileDispositionInformation);
if (!NT_SUCCESS(Status))
{
CHECKPOINT;
NtClose (FileHandle);
SetLastError (RtlNtStatusToDosError (Status));
return FALSE;
}
if ( FileNameString.Length == 0 ) Status = NtClose (FileHandle);
return FALSE; if (!NT_SUCCESS (Status))
{
CHECKPOINT;
SetLastError (RtlNtStatusToDosError (Status));
return FALSE;
}
if ( FileNameString.Length > MAX_PATH*sizeof(WCHAR) ) return TRUE;
return FALSE;
FileNameString.Buffer = (WCHAR *)FileNameW;
FileNameString.MaximumLength = FileNameString.Length + sizeof(WCHAR);
ObjectAttributes.Length = sizeof(OBJECT_ATTRIBUTES);
ObjectAttributes.RootDirectory = NULL;
ObjectAttributes.ObjectName = &FileNameString;
ObjectAttributes.Attributes = OBJ_CASE_INSENSITIVE| OBJ_INHERIT;
ObjectAttributes.SecurityDescriptor = NULL;
ObjectAttributes.SecurityQualityOfService = NULL;
DPRINT("FileName %S\n",FileNameW);
errCode = ZwCreateFile(&FileHandle,
FILE_WRITE_ATTRIBUTES,
&ObjectAttributes,
&IoStatusBlock,
NULL,
FILE_ATTRIBUTE_NORMAL,
0,
FILE_OPEN,
FILE_DIRECTORY_FILE,
NULL,
0);
if (!NT_SUCCESS(errCode))
{
CHECKPOINT;
SetLastError(RtlNtStatusToDosError(errCode));
return FALSE;
}
FileDispInfo.DeleteFile = TRUE;
errCode = NtSetInformationFile(FileHandle,
&IoStatusBlock,
&FileDispInfo,
sizeof(FILE_DISPOSITION_INFORMATION),
FileDispositionInformation);
if (!NT_SUCCESS(errCode))
{
CHECKPOINT;
NtClose(FileHandle);
SetLastError(RtlNtStatusToDosError(errCode));
return FALSE;
}
errCode = NtClose(FileHandle);
if (!NT_SUCCESS(errCode))
{
CHECKPOINT;
SetLastError(RtlNtStatusToDosError(errCode));
return FALSE;
}
return TRUE;
} }
/* EOF */ /* EOF */

151
reactos/lib/kernel32/file/deviceio.c
View file

@ -1,4 +1,5 @@
/* /* $Id: deviceio.c,v 1.6 2000/03/14 23:09:23 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
* FILE: lib/kernel32/file/deviceio.c * FILE: lib/kernel32/file/deviceio.c
@ -35,94 +36,134 @@ DeviceIoControl(
WINBOOL bFsIoControlCode = FALSE; WINBOOL bFsIoControlCode = FALSE;
if ( lpBytesReturned == NULL ) { if (lpBytesReturned == NULL)
SetLastError(RtlNtStatusToDosError(STATUS_INVALID_PARAMETER)); {
return FALSE;; SetLastError (RtlNtStatusToDosError (STATUS_INVALID_PARAMETER));
return FALSE;
} }
if( ( ( dwIoControlCode >> 16 ) & FILE_DEVICE_FILE_SYSTEM ) == FILE_DEVICE_FILE_SYSTEM ) if (((dwIoControlCode >> 16) & FILE_DEVICE_FILE_SYSTEM) == FILE_DEVICE_FILE_SYSTEM)
bFsIoControlCode = TRUE; bFsIoControlCode = TRUE;
else else
bFsIoControlCode = FALSE; bFsIoControlCode = FALSE;
if(lpOverlapped != NULL) {
if(lpOverlapped != NULL)
{
hEvent = lpOverlapped->hEvent; hEvent = lpOverlapped->hEvent;
lpOverlapped->Internal = STATUS_PENDING; lpOverlapped->Internal = STATUS_PENDING;
IoStatusBlock = (PIO_STATUS_BLOCK)lpOverlapped; IoStatusBlock = (PIO_STATUS_BLOCK)lpOverlapped;
} }
else { else
{
IoStatusBlock = &IIosb; IoStatusBlock = &IIosb;
} }
if(bFsIoControlCode == TRUE) { if (bFsIoControlCode == TRUE)
errCode = NtFsControlFile(hDevice,hEvent,NULL,NULL,IoStatusBlock,dwIoControlCode,lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize ); {
} else { errCode = NtFsControlFile (hDevice,
errCode = NtDeviceIoControlFile(hDevice,hEvent,NULL,NULL,IoStatusBlock,dwIoControlCode, lpInBuffer, nInBufferSize, lpOutBuffer, nOutBufferSize); hEvent,
} NULL,
NULL,
IoStatusBlock,
dwIoControlCode,
lpInBuffer,
nInBufferSize,
lpOutBuffer,
nOutBufferSize);
}
else
{
errCode = NtDeviceIoControlFile (hDevice,
hEvent,
NULL,
NULL,
IoStatusBlock,
dwIoControlCode,
lpInBuffer,
nInBufferSize,
lpOutBuffer,
nOutBufferSize);
}
if(errCode == STATUS_PENDING ) { if (errCode == STATUS_PENDING)
{
if(NtWaitForSingleObject(hDevice,FALSE,NULL) < 0) { if (NtWaitForSingleObject(hDevice,FALSE,NULL) < 0)
{
*lpBytesReturned = IoStatusBlock->Information; *lpBytesReturned = IoStatusBlock->Information;
SetLastError(RtlNtStatusToDosError(errCode)); SetLastError (RtlNtStatusToDosError (errCode));
return FALSE;; return FALSE;
} }
}
} else if ( !NT_SUCCESS(errCode) ) { else if (!NT_SUCCESS(errCode))
SetLastError(RtlNtStatusToDosError(errCode)); {
SetLastError (RtlNtStatusToDosError (errCode));
return FALSE; return FALSE;
} }
if (lpOverlapped)
*lpBytesReturned = lpOverlapped->InternalHigh;
else
*lpBytesReturned = IoStatusBlock->Information;
return TRUE;
}
if (lpOverlapped)
*lpBytesReturned = lpOverlapped->InternalHigh;
else
*lpBytesReturned = IoStatusBlock->Information;
return TRUE;
}
WINBOOL WINBOOL
STDCALL STDCALL
GetOverlappedResult( GetOverlappedResult (
HANDLE hFile, HANDLE hFile,
LPOVERLAPPED lpOverlapped, LPOVERLAPPED lpOverlapped,
LPDWORD lpNumberOfBytesTransferred, LPDWORD lpNumberOfBytesTransferred,
WINBOOL bWait WINBOOL bWait
) )
{ {
DWORD WaitStatus; DWORD WaitStatus;
if ( lpOverlapped == NULL ) { if (lpOverlapped == NULL)
{
SetLastError(RtlNtStatusToDosError(STATUS_INVALID_PARAMETER)); SetLastError(RtlNtStatusToDosError(STATUS_INVALID_PARAMETER));
return FALSE; return FALSE;
} }
if ( lpOverlapped ->Internal == STATUS_PENDING) {
if ( lpNumberOfBytesTransferred == 0 ) {
SetLastError(RtlNtStatusToDosError(STATUS_PENDING));
return FALSE;
}
else if ( bWait == TRUE ) {
if ( lpOverlapped->hEvent != NULL ) {
WaitStatus = WaitForSingleObject(lpOverlapped->hEvent,-1);
if ( WaitStatus == STATUS_TIMEOUT ) {
SetLastError(ERROR_IO_INCOMPLETE);
return FALSE;
}
else
return GetOverlappedResult(hFile,lpOverlapped,lpNumberOfBytesTransferred,FALSE);
} if (lpOverlapped ->Internal == STATUS_PENDING)
{
if (lpNumberOfBytesTransferred == 0)
{
SetLastError (RtlNtStatusToDosError (STATUS_PENDING));
return FALSE;
}
else if (bWait == TRUE)
{
if (lpOverlapped->hEvent != NULL)
{
WaitStatus = WaitForSingleObject (lpOverlapped->hEvent,
-1);
if (WaitStatus == STATUS_TIMEOUT)
{
SetLastError (ERROR_IO_INCOMPLETE);
return FALSE;
}
else
return GetOverlappedResult (hFile,
lpOverlapped,
lpNumberOfBytesTransferred,
FALSE);
}
} }
} }
*lpNumberOfBytesTransferred = lpOverlapped->InternalHigh;
if ( lpOverlapped->Internal < 0 ) {
SetLastError(RtlNtStatusToDosError(lpOverlapped->Internal));
return FALSE;
}
return TRUE;
*lpNumberOfBytesTransferred = lpOverlapped->InternalHigh;
if (lpOverlapped->Internal < 0)
{
SetLastError (RtlNtStatusToDosError (lpOverlapped->Internal));
return FALSE;
}
return TRUE;
} }
/* EOF */

23
reactos/lib/kernel32/file/lfile.c
View file

@ -1,4 +1,4 @@
/* $Id: lfile.c,v 1.4 1999/08/29 06:59:01 ea Exp $ /* $Id: lfile.c,v 1.5 2000/03/14 23:09:23 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -15,8 +15,6 @@
#include <wchar.h> #include <wchar.h>
long long
STDCALL STDCALL
_hread( _hread(
@ -136,8 +134,6 @@ _lopen (
else if ((iReadWrite & OF_SHARE_EXCLUSIVE) == OF_SHARE_EXCLUSIVE) else if ((iReadWrite & OF_SHARE_EXCLUSIVE) == OF_SHARE_EXCLUSIVE)
dwShareMode = 0; dwShareMode = 0;
SetLastError(0); SetLastError(0);
return (HFILE) CreateFileA( return (HFILE) CreateFileA(
lpPathName, lpPathName,
@ -146,9 +142,7 @@ _lopen (
NULL, NULL,
OPEN_EXISTING, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, FILE_ATTRIBUTE_NORMAL,
NULL NULL);
);
} }
@ -178,18 +172,17 @@ _lcreat (
NULL, NULL,
CREATE_ALWAYS, CREATE_ALWAYS,
iAttribute, iAttribute,
NULL NULL);
);
} }
int int
STDCALL STDCALL
_lclose ( _lclose (
HFILE hFile HFILE hFile
) )
{ {
if ( CloseHandle((HANDLE)hFile) ) if (CloseHandle ((HANDLE)hFile))
{ {
return 0; return 0;
} }
@ -205,13 +198,11 @@ _llseek(
int iOrigin int iOrigin
) )
{ {
return SetFilePointer( return SetFilePointer (
(HANDLE) hFile, (HANDLE) hFile,
lOffset, lOffset,
NULL, NULL,
(DWORD) iOrigin (DWORD) iOrigin);
);
} }
/* EOF */ /* EOF */

186
reactos/lib/kernel32/file/move.c
View file

@ -1,95 +1,116 @@
/* /* $Id: move.c,v 1.3 2000/03/14 23:09:23 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
* FILE: lib/kernel32/file/file.c * FILE: lib/kernel32/file/file.c
* PURPOSE: Directory functions * PURPOSE: Directory functions
* PROGRAMMER: Ariadne ( ariadne@xs4all.nl) * PROGRAMMER: Ariadne ( ariadne@xs4all.nl)
* GetTempFileName is modified from WINE [ Alexandre Juiliard ]
* UPDATE HISTORY: * UPDATE HISTORY:
* Created 01/11/98 * Created 01/11/98
*/ */
/* FIXME: the large integer manipulations in this file dont handle overflow */ /* INCLUDES *****************************************************************/
/* INCLUDES ****************************************************************/
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <windows.h> #include <windows.h>
#include <wchar.h>
#include <string.h>
//#define NDEBUG #define NDEBUG
#include <kernel32/kernel32.h> #include <kernel32/kernel32.h>
#define FILE_RENAME_SIZE MAX_PATH +sizeof(FILE_RENAME_INFORMATION)
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
WINBOOL WINBOOL
STDCALL STDCALL
MoveFileA( MoveFileA (
LPCSTR lpExistingFileName, LPCSTR lpExistingFileName,
LPCSTR lpNewFileName LPCSTR lpNewFileName
) )
{ {
return MoveFileExA(lpExistingFileName,lpNewFileName,MOVEFILE_COPY_ALLOWED); return MoveFileExA (lpExistingFileName,
lpNewFileName,
MOVEFILE_COPY_ALLOWED);
} }
WINBOOL
STDCALL
MoveFileExA(
LPCSTR lpExistingFileName,
LPCSTR lpNewFileName,
DWORD dwFlags
)
{
ULONG i;
WCHAR ExistingFileNameW[MAX_PATH];
WCHAR NewFileNameW[MAX_PATH];
i = 0;
while ((*lpExistingFileName)!=0 && i < MAX_PATH)
{
ExistingFileNameW[i] = *lpExistingFileName;
lpExistingFileName++;
i++;
}
ExistingFileNameW[i] = 0;
i = 0;
while ((*lpNewFileName)!=0 && i < MAX_PATH)
{
NewFileNameW[i] = *lpNewFileName;
lpNewFileName++;
i++;
}
NewFileNameW[i] = 0;
return MoveFileExW(ExistingFileNameW,NewFileNameW,dwFlags);
}
WINBOOL WINBOOL
STDCALL STDCALL
MoveFileW( MoveFileExA (
LPCWSTR lpExistingFileName, LPCSTR lpExistingFileName,
LPCWSTR lpNewFileName LPCSTR lpNewFileName,
) DWORD dwFlags
)
{ {
return MoveFileExW(lpExistingFileName,lpNewFileName,MOVEFILE_COPY_ALLOWED); UNICODE_STRING ExistingFileNameU;
UNICODE_STRING NewFileNameU;
ANSI_STRING ExistingFileName;
ANSI_STRING NewFileName;
WINBOOL Result;
RtlInitAnsiString (&ExistingFileName,
(LPSTR)lpExistingFileName);
RtlInitAnsiString (&NewFileName,
(LPSTR)lpNewFileName);
/* convert ansi (or oem) string to unicode */
if (bIsFileApiAnsi)
{
RtlAnsiStringToUnicodeString (&ExistingFileNameU,
&ExistingFileName,
TRUE);
RtlAnsiStringToUnicodeString (&NewFileNameU,
&NewFileName,
TRUE);
}
else
{
RtlOemStringToUnicodeString (&ExistingFileNameU,
&ExistingFileName,
TRUE);
RtlOemStringToUnicodeString (&NewFileNameU,
&NewFileName,
TRUE);
}
Result = MoveFileExW (ExistingFileNameU.Buffer,
NewFileNameU.Buffer,
dwFlags);
RtlFreeHeap (RtlGetProcessHeap (),
0,
ExistingFileNameU.Buffer);
RtlFreeHeap (RtlGetProcessHeap (),
0,
NewFileNameU.Buffer);
return Result;
} }
#define FILE_RENAME_SIZE MAX_PATH +sizeof(FILE_RENAME_INFORMATION)
WINBOOL WINBOOL
STDCALL STDCALL
MoveFileExW( MoveFileW (
LPCWSTR lpExistingFileName, LPCWSTR lpExistingFileName,
LPCWSTR lpNewFileName, LPCWSTR lpNewFileName
DWORD dwFlags )
) {
return MoveFileExW (lpExistingFileName,
lpNewFileName,
MOVEFILE_COPY_ALLOWED);
}
WINBOOL
STDCALL
MoveFileExW (
LPCWSTR lpExistingFileName,
LPCWSTR lpNewFileName,
DWORD dwFlags
)
{ {
HANDLE hFile = NULL; HANDLE hFile = NULL;
IO_STATUS_BLOCK IoStatusBlock; IO_STATUS_BLOCK IoStatusBlock;
@ -97,33 +118,40 @@ MoveFileExW(
USHORT Buffer[FILE_RENAME_SIZE]; USHORT Buffer[FILE_RENAME_SIZE];
NTSTATUS errCode; NTSTATUS errCode;
hFile = CreateFileW( hFile = CreateFileW (lpExistingFileName,
lpExistingFileName, GENERIC_ALL,
GENERIC_ALL, FILE_SHARE_WRITE|FILE_SHARE_READ,
FILE_SHARE_WRITE|FILE_SHARE_READ, NULL,
NULL, OPEN_EXISTING,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
FILE_ATTRIBUTE_NORMAL, NULL);
NULL
);
FileRename = (FILE_RENAME_INFORMATION *)Buffer; FileRename = (FILE_RENAME_INFORMATION *)Buffer;
if ( ( dwFlags & MOVEFILE_REPLACE_EXISTING ) == MOVEFILE_REPLACE_EXISTING ) if ((dwFlags & MOVEFILE_REPLACE_EXISTING) == MOVEFILE_REPLACE_EXISTING)
FileRename->Replace = TRUE; FileRename->Replace = TRUE;
else else
FileRename->Replace = FALSE; FileRename->Replace = FALSE;
FileRename->FileNameLength = lstrlenW(lpNewFileName); FileRename->FileNameLength = wcslen (lpNewFileName);
memcpy(FileRename->FileName,lpNewFileName,min(FileRename->FileNameLength,MAX_PATH)); memcpy (FileRename->FileName,
lpNewFileName,
min(FileRename->FileNameLength, MAX_PATH));
errCode = NtSetInformationFile(hFile,&IoStatusBlock,FileRename, FILE_RENAME_SIZE, FileRenameInformation); errCode = NtSetInformationFile (hFile,
if ( !NT_SUCCESS(errCode) ) { &IoStatusBlock,
if ( CopyFileW(lpExistingFileName,lpNewFileName,FileRename->Replace) ) FileRename,
DeleteFileW(lpExistingFileName); FILE_RENAME_SIZE,
FileRenameInformation);
if (!NT_SUCCESS(errCode))
{
if (CopyFileW (lpExistingFileName,
lpNewFileName,
FileRename->Replace))
DeleteFileW (lpExistingFileName);
} }
CloseHandle(hFile); CloseHandle(hFile);
return TRUE; return TRUE;
} }
/* EOF */