-/* $Id: rtl.h,v 1.25 2000/02/05 16:04:52 ekohl Exp $
+/* $Id: rtl.h,v 1.26 2000/02/18 00:47:28 ekohl Exp $
*
*/
PCSZ SourceString
);
-NTSTATUS
-STDCALL
-RtlInitializeContext (
- IN HANDLE ProcessHandle,
- IN PCONTEXT Context,
- IN PVOID Parameter,
- IN PTHREAD_START_ROUTINE StartAddress,
- IN OUT PINITIAL_TEB InitialTeb
- );
-
VOID
STDCALL
RtlInitString (
PCWSTR SourceString
);
+NTSTATUS
+STDCALL
+RtlInitializeContext (
+ IN HANDLE ProcessHandle,
+ IN PCONTEXT Context,
+ IN PVOID Parameter,
+ IN PTHREAD_START_ROUTINE StartAddress,
+ IN OUT PINITIAL_TEB InitialTeb
+ );
+
NTSTATUS
STDCALL
RtlIntegerToChar (
IN OUT PUNICODE_STRING String
);
+BOOLEAN
+STDCALL
+RtlIsNameLegalDOS8Dot3 (
+ IN PUNICODE_STRING UnicodeName,
+ IN OUT PANSI_STRING AnsiName,
+ IN OUT PBOOLEAN SpacesFound
+ );
+
LARGE_INTEGER
STDCALL
RtlLargeIntegerAdd (
#endif
#define DPRINT1(args...) do { DbgPrint("(%s:%d) ",__FILE__,__LINE__); DbgPrint(args); ExAllocatePool(NonPagedPool,0); } while(0);
+#define CHECKPOINT1 do { DbgPrint("%s:%d\n",__FILE__,__LINE__); ExAllocatePool(NonPagedPool,0); } while(0);
extern unsigned int old_idt[256][2];
//extern unsigned int idt;
ULONG Size;
} PEB_FREE_BLOCK, *PPEB_FREE_BLOCK;
+/* RTL_USER_PROCESS_PARAMETERS.Flags */
+#define PPF_NORMALIZED (1)
+
typedef struct _RTL_USER_PROCESS_PARAMETERS
{
ULONG TotalSize; // 00h
#define FIELD_OFFSET(type,fld) ((LONG)&(((type *)0)->fld))
#endif
+
+/* GLOBAL VARIABLES ***********************************************************/
+
+extern WINBOOL bIsFileApiAnsi;
+
+
+/* FUNCTION PROTOTYPES ********************************************************/
+
BOOL __ErrorReturnFalse(ULONG ErrorCode);
PVOID __ErrorReturnNull(ULONG ErrorCode);
-/* $Id: rtl.h,v 1.8 2000/02/05 16:06:09 ekohl Exp $
+/* $Id: rtl.h,v 1.9 2000/02/18 00:48:25 ekohl Exp $
*
*/
PWSTR DeviceName
);
-BOOLEAN
-STDCALL
-RtlIsNameLegalDOS8Dot3 (
- PUNICODE_STRING us,
- PANSI_STRING as,
- PBOOLEAN pb
- );
-
NTSTATUS
STDCALL
RtlSetCurrentDirectory_U (
IN PUNICODE_STRING Title,
IN PUNICODE_STRING Desktop,
IN PUNICODE_STRING Reserved,
- IN PVOID Reserved2
+ IN PUNICODE_STRING Reserved2
);
-VOID
+PRTL_USER_PROCESS_PARAMETERS
STDCALL
RtlDeNormalizeProcessParams (
IN OUT PRTL_USER_PROCESS_PARAMETERS ProcessParameters
IN OUT PRTL_USER_PROCESS_PARAMETERS ProcessParameters
);
-VOID
+PRTL_USER_PROCESS_PARAMETERS
STDCALL
RtlNormalizeProcessParams (
IN OUT PRTL_USER_PROCESS_PARAMETERS ProcessParameters
-/* $Id: curdir.c,v 1.19 2000/01/11 17:30:16 ekohl Exp $
+/* $Id: curdir.c,v 1.20 2000/02/18 00:49:39 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
/* INCLUDES ******************************************************************/
+#include <ddk/ntddk.h>
+#include <ntdll/rtl.h>
#include <windows.h>
-#include <wchar.h>
-#include <ctype.h>
-#include <string.h>
#define NDEBUG
#include <kernel32/kernel32.h>
-/* GLOBALS *******************************************************************/
-static HANDLE hCurrentDirectory = NULL;
-static WCHAR CurrentDirectoryW[MAX_PATH];
+/* GLOBAL VARIABLES **********************************************************/
static WCHAR SystemDirectoryW[MAX_PATH];
static WCHAR WindowsDirectoryW[MAX_PATH];
-WINBOOL STDCALL SetCurrentDirectoryW(LPCWSTR lpPathName);
/* FUNCTIONS *****************************************************************/
-DWORD STDCALL GetCurrentDirectoryA(DWORD nBufferLength, LPSTR lpBuffer)
+DWORD
+STDCALL
+GetCurrentDirectoryA (
+ DWORD nBufferLength,
+ LPSTR lpBuffer
+ )
{
- UINT uSize,i;
- WCHAR TempDir[MAX_PATH];
-
- if ( lpBuffer == NULL )
- return 0;
-
- GetCurrentDirectoryW(MAX_PATH, TempDir);
- uSize = lstrlenW(TempDir);
- if (nBufferLength > uSize)
- {
- i = 0;
- while (TempDir[i] != 0)
- {
- lpBuffer[i] = (unsigned char)TempDir[i];
- i++;
- }
- lpBuffer[i] = 0;
- }
- return uSize;
+ ANSI_STRING AnsiString;
+ UNICODE_STRING UnicodeString;
+
+ /* initialize ansi string */
+ AnsiString.Length = 0;
+ AnsiString.MaximumLength = nBufferLength;
+ AnsiString.Buffer = lpBuffer;
+
+ /* allocate buffer for unicode string */
+ UnicodeString.Length = 0;
+ UnicodeString.MaximumLength = nBufferLength * sizeof(WCHAR);
+ UnicodeString.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
+ 0,
+ UnicodeString.MaximumLength);
+
+ /* get current directory */
+ UnicodeString.Length = RtlGetCurrentDirectory_U (UnicodeString.MaximumLength,
+ UnicodeString.Buffer);
+ DPRINT("UnicodeString.Buffer %S\n", UnicodeString.Buffer);
+
+ /* convert unicode string to ansi (or oem) */
+ if (bIsFileApiAnsi)
+ RtlUnicodeStringToAnsiString (&AnsiString,
+ &UnicodeString,
+ FALSE);
+ else
+ RtlUnicodeStringToOemString (&AnsiString,
+ &UnicodeString,
+ FALSE);
+ DPRINT("AnsiString.Buffer %s\n", AnsiString.Buffer);
+
+ /* free unicode string */
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ UnicodeString.Buffer);
+
+ return AnsiString.Length;
}
-DWORD STDCALL GetCurrentDirectoryW(DWORD nBufferLength, LPWSTR lpBuffer)
-{
- UINT uSize;
- DPRINT("GetCurrentDirectoryW()\n");
+DWORD
+STDCALL
+GetCurrentDirectoryW (
+ DWORD nBufferLength,
+ LPWSTR lpBuffer
+ )
+{
+ ULONG Length;
- if ( lpBuffer == NULL )
- return 0;
+ Length = RtlGetCurrentDirectory_U (nBufferLength,
+ lpBuffer);
- uSize = lstrlenW(CurrentDirectoryW);
- if (nBufferLength > uSize)
- {
- lstrcpyW(lpBuffer, CurrentDirectoryW);
- }
- if (uSize > 3 && lpBuffer[uSize - 1] == L'\\')
- {
- lpBuffer[uSize - 1] = 0;
- uSize--;
- }
- DPRINT("GetCurrentDirectoryW() = '%S'\n",lpBuffer);
-
- return uSize;
-#if 0
- return (RtlGetCurrentDirectory_U (nBufferLength, lpBuffer) / sizeof (WCHAR));
-#endif
+ return (Length / sizeof (WCHAR));
}
-WINBOOL STDCALL SetCurrentDirectoryA(LPCSTR lpPathName)
-{
- UINT i;
- WCHAR PathNameW[MAX_PATH];
-
- if ( lpPathName == NULL )
- {
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
- }
-
- if ( lstrlen(lpPathName) > MAX_PATH )
- {
- SetLastError(ERROR_BUFFER_OVERFLOW);
- return FALSE;
- }
-
- i = 0;
- while ((lpPathName[i])!=0 && i < MAX_PATH)
- {
- PathNameW[i] = (WCHAR)lpPathName[i];
- i++;
- }
- PathNameW[i] = 0;
-
- return SetCurrentDirectoryW(PathNameW);
-}
-WINBOOL STDCALL SetCurrentDirectoryW(LPCWSTR lpPathName)
+WINBOOL
+STDCALL
+SetCurrentDirectoryA (
+ LPCSTR lpPathName
+ )
{
- ULONG len;
- WCHAR PathName[MAX_PATH];
- HANDLE hDir;
-
- DPRINT("SetCurrentDirectoryW(lpPathName %S)\n",lpPathName);
-
- if (lpPathName == NULL)
- {
- SetLastError(ERROR_INVALID_PARAMETER);
- return FALSE;
- }
-
- len = lstrlenW(lpPathName);
- if (len > MAX_PATH)
- {
- SetLastError(ERROR_BUFFER_OVERFLOW);
- return FALSE;
- }
-
- if (!GetFullPathNameW (lpPathName, MAX_PATH, PathName, NULL))
- {
- SetLastError(ERROR_BAD_PATHNAME);
- return FALSE;
- }
-
- DPRINT("PathName %S\n",PathName);
-
- hDir = CreateFileW(PathName,
- GENERIC_READ,
- FILE_SHARE_READ,
- NULL,
- OPEN_EXISTING,
- FILE_ATTRIBUTE_DIRECTORY,
- NULL);
- if (hDir == INVALID_HANDLE_VALUE)
- {
- DPRINT("Failed to open directory\n");
- SetLastError(ERROR_BAD_PATHNAME);
- return FALSE;
- }
-
- if (hCurrentDirectory != NULL)
- {
- CloseHandle(hCurrentDirectory);
- }
-
- hCurrentDirectory = hDir;
-
- DPRINT("PathName %S\n",PathName);
+ ANSI_STRING AnsiString;
+ UNICODE_STRING UnicodeString;
+ NTSTATUS Status;
+
+ RtlInitAnsiString (&AnsiString,
+ (LPSTR)lpPathName);
+
+ /* convert ansi (or oem) to unicode */
+ if (bIsFileApiAnsi)
+ RtlAnsiStringToUnicodeString (&UnicodeString,
+ &AnsiString,
+ TRUE);
+ else
+ RtlOemStringToUnicodeString (&UnicodeString,
+ &AnsiString,
+ TRUE);
+
+ Status = RtlSetCurrentDirectory_U (&UnicodeString);
+
+ RtlFreeUnicodeString (&UnicodeString);
+
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastError (RtlNtStatusToDosError (Status));
+ return FALSE;
+ }
+
+ return TRUE;
+}
- wcscpy(CurrentDirectoryW,PathName);
- len = lstrlenW(CurrentDirectoryW);
- if (CurrentDirectoryW[len-1] != '\\')
- {
- CurrentDirectoryW[len] = '\\';
- CurrentDirectoryW[len+1] = 0;
- }
- return TRUE;
-#if 0
- UNICODE_STRING PathName_U;
+WINBOOL
+STDCALL
+SetCurrentDirectoryW (
+ LPCWSTR lpPathName
+ )
+{
+ UNICODE_STRING UnicodeString;
+ NTSTATUS Status;
- RtlInitUnicodeString (&PathName_U,
+ RtlInitUnicodeString (&UnicodeString,
lpPathName);
- return RtlSetCurrentDirectory_U (&PathName_U);
-#endif
+ Status = RtlSetCurrentDirectory_U (&UnicodeString);
+ if (!NT_SUCCESS(Status))
+ {
+ SetLastError (RtlNtStatusToDosError (Status));
+ return FALSE;
+ }
+
+ return TRUE;
}
-DWORD STDCALL GetTempPathA(DWORD nBufferLength, LPSTR lpBuffer)
+
+DWORD STDCALL GetTempPathA (DWORD nBufferLength, LPSTR lpBuffer)
{
WCHAR BufferW[MAX_PATH];
DWORD retCode;
UINT i;
retCode = GetTempPathW(nBufferLength,BufferW);
i = 0;
- while ((BufferW[i])!=0 && i < MAX_PATH)
- {
+ while ((BufferW[i])!=0 && i < MAX_PATH)
+ {
lpBuffer[i] = (unsigned char)BufferW[i];
i++;
- }
- lpBuffer[i] = 0;
+ }
+ lpBuffer[i] = 0;
return retCode;
}
UINT STDCALL GetSystemDirectoryA(LPSTR lpBuffer, UINT uSize)
{
UINT uPathSize,i;
- if ( lpBuffer == NULL )
+
+ if ( lpBuffer == NULL )
return 0;
- uPathSize = lstrlenW(SystemDirectoryW);
+ uPathSize = lstrlenW(SystemDirectoryW);
if ( uSize > uPathSize ) {
i = 0;
while ((SystemDirectoryW[i])!=0 && i < uSize)
UINT STDCALL GetWindowsDirectoryA(LPSTR lpBuffer, UINT uSize)
{
UINT uPathSize,i;
- if ( lpBuffer == NULL )
+ if ( lpBuffer == NULL )
return 0;
- uPathSize = lstrlenW(WindowsDirectoryW);
+ uPathSize = lstrlenW(WindowsDirectoryW);
if ( uSize > uPathSize ) {
i = 0;
while ((WindowsDirectoryW[i])!=0 && i < uSize)
)
{
UINT uPathSize;
- if ( lpBuffer == NULL )
+ if ( lpBuffer == NULL )
return 0;
- uPathSize = lstrlenW(SystemDirectoryW);
- if ( uSize > uPathSize )
+ uPathSize = lstrlenW(SystemDirectoryW);
+ if ( uSize > uPathSize )
lstrcpynW(lpBuffer,SystemDirectoryW,uPathSize);
return uPathSize;
)
{
UINT uPathSize;
- if ( lpBuffer == NULL )
+ if ( lpBuffer == NULL )
return 0;
- uPathSize = lstrlenW(WindowsDirectoryW);
+ uPathSize = lstrlenW(WindowsDirectoryW);
if ( uSize > uPathSize );
lstrcpynW(lpBuffer,WindowsDirectoryW,uPathSize);
-/* $Id: dir.c,v 1.23 2000/01/20 22:55:37 ekohl Exp $
+/* $Id: dir.c,v 1.24 2000/02/18 00:49:39 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
/* INCLUDES ******************************************************************/
#include <ddk/ntddk.h>
+#include <ntdll/rtl.h>
#include <windows.h>
#include <string.h>
#include <wchar.h>
}
-static DWORD GetDotSequenceLengthA (PSTR p)
+DWORD
+STDCALL
+GetFullPathNameA (
+ LPCSTR lpFileName,
+ DWORD nBufferLength,
+ LPSTR lpBuffer,
+ LPSTR *lpFilePart
+ )
{
- DWORD dwCount = 0;
-
- for (;;)
- {
- if (*p == '.')
- dwCount++;
- else if ((*p == '\\' || *p == '\0') && dwCount)
- return dwCount;
+ UNICODE_STRING FileNameU;
+ UNICODE_STRING FullNameU;
+ ANSI_STRING FileName;
+ ANSI_STRING FullName;
+ PWSTR FilePartU;
+ ULONG BufferLength;
+ ULONG Offset;
+
+ DPRINT("GetFullPathNameA(lpFileName %s, nBufferLength %d, lpBuffer %p, "
+ "lpFilePart %p)\n",lpFileName,nBufferLength,lpBuffer,lpFilePart);
+
+ RtlInitAnsiString (&FileName,
+ (LPSTR)lpFileName);
+
+ if (bIsFileApiAnsi)
+ RtlAnsiStringToUnicodeString (&FileNameU,
+ &FileName,
+ TRUE);
else
- return 0;
- p++;
- }
- return 0;
-}
-
-DWORD STDCALL GetFullPathNameA(LPCSTR lpFileName,
- DWORD nBufferLength,
- LPSTR lpBuffer,
- LPSTR *lpFilePart)
-{
- PSTR p;
- PSTR prev = NULL;
-
- DPRINT("GetFullPathNameA(lpFileName %s, nBufferLength %d, lpBuffer %p, "
- "lpFilePart %p)\n",lpFileName,nBufferLength,lpBuffer,lpFilePart);
-
- if (!lpFileName || !lpBuffer)
- return 0;
-
- if (isalpha(lpFileName[0]) && lpFileName[1] == ':')
- {
- if (lpFileName[2] == '\\')
- {
- lstrcpyA(lpBuffer, lpFileName);
- }
- else
- {
- CHAR szRoot[4] = "A:\\";
- DWORD len;
-
- szRoot[0] = lpFileName[0];
- len = GetCurrentDirectoryA(nBufferLength, lpBuffer);
- if (lpBuffer[len - 1] != '\\')
- {
- lpBuffer[len] = '\\';
- lpBuffer[len + 1] = 0;
- }
- lstrcatA(lpBuffer, &lpFileName[2]);
- }
- }
- else if (lpFileName[0] == '\\')
- {
- GetCurrentDirectoryA(nBufferLength, lpBuffer);
- lstrcpyA(&lpBuffer[2], lpFileName);
- }
- else
- {
- DWORD len;
- len = GetCurrentDirectoryA(nBufferLength, lpBuffer);
- if (lpBuffer[len - 1] != '\\')
- {
- lpBuffer[len] = '\\';
- lpBuffer[len + 1] = 0;
- }
- lstrcatA(lpBuffer, lpFileName);
- }
-
- DPRINT("lpBuffer %s\n",lpBuffer);
-
- p = lpBuffer + 2;
- prev = p;
-
- while ((*p) != 0 || ((*p) == '\\' && (*(p+1)) == 0))
- {
- DWORD dwDotLen;
-
- dwDotLen = GetDotSequenceLengthA (p+1);
- DPRINT("DotSequenceLength %u\n", dwDotLen);
- DPRINT("prev %s p %s\n",prev,p);
-
- if (dwDotLen == 0)
- {
- prev = p;
- do
- {
- p++;
- }
- while ((*p) != 0 && (*p) != '\\');
- }
- else if (dwDotLen == 1)
- {
- lstrcpyA(p, p+2);
- }
- else
- {
- if (dwDotLen > 2)
- {
- int n = dwDotLen - 2;
-
- while (n > 0 && prev > (lpBuffer+2))
- {
- prev--;
- if ((*prev) == '\\')
- n--;
- }
- }
-
- if (*(p+dwDotLen+1) == 0)
- *(prev+1) = 0;
- else
- lstrcpyA (prev, p+dwDotLen+1);
- p = prev;
- if (prev > (lpBuffer+2))
- {
- prev--;
- while ((*prev) != '\\')
- {
- prev--;
- }
- }
- }
- }
-
- if (lpFilePart != NULL)
- {
- (*lpFilePart) = prev + 1;
- }
-
- DPRINT("lpBuffer %s\n",lpBuffer);
+ RtlOemStringToUnicodeString (&FileNameU,
+ &FileName,
+ TRUE);
+
+ BufferLength = nBufferLength * sizeof(WCHAR);
+
+ FullNameU.MaximumLength = BufferLength;
+ FullNameU.Length = 0;
+ FullNameU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
+ 0,
+ BufferLength);
+
+ FullNameU.Length = RtlGetFullPathName_U (FileNameU.Buffer,
+ BufferLength,
+ FullNameU.Buffer,
+ &FilePartU);
+
+ RtlFreeUnicodeString (&FileNameU);
+
+ FullName.MaximumLength = nBufferLength;
+ FullName.Length = 0;
+ FullName.Buffer = lpBuffer;
+
+ /* convert unicode to ansi (or oem) */
+ if (bIsFileApiAnsi)
+ RtlUnicodeStringToAnsiString (&FullName,
+ &FullNameU,
+ FALSE);
+ else
+ RtlUnicodeStringToOemString (&FullName,
+ &FullNameU,
+ FALSE);
- return strlen(lpBuffer);
-}
+ if (lpFilePart != NULL)
+ {
+ Offset = (ULONG)(FilePartU - FullNameU.Buffer);
+ *lpFilePart = FullName.Buffer + Offset;
+ }
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ FullNameU.Buffer);
-static DWORD GetDotSequenceLengthW (PWSTR p)
-{
- DWORD dwCount = 0;
+ DPRINT("lpBuffer %s lpFilePart %s Length %ld\n",
+ lpBuffer, lpFilePart, FullName.Length);
- for (;;)
- {
- if (*p == '.')
- dwCount++;
- else if ((*p == '\\' || *p == '\0') && dwCount)
- return dwCount;
- else
- return 0;
- p++;
- }
- return 0;
+ return FullName.Length;
}
-DWORD STDCALL GetFullPathNameW(LPCWSTR lpFileName,
- DWORD nBufferLength,
- LPWSTR lpBuffer,
- LPWSTR *lpFilePart)
+DWORD
+STDCALL
+GetFullPathNameW (
+ LPCWSTR lpFileName,
+ DWORD nBufferLength,
+ LPWSTR lpBuffer,
+ LPWSTR *lpFilePart
+ )
{
- PWSTR p;
- PWSTR prev = NULL;
+ ULONG Length;
- DPRINT("GetFullPathNameW(lpFileName %S, nBufferLength %d, lpBuffer %p, "
- "lpFilePart %p)\n",lpFileName,nBufferLength,lpBuffer,lpFilePart);
+ DPRINT("GetFullPathNameW(lpFileName %S, nBufferLength %d, lpBuffer %p, "
+ "lpFilePart %p)\n",lpFileName,nBufferLength,lpBuffer,lpFilePart);
- if (!lpFileName || !lpBuffer)
- return 0;
-
- if (isalpha(lpFileName[0]) && lpFileName[1] == L':')
- {
- if (lpFileName[2] == L'\\')
- {
- lstrcpyW(lpBuffer, lpFileName);
- }
- else
- {
- WCHAR szRoot[4] = L"A:\\";
- DWORD len;
-
- szRoot[0] = lpFileName[0];
- len = GetCurrentDirectoryW(nBufferLength, lpBuffer);
- if (lpBuffer[len - 1] != L'\\')
- {
- lpBuffer[len] = L'\\';
- lpBuffer[len + 1] = 0;
- }
- lstrcatW(lpBuffer, &lpFileName[2]);
- }
- }
- else if (lpFileName[0] == L'\\')
- {
- GetCurrentDirectoryW(nBufferLength, lpBuffer);
- lstrcpyW(&lpBuffer[2], lpFileName);
- }
- else
- {
- DWORD len;
- len = GetCurrentDirectoryW(nBufferLength, lpBuffer);
- if (lpBuffer[len - 1] != L'\\')
- {
- lpBuffer[len] = L'\\';
- lpBuffer[len + 1] = 0;
- }
- lstrcatW(lpBuffer, lpFileName);
- }
+ Length = RtlGetFullPathName_U ((LPWSTR)lpFileName,
+ nBufferLength * sizeof(WCHAR),
+ lpBuffer,
+ lpFilePart);
- DPRINT("lpBuffer %S\n",lpBuffer);
+ DPRINT("lpBuffer %S lpFilePart %S Length %ld\n",
+ lpBuffer, lpFilePart, Length / sizeof(WCHAR));
- p = lpBuffer + 2;
- prev = p;
-
- while ((*p) != 0 || ((*p) == L'\\' && (*(p+1)) == 0))
- {
- DWORD dwDotLen;
-
- dwDotLen = GetDotSequenceLengthW (p+1);
- DPRINT("DotSequenceLength %u\n", dwDotLen);
- DPRINT("prev %S p %S\n",prev,p);
-
- if (dwDotLen == 0)
- {
- prev = p;
- do
- {
- p++;
- }
- while ((*p) != 0 && (*p) != L'\\');
- }
- else if (dwDotLen == 1)
- {
- lstrcpyW(p, p+2);
- }
- else
- {
- if (dwDotLen > 2)
- {
- int n = dwDotLen - 2;
-
- while (n > 0 && prev > (lpBuffer+2))
- {
- prev--;
- if ((*prev) == L'\\')
- n--;
- }
- }
-
- if (*(p+dwDotLen+1) == 0)
- *(prev+1) = 0;
- else
- lstrcpyW (prev, p+dwDotLen+1);
- p = prev;
- if (prev > (lpBuffer+2))
- {
- prev--;
- while ((*prev) != L'\\')
- {
- prev--;
- }
- }
- }
- }
-
- if (lpFilePart != NULL)
- {
- (*lpFilePart) = prev + 1;
- }
-
- DPRINT("lpBuffer %S\n",lpBuffer);
-
- return wcslen(lpBuffer);
+ return (Length / sizeof(WCHAR));
}
return RetValue;
}
-DWORD STDCALL SearchPathW(LPCWSTR lpPath,
- LPCWSTR lpFileName,
- LPCWSTR lpExtension,
- DWORD nBufferLength,
- LPWSTR lpBuffer,
+DWORD STDCALL SearchPathW(LPCWSTR lpPath,
+ LPCWSTR lpFileName,
+ LPCWSTR lpExtension,
+ DWORD nBufferLength,
+ LPWSTR lpBuffer,
LPWSTR *lpFilePart)
/*
* FUNCTION: Searches for the specified file
DPRINT("SearchPath\n");
- if ( lpPath == NULL ) {
+ if ( lpPath == NULL )
+ {
// check the directory from which the application loaded
if ( GetCurrentDirectoryW( MAX_PATH, BufferW ) > 0 ) {
HeapFree(GetProcessHeap(),0,EnvironmentBufferW);
-// WCHAR BufferW[MAX_PATH];
-// WCHAR FileAndExtensionW[MAX_PATH];
-// WCHAR *EnvironmentBufferW = NULL;
-
-// UNICODE_STRING PathString;
-// OBJECT_ATTRIBUTES ObjectAttributes;
-// IO_STATUS_BLOCK IoStatusBlock;
-
- DPRINT("SearchPath\n");
-
- if (lpPath == NULL)
- {
- // check the directory from which the application loaded
-
- if (GetCurrentDirectoryW(MAX_PATH, BufferW) > 0)
- {
- retCode = SearchPathW(BufferW,lpFileName, lpExtension, nBufferLength, lpBuffer, lpFilePart );
- if ( retCode != 0 )
- return retCode;
- }
- if ( GetSystemDirectoryW(BufferW, MAX_PATH) > 0 )
- {
- retCode = SearchPathW(BufferW,lpFileName, lpExtension, nBufferLength, lpBuffer, lpFilePart );
- if ( retCode != 0 )
- return retCode;
- }
-
- if ( GetWindowsDirectoryW(BufferW, MAX_PATH) > 0 )
- {
- retCode = SearchPathW(BufferW,lpFileName, lpExtension, nBufferLength, lpBuffer, lpFilePart );
- if ( retCode != 0 )
- return retCode;
- }
-
- j = GetEnvironmentVariableW(L"Path",EnvironmentBufferW,0);
- EnvironmentBufferW = (WCHAR *) HeapAlloc(GetProcessHeap(),HEAP_GENERATE_EXCEPTIONS|HEAP_ZERO_MEMORY,(j+1)*sizeof(WCHAR));
-
- j = GetEnvironmentVariableW(L"Path",EnvironmentBufferW,j+1);
-
- for(i=0;i<j;i++) {
- if ( EnvironmentBufferW[i] == L';' )
- EnvironmentBufferW[i] = 0;
+ return retCode;
}
- i = 0;
- while ( retCode == 0 && i < j ) {
- if ( EnvironmentBufferW[i] != 0 )
- retCode = SearchPathW(&EnvironmentBufferW[i],lpFileName, lpExtension, nBufferLength, lpBuffer, lpFilePart );
- i += lstrlenW(&EnvironmentBufferW[i]) + 1;
- }
-
- HeapFree(GetProcessHeap(),0,EnvironmentBufferW);
-
- return retCode;
- }
- else {
-
- FileAndExtensionW[0] = 0;
- lpBuffer[0] = 0;
- i = lstrlenW(lpFileName);
- j = lstrlenW(lpPath);
+ else
+ {
+ FileAndExtensionW[0] = 0;
+ lpBuffer[0] = 0;
+ i = lstrlenW(lpFileName);
+ j = lstrlenW(lpPath);
- if ( i + j + 8 < nBufferLength )
- return i + j + 9;
+ if ( i + j + 8 < nBufferLength )
+ return i + j + 9;
- if ( lpExtension != NULL ) {
+ if ( lpExtension != NULL )
+ {
if ( lpFileName[i-4] != L'.' ) {
wcscpy(FileAndExtensionW,lpFileName);
wcscat(FileAndExtensionW,lpExtension);
}
else
- wcscpy(FileAndExtensionW,lpFileName);
- }
- else
- wcscpy(FileAndExtensionW,lpFileName);
-
-
-
-
- lstrcatW(BufferW,L"\\??\\");
- lstrcatW(BufferW,lpPath);
-
-
- //printf("%S\n",FileAndExtensionW);
-
-
- i = wcslen(BufferW);
- if ( BufferW[i-1] != L'\\' ) {
- BufferW[i] = L'\\';
- BufferW[i+1] = 0;
- }
- if ( lpFilePart != NULL )
- {
- *lpFilePart = &BufferW[wcslen(BufferW)+1];
- wcscpy(FileAndExtensionW,lpFileName);
+ wcscpy(FileAndExtensionW,lpFileName);
}
else
wcscpy(FileAndExtensionW,lpFileName);
lstrcatW(BufferW,L"\\??\\");
lstrcatW(BufferW,lpPath);
-
+
+ //printf("%S\n",FileAndExtensionW);
+
+ i = wcslen(BufferW);
+ if ( BufferW[i-1] != L'\\' )
+ {
+ BufferW[i] = L'\\';
+ BufferW[i+1] = 0;
+ }
+ if ( lpFilePart != NULL )
+ {
+ *lpFilePart = &BufferW[wcslen(BufferW)+1];
+ wcscpy(FileAndExtensionW,lpFileName);
+ }
+ else
+ wcscpy(FileAndExtensionW,lpFileName);
+
+ lstrcatW(BufferW,L"\\??\\");
+ lstrcatW(BufferW,lpPath);
+
//printf("%S\n",FileAndExtensionW);
i = wcslen(BufferW);
if ( lpFilePart != NULL )
*lpFilePart = &BufferW[wcslen(BufferW)+1];
wcscat(BufferW,FileAndExtensionW);
- //printf("%S\n",lpBuffer);
+
+ //printf("%S\n",lpBuffer);
PathString.Buffer = BufferW;
PathString.Length = lstrlenW(PathString.Buffer)*sizeof(WCHAR);
*lpFilePart = wcsrchr(lpBuffer,'\\')+1;
}
- return lstrlenW(lpBuffer);
- }
+ return lstrlenW(lpBuffer);
}
}
+/* EOF */
#define LPPROGRESS_ROUTINE void*
+
/* GLOBALS ******************************************************************/
-static BOOLEAN bIsFileApiAnsi; // set the file api to ansi or oem
+WINBOOL bIsFileApiAnsi = TRUE; // set the file api to ansi or oem
+
/* FUNCTIONS ****************************************************************/
VOID STDCALL SetFileApisToOEM(VOID)
{
- bIsFileApiAnsi = FALSE;
+ bIsFileApiAnsi = FALSE;
}
WINBOOL STDCALL AreFileApisANSI(VOID)
{
- return(bIsFileApiAnsi);
+ return (bIsFileApiAnsi);
}
HANDLE hFile;
NTSTATUS errCode;
- hFile = CreateFileW(lpFileName,
+ hFile = CreateFileW(lpFileName,
FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES,
FILE_SHARE_READ,
NULL,
{
DPRINT("DLL_PROCESS_ATTACH\n");
AllocConsole();
- SetCurrentDirectoryA("C:\\");
break;
}
case DLL_THREAD_ATTACH:
}
return TRUE;
}
-
-
-
-/*
+/* $Id: env.c,v 1.10 2000/02/18 00:49:56 ekohl Exp $
+ *
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: lib/kernel32/misc/env.c
*/
#include <ddk/ntddk.h>
+#include <ntdll/rtl.h>
#include <windows.h>
#include <wchar.h>
#include <string.h>
+#define NDEBUG
#include <kernel32/kernel32.h>
-#define MAX_ENVIRONMENT_VARS 255
-#define MAX_VALUE 1024
-typedef struct _ENV_ELEMENT
+/* FUNCTIONS ******************************************************************/
+
+DWORD
+STDCALL
+GetEnvironmentVariableA (
+ LPCSTR lpName,
+ LPSTR lpBuffer,
+ DWORD nSize
+ )
{
- UNICODE_STRING Name;
- UNICODE_STRING Value;
- WINBOOL Valid;
-} ENV_ELEMENT;
+ ANSI_STRING VarName;
+ ANSI_STRING VarValue;
+ UNICODE_STRING VarNameU;
+ UNICODE_STRING VarValueU;
+ NTSTATUS Status;
+
+ /* initialize unicode variable name string */
+ RtlInitAnsiString (&VarName,
+ (LPSTR)lpName);
+ RtlAnsiStringToUnicodeString (&VarNameU,
+ &VarName,
+ TRUE);
+
+ /* initialize ansi variable value string */
+ VarValue.Length = 0;
+ VarValue.MaximumLength = nSize;
+ VarValue.Buffer = lpBuffer;
+
+ /* initialize unicode variable value string and allocate buffer */
+ VarValueU.Length = 0;
+ VarValueU.MaximumLength = nSize * sizeof(WCHAR);
+ VarValueU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
+ 0,
+ VarValueU.MaximumLength);
+
+ /* get unicode environment variable */
+ Status = RtlQueryEnvironmentVariable_U (NULL,
+ &VarNameU,
+ &VarValueU);
+ if (!NT_SUCCESS(Status))
+ {
+ /* free unicode buffer */
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ VarValueU.Buffer);
-ENV_ELEMENT Environment[MAX_ENVIRONMENT_VARS+1];
-UINT nEnvVar = 0;
+ /* free unicode variable name string */
+ RtlFreeUnicodeString (&VarNameU);
-DWORD STDCALL GetEnvironmentVariableA(LPCSTR lpName,
- LPSTR lpBuffer,
- DWORD nSize)
-{
- WCHAR BufferW[MAX_VALUE];
- WCHAR NameW[MAX_PATH];
- DWORD RetValue;
- int i=0;
-
- while ((*lpName)!=0 && i < MAX_PATH)
- {
- NameW[i] = *lpName;
- lpName++;
- i++;
- }
- NameW[i] = 0;
-
- RetValue = GetEnvironmentVariableW(NameW,BufferW,nSize);
- for(i=0;i<nSize;i++)
- lpBuffer[i] = (char)BufferW[i];
- return RetValue;
+ SetLastError (RtlNtStatusToDosError(Status));
+ return 0;
+ }
+
+ /* convert unicode value string to ansi */
+ RtlUnicodeStringToAnsiString (&VarValue,
+ &VarValueU,
+ FALSE);
+
+ /* free unicode buffer */
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ VarValueU.Buffer);
+
+ /* free unicode variable name string */
+ RtlFreeUnicodeString (&VarNameU);
+
+ return (VarValueU.Length / sizeof(WCHAR));
}
+
DWORD
STDCALL
-GetEnvironmentVariableW(
- LPCWSTR lpName,
- LPWSTR lpBuffer,
- DWORD nSize
- )
+GetEnvironmentVariableW (
+ LPCWSTR lpName,
+ LPWSTR lpBuffer,
+ DWORD nSize
+ )
{
- UINT NameLen;
- UINT i;
- NameLen = lstrlenW(lpName);
- i = 0;
+ UNICODE_STRING VarName;
+ UNICODE_STRING VarValue;
+ NTSTATUS Status;
+
+ RtlInitUnicodeString (&VarName,
+ lpName);
- while (i < nEnvVar)
+ VarValue.Length = 0;
+ VarValue.MaximumLength = nSize * sizeof(WCHAR);
+ VarValue.Buffer = lpBuffer;
+
+ Status = RtlQueryEnvironmentVariable_U (NULL,
+ &VarName,
+ &VarValue);
+ if (!NT_SUCCESS(Status))
{
- if ( _wcsnicmp(Environment[i].Name.Buffer,lpName,min(NameLen,Environment[i].Name.Length/sizeof(WCHAR))) != 0 ) {
- lstrcpynW(lpBuffer,Environment[i].Value.Buffer,min(nSize,Environment[i].Value.Length/sizeof(WCHAR)));
-
- return lstrlenW(Environment[i].Value.Buffer);
-
- }
- i++;
+ SetLastError (RtlNtStatusToDosError(Status));
+ return 0;
}
- return 0;
-
-}
+ return (VarValue.Length / sizeof(WCHAR));
+}
WINBOOL
STDCALL
-SetEnvironmentVariableA(
- LPCSTR lpName,
- LPCSTR lpValue
- )
+SetEnvironmentVariableA (
+ LPCSTR lpName,
+ LPCSTR lpValue
+ )
{
- WCHAR NameW[MAX_PATH];
- WCHAR ValueW[MAX_VALUE];
-
- int i=0;
- while ((*lpName)!=0 && i < MAX_PATH)
+ ANSI_STRING VarName;
+ ANSI_STRING VarValue;
+ UNICODE_STRING VarNameU;
+ UNICODE_STRING VarValueU;
+ NTSTATUS Status;
+
+ RtlInitAnsiString (&VarName,
+ (LPSTR)lpName);
+ RtlAnsiStringToUnicodeString (&VarNameU,
+ &VarName,
+ TRUE);
+
+ RtlInitAnsiString (&VarValue,
+ (LPSTR)lpValue);
+ RtlAnsiStringToUnicodeString (&VarValueU,
+ &VarValue,
+ TRUE);
+
+ Status = RtlSetEnvironmentVariable (NULL,
+ &VarNameU,
+ &VarValueU);
+
+ RtlFreeUnicodeString (&VarNameU);
+ RtlFreeUnicodeString (&VarValueU);
+
+ if (!NT_SUCCESS(Status))
{
- NameW[i] = *lpName;
- lpName++;
- i++;
+ SetLastError (RtlNtStatusToDosError(Status));
+ return FALSE;
}
- NameW[i] = 0;
- i = 0;
-
- while ((*lpValue)!=0 && i < MAX_PATH)
- {
- ValueW[i] = *lpValue;
- lpValue++;
- i++;
- }
- ValueW[i] = 0;
- return SetEnvironmentVariableW(NameW,ValueW);
+ return TRUE;
}
WINBOOL
STDCALL
-SetEnvironmentVariableW(
- LPCWSTR lpName,
- LPCWSTR lpValue
- )
+SetEnvironmentVariableW (
+ LPCWSTR lpName,
+ LPCWSTR lpValue
+ )
{
- UINT NameLen, ValueLen;
- UINT i;
- WCHAR *NameBuffer;
- WCHAR *ValueBuffer;
- NameLen = lstrlenW(lpName);
- ValueLen = lstrlenW(lpValue);
- i = 0;
-
- while (i < nEnvVar)
- {
- if ( _wcsnicmp(Environment[i].Name.Buffer,lpName,min(NameLen,Environment[i].Name.Length/sizeof(WCHAR))) != 0 ) {
- if ( lpValue != NULL ) {
- lstrcpynW(Environment[i].Value.Buffer,lpValue,min(ValueLen,Environment[i].Value.MaximumLength/sizeof(WCHAR)));
- return TRUE;
- }
- else {
- Environment[i].Valid = FALSE;
- Environment[i].Value.Length = 0;
- Environment[i].Name.Length = 0;
- return FALSE;
- }
- }
- i++;
- }
+ UNICODE_STRING VarName;
+ UNICODE_STRING VarValue;
+ NTSTATUS Status;
- if ( nEnvVar >= MAX_ENVIRONMENT_VARS )
- return FALSE;
+ RtlInitUnicodeString (&VarName,
+ lpName);
+
+ RtlInitUnicodeString (&VarValue,
+ lpValue);
- while (i < nEnvVar)
+ Status = RtlSetEnvironmentVariable (NULL,
+ &VarName,
+ &VarValue);
+ if (!NT_SUCCESS(Status))
{
- if ( Environment[i].Valid == FALSE )
- break;
- i++;
- }
- if ( i == nEnvVar ) {
- NameBuffer = (WCHAR *)HeapAlloc(GetProcessHeap(),HEAP_GENERATE_EXCEPTIONS|HEAP_ZERO_MEMORY,MAX_PATH*sizeof(WCHAR) );
- ValueBuffer = (WCHAR *)HeapAlloc(GetProcessHeap(),HEAP_GENERATE_EXCEPTIONS|HEAP_ZERO_MEMORY,MAX_VALUE*sizeof(WCHAR) );
-
- Environment[i].Name.Buffer = NameBuffer;
- Environment[i].Name.MaximumLength = MAX_PATH*sizeof(WCHAR);
-
- Environment[i].Value.Buffer = ValueBuffer;
- Environment[i].Value.MaximumLength = MAX_VALUE*sizeof(WCHAR);
- nEnvVar++;
+ SetLastError (RtlNtStatusToDosError(Status));
+ return FALSE;
}
- Environment[i].Valid = TRUE;
-
- lstrcpynW(Environment[i].Name.Buffer,lpValue,min(NameLen,(Environment[i].Name.MaximumLength-sizeof(WCHAR))/sizeof(WCHAR)));
- Environment[i].Name.Length = NameLen*sizeof(WCHAR);
-
- lstrcpynW(Environment[i].Value.Buffer,lpValue,min(ValueLen,(Environment[i].Value.MaximumLength-sizeof(WCHAR)))/sizeof(WCHAR));
- Environment[i].Value.Length = ValueLen*sizeof(WCHAR);
return TRUE;
}
+
DWORD
STDCALL
GetVersion(VOID)
}
-
WINBOOL
STDCALL
GetVersionExW(
- LPOSVERSIONINFO lpVersionInformation
- )
+ LPOSVERSIONINFO lpVersionInformation
+ )
{
lpVersionInformation->dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
lpVersionInformation->dwMajorVersion = 4;
return TRUE;
}
+
WINBOOL
STDCALL
GetVersionExA(
- LPOSVERSIONINFO lpVersionInformation
- )
+ LPOSVERSIONINFO lpVersionInformation
+ )
{
lpVersionInformation->dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
lpVersionInformation->dwMajorVersion = 4;
LPSTR
STDCALL
-GetEnvironmentStringsA(VOID)
+GetEnvironmentStringsA (
+ VOID
+ )
{
-#if 0
- WCHAR *EnvironmentStringsW;
- char *EnvironmentStringsA;
- int size = 0;
- int i;
-#endif
-
- return(NULL);
-
- /* FIXME: This doesn't work */
-#if 0
- EnvironmentStringsW = GetEnvironmentStringsW();
- EnvironmentStringsA = (char *)EnvironmentStringsW;
-
- for(i=0;i<nEnvVar;i++)
- {
- if ( Environment[i].Valid )
- {
- size += Environment[i].Name.Length;
- size += sizeof(WCHAR); // =
- size += Environment[i].Value.Length;
- size += sizeof(WCHAR); // zero
- }
- }
- size += sizeof(WCHAR);
- size /= sizeof(WCHAR);
- for(i=0;i<size;i++)
- EnvironmentStringsA[i] = (char)EnvironmentStringsW[i];
- return EnvironmentStringsA;
-#endif
-}
-
+ UNICODE_STRING UnicodeString;
+ ANSI_STRING AnsiString;
+ PWCHAR EnvU;
+ PWCHAR PtrU;
+ ULONG Length;
+ PCHAR EnvPtr = NULL;
-LPWSTR
-STDCALL
-GetEnvironmentStringsW(VOID)
-{
-#if 0
- int size = 0;
- int i;
- WCHAR *EnvironmentString;
- WCHAR *EnvironmentStringSave;
-#endif
-
- return(NULL);
-
- /* FIXME: This doesn't work, why not? */
-#if 0
- for(i=0;i<nEnvVar;i++)
- {
- if ( Environment[i].Valid )
- {
- size += Environment[i].Name.Length;
- size += sizeof(WCHAR); // =
- size += Environment[i].Value.Length;
- size += sizeof(WCHAR); // zero
- }
- }
- size += sizeof(WCHAR); // extra zero
- DPRINT("size %d\n",size);
- EnvironmentString = (WCHAR *)HeapAlloc(GetProcessHeap(),
- HEAP_GENERATE_EXCEPTIONS|HEAP_ZERO_MEMORY,
- size);
- DPRINT("EnvironmentString %x\n",EnvironmentString);
- EnvironmentStringSave = EnvironmentString;
- for(i=0;i<nEnvVar;i++)
- {
- if ( Environment[i].Valid )
- {
- wcscpy(EnvironmentString,Environment[i].Name.Buffer);
- wcscat(EnvironmentString,L"=");
- wcscat(EnvironmentString,Environment[i].Value.Buffer);
-
- size = Environment[i].Name.Length;
- size += sizeof(WCHAR); // =
- size += Environment[i].Value.Length;
- size += sizeof(WCHAR); // zero
- EnvironmentString += (size/sizeof(WCHAR));
- }
- }
- *EnvironmentString = 0;
- return EnvironmentStringSave;
-#endif
-}
+ EnvU = (PWCHAR)(NtCurrentPeb ()->ProcessParameters->Environment);
+ if (EnvU == NULL)
+ return NULL;
-WINBOOL
-STDCALL
-FreeEnvironmentStringsA(
- LPSTR EnvironmentStrings
- )
-{
- if ( EnvironmentStrings == NULL )
- return FALSE;
- HeapFree(GetProcessHeap(),0,EnvironmentStrings);
- return TRUE;
-}
+ if (*EnvU == 0)
+ return NULL;
-WINBOOL
-STDCALL
-FreeEnvironmentStringsW(
- LPWSTR EnvironmentStrings
- )
-{
- if ( EnvironmentStrings == NULL )
- return FALSE;
- HeapFree(GetProcessHeap(),0,EnvironmentStrings);
- return TRUE;
-}
+ /* get environment size */
+ PtrU = EnvU;
+ while (*PtrU)
+ {
+ while (*PtrU)
+ PtrU++;
+ PtrU++;
+ }
+ Length = (ULONG)(PtrU - EnvU);
+ DPRINT("Length %lu\n", Length);
+ /* allocate environment buffer */
+ EnvPtr = RtlAllocateHeap (RtlGetProcessHeap (),
+ 0,
+ Length + 1);
+ DPRINT("EnvPtr %p\n", EnvPtr);
-int ExpandVariableA(
- LPCSTR lpSrc, LPSTR lpDst, DWORD nSize , DWORD *nWritten)
-{
- int nVar = 0;
- LPSTR lpVar;
- LPSTR lpEnd;
+ /* convert unicode environment to ansi */
+ UnicodeString.MaximumLength = Length + sizeof(WCHAR);
+ UnicodeString.Buffer = EnvU;
- if ( nWritten == NULL )
- return -1;
+ AnsiString.MaximumLength = Length + 1;
+ AnsiString.Length = 0;
+ AnsiString.Buffer = EnvPtr;
- if ( *lpSrc != '%' ) {
- return -1;
- }
+ DPRINT ("UnicodeString.Buffer \'%S\'\n", UnicodeString.Buffer);
+ while (*(UnicodeString.Buffer))
+ {
+ UnicodeString.Length = wcslen (UnicodeString.Buffer) * sizeof(WCHAR);
+ if (UnicodeString.Length > 0)
+ {
+ DPRINT("UnicodeString.Buffer \'%S\'\n", UnicodeString.Buffer);
- lpVar = (LPSTR)lpSrc;
- lpVar++;
+ RtlUnicodeStringToAnsiString (&AnsiString,
+ &UnicodeString,
+ FALSE);
+ DPRINT("AnsiString.Buffer \'%s\'\n", AnsiString.Buffer);
- lpEnd = strchr( lpVar, '%' );
- if ( lpEnd == NULL ) {
- return -1;
+ AnsiString.Buffer += (AnsiString.Length + 1);
+ UnicodeString.Buffer += ((UnicodeString.Length / sizeof(WCHAR)) + 1);
+ }
}
- else
- *lpEnd = 0;
+ *(AnsiString.Buffer) = 0;
- nWritten = GetEnvironmentVariableA(lpVar,lpDst,nSize);
- *lpEnd = '%';
-
- if ( nWritten == 0 )
- return -1;
-
- if ( nWritten > nSize )
- return -1;
-
- return (lpEnd - lpVar) -1;
+ return EnvPtr;
}
-DWORD STDCALL ExpandEnvironmentStringsA(
- LPCSTR lpSrc, LPSTR lpDst, DWORD nSize
-)
+LPWSTR
+STDCALL
+GetEnvironmentStringsW (
+ VOID
+ )
{
- DWORD v;
- DWORD bw;
-
- while(*lpSrc != 0 && nSize > 0 )
- {
- if ( *lpSrc == '%' ) {
- v = ExpandVariableA(lpSrc,lpDst,nSize , &bw);
- if ( v == -1 ) {
- *lpDst = *lpSrc;
- lpDst++;
- lpSrc++;
- nSize--;
- }
- else {
- lpSrc+=v;
- lpDst+=bw;
- nSize-=bw;
- }
- }
- else {
-
- *lpDst = *lpSrc;
- lpDst++;
- lpSrc++;
- nSize--;
-
- }
-
- }
-
+ return (LPWSTR)(NtCurrentPeb ()->ProcessParameters->Environment);
}
-int ExpandVariableW(
- LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize , DWORD *nWritten)
+
+WINBOOL
+STDCALL
+FreeEnvironmentStringsA (
+ LPSTR EnvironmentStrings
+ )
{
- LPWSTR lpVar;
- LPWSTR lpEnd;
+ if (EnvironmentStrings == NULL)
+ return FALSE;
- if ( nWritten == NULL )
- return -1;
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ EnvironmentStrings);
- if ( *lpSrc != L'%' ) {
- return -1;
- }
+ return TRUE;
+}
- lpVar = (LPWSTR)lpSrc;
- lpVar++;
+WINBOOL
+STDCALL
+FreeEnvironmentStringsW (
+ LPWSTR EnvironmentStrings
+ )
+{
+ return TRUE;
+}
- lpEnd = wcschr( lpVar, L'%' );
- if ( lpEnd == NULL ) {
- return -1;
+DWORD
+STDCALL
+ExpandEnvironmentStringsA (
+ LPCSTR lpSrc,
+ LPSTR lpDst,
+ DWORD nSize
+ )
+{
+ ANSI_STRING Source;
+ ANSI_STRING Destination;
+ UNICODE_STRING SourceU;
+ UNICODE_STRING DestinationU;
+ NTSTATUS Status;
+ ULONG Length = 0;
+
+ RtlInitAnsiString (&Source,
+ (LPSTR)lpSrc);
+ RtlAnsiStringToUnicodeString (&SourceU,
+ &Source,
+ TRUE);
+
+ Destination.Length = 0;
+ Destination.MaximumLength = nSize;
+ Destination.Buffer = lpDst,
+
+ DestinationU.Length = 0;
+ DestinationU.MaximumLength = nSize * sizeof(WCHAR);
+ DestinationU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
+ 0,
+ DestinationU.MaximumLength);
+
+ Status = RtlExpandEnvironmentStrings_U (NULL,
+ &SourceU,
+ &DestinationU,
+ &Length);
+
+ RtlFreeUnicodeString (&SourceU);
+
+ if (!NT_SUCCESS(Status))
+ {
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ DestinationU.Buffer);
+ SetLastError (RtlNtStatusToDosError (Status));
+ return 0;
}
- else
- *lpEnd = 0;
- nWritten = GetEnvironmentVariableW(lpVar,lpDst,nSize);
- *lpEnd = L'%';
+ RtlUnicodeStringToAnsiString (&Destination,
+ &DestinationU,
+ FALSE);
- if ( nWritten == 0 )
- return -1;
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ DestinationU.Buffer);
- if ( nWritten > nSize )
- return -1;
-
- return ((lpEnd - lpVar)/2) -1;
+ return (Length / sizeof(WCHAR));
}
-DWORD STDCALL ExpandEnvironmentStringsW(
- LPCWSTR lpSrc, LPWSTR lpDst, DWORD nSize
-)
+DWORD
+STDCALL
+ExpandEnvironmentStringsW (
+ LPCWSTR lpSrc,
+ LPWSTR lpDst,
+ DWORD nSize
+ )
{
- DWORD v;
- DWORD bw;
-
- while(*lpSrc != 0 && nSize > 0 )
+ UNICODE_STRING Source;
+ UNICODE_STRING Destination;
+ NTSTATUS Status;
+ ULONG Length = 0;
+
+ RtlInitUnicodeString (&Source,
+ (LPWSTR)lpSrc);
+
+ Destination.Length = 0;
+ Destination.MaximumLength = nSize * sizeof(WCHAR);
+ Destination.Buffer = lpDst;
+
+ Status = RtlExpandEnvironmentStrings_U (NULL,
+ &Source,
+ &Destination,
+ &Length);
+ if (!NT_SUCCESS(Status))
{
- if ( *lpSrc == L'%' ) {
- v = ExpandVariableW(lpSrc,lpDst,nSize , &bw);
- if ( v == -1 ) {
- *lpDst = *lpSrc;
- lpDst++;
- lpSrc++;
- nSize--;
- }
- else {
- lpSrc+=v;
- lpDst+=bw;
- nSize-=bw;
- }
- }
- else {
-
- *lpDst = *lpSrc;
- lpDst++;
- lpSrc++;
- nSize--;
-
- }
-
+ SetLastError (RtlNtStatusToDosError (Status));
+ return 0;
}
-
+
+ return (Length / sizeof(WCHAR));
}
+/* EOF */
\ No newline at end of file
-/* $Id: create.c,v 1.20 2000/02/13 16:05:13 dwelch Exp $
+/* $Id: create.c,v 1.21 2000/02/18 00:50:07 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
ULONG PpbSize;
ULONG BytesWritten;
ULONG Offset;
-
+ PVOID ParentEnv = NULL;
+ PVOID EnvPtr = NULL;
+ ULONG EnvSize = 0;
+
+ /* create the Environment */
+ if (Ppb->Environment != NULL)
+ ParentEnv = Ppb->Environment;
+ else if (NtCurrentPeb()->ProcessParameters->Environment != NULL)
+ ParentEnv = NtCurrentPeb()->ProcessParameters->Environment;
+
+ if (ParentEnv != NULL)
+ {
+ MEMORY_BASIC_INFORMATION MemInfo;
+
+ Status = NtQueryVirtualMemory (NtCurrentProcess (),
+ ParentEnv,
+ MemoryBasicInformation,
+ &MemInfo,
+ sizeof(MEMORY_BASIC_INFORMATION),
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+ EnvSize = MemInfo.RegionSize;
+ }
+ DPRINT("EnvironmentSize %ld\n", EnvSize);
+
+ /* allocate and initialize new environment block */
+ if (EnvSize != 0)
+ {
+ Status = NtAllocateVirtualMemory(ProcessHandle,
+ &EnvPtr,
+ 0,
+ &EnvSize,
+ MEM_COMMIT,
+ PAGE_READWRITE);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+
+ NtWriteVirtualMemory(ProcessHandle,
+ EnvPtr,
+ ParentEnv,
+ EnvSize,
+ &BytesWritten);
+ }
+
/* create the PPB */
PpbBase = (PVOID)PEB_STARTUPINFO;
PpbSize = Ppb->TotalSize;
Ppb->TotalSize,
&BytesWritten);
+ /* write pointer to environment */
+ Offset = FIELD_OFFSET(RTL_USER_PROCESS_PARAMETERS, Environment);
+ NtWriteVirtualMemory(ProcessHandle,
+ (PVOID)(PpbBase + Offset),
+ &EnvPtr,
+ sizeof(EnvPtr),
+ &BytesWritten);
- /* create the PPB */
-
+ /* write pointer to process parameter block */
Offset = FIELD_OFFSET(PEB, ProcessParameters);
-
NtWriteVirtualMemory(ProcessHandle,
- PEB_BASE + Offset,
+ (PVOID)(PEB_BASE + Offset),
&PpbBase,
sizeof(PpbBase),
&BytesWritten);
NTSTATUS Status;
LPTHREAD_START_ROUTINE lpStartAddress = NULL;
WCHAR TempCommandLine[256];
- PVOID BaseAddress;
- LARGE_INTEGER SectionOffset;
- IMAGE_NT_HEADERS Headers;
- IMAGE_DOS_HEADER DosHeader;
- HANDLE NTDllSection;
- ULONG InitialViewSize;
+// PVOID BaseAddress;
+// LARGE_INTEGER SectionOffset;
+// IMAGE_NT_HEADERS Headers;
+// IMAGE_DOS_HEADER DosHeader;
+// HANDLE NTDllSection;
+// ULONG InitialViewSize;
PROCESS_BASIC_INFORMATION ProcessBasicInfo;
ULONG retlen;
DWORD len = 0;
-; $Id: ntdll.def,v 1.39 2000/02/05 16:07:10 ekohl Exp $
+; $Id: ntdll.def,v 1.40 2000/02/18 00:48:50 ekohl Exp $
;
; ReactOS Operating System
;
RtlDestroyEnvironment@4
RtlDestroyHeap@4
RtlDestroyProcessParameters@4
+RtlDetermineDosPathNameType_U@4
+RtlDoesFileExists_U@4
+RtlDosPathNameToNtPathName_U@16
+RtlDosSearchPath_U@24
RtlDowncaseUnicodeString@12
RtlEnlargedIntegerMultiply@8
RtlEnlargedUnsignedDivide@16
RtlFreeUnicodeString@4
RtlGetCurrentDirectory_U@8
RtlGetDaclSecurityDescriptor@16
+RtlGetFullPathName_U@16
RtlGetGroupSecurityDescriptor@12
+RtlGetLongestNtPathLength@0
RtlGetOwnerSecurityDescriptor@12
RtlGetProcessHeap@0
RtlInitAnsiString@8
-RtlInitializeContext@20
RtlInitString@8
RtlInitUnicodeString@8
+RtlInitializeContext@20
RtlIntegerToChar@16
RtlIntegerToUnicodeString@12
+RtlIsDosDeviceName_U@4
+RtlIsNameLegalDOS8Dot3@12
RtlLargeIntegerAdd@16
RtlLargeIntegerArithmeticShift@12
RtlLargeIntegerDivide@20
RtlUnlockHeap@4
RtlUnicodeStringToAnsiSize@4
RtlUnicodeStringToAnsiString@12
+RtlUnicodeStringToCountedOemString@12
RtlUnicodeStringToInteger@12
RtlUnicodeStringToOemSize@4
RtlUnicodeStringToOemString@12
-; $Id: ntdll.edf,v 1.29 2000/02/05 16:07:10 ekohl Exp $
+; $Id: ntdll.edf,v 1.30 2000/02/18 00:48:50 ekohl Exp $
;
; ReactOS Operating System
;
RtlDestroyEnvironment=RtlDestroyEnvironment@4
RtlDestroyHeap=RtlDestroyHeap@4
RtlDestroyProcessParameters=RtlDestroyProcessParameters@4
+RtlDetermineDosPathNameType_U=RtlDetermineDosPathNameType_U@4
+RtlDoesFileExists_U=RtlDoesFileExists_U@4
+RtlDosPathNameToNtPathName_U=RtlDosPathNameToNtPathName_U@16
+RtlDosSearchPath_U=RtlDosSearchPath_U@24
RtlDowncaseUnicodeString=RtlDowncaseUnicodeString@12
RtlEnlargedIntegerMultiply=RtlEnlargedIntegerMultiply@8
RtlEnlargedUnsignedDivide=RtlEnlargedUnsignedDivide@16
RtlFreeUnicodeString=RtlFreeUnicodeString@4
RtlGetCurrentDirectory_U=RtlGetCurrentDirectory_U@8
RtlGetDaclSecurityDescriptor=RtlGetDaclSecurityDescriptor@16
+RtlGetFullPathName_U=RtlGetFullPathName_U@16
RtlGetGroupSecurityDescriptor=RtlGetGroupSecurityDescriptor@12
+RtlGetLongestNtPathLength=RtlGetLongestNtPathLength@0
RtlGetOwnerSecurityDescriptor=RtlGetOwnerSecurityDescriptor@12
RtlGetProcessHeap=RtlGetProcessHeap@0
RtlInitAnsiString=RtlInitAnsiString@8
-RtlInitializeContext=RtlInitializeContext@20
RtlInitString=RtlInitString@8
RtlInitUnicodeString=RtlInitUnicodeString@8
+RtlInitializeContext=RtlInitializeContext@20
RtlIntegerToChar=RtlIntegerToChar@16
RtlIntegerToUnicodeString=RtlIntegerToUnicodeString@12
+RtlIsDosDeviceName_U=RtlIsDosDeviceName_U@4
+RtlIsNameLegalDOS8Dot3=RtlIsNameLegalDOS8Dot3@12
RtlLargeIntegerAdd=RtlLargeIntegerAdd@16
RtlLargeIntegerArithmeticShift=RtlLargeIntegerArithmeticShift@12
RtlLargeIntegerDivide=RtlLargeIntegerDivide@20
RtlUnlockHeap=RtlUnlockHeap@4
RtlUnicodeStringToAnsiSize=RtlUnicodeStringToAnsiSize@4
RtlUnicodeStringToAnsiString=RtlUnicodeStringToAnsiString@12
+RtlUnicodeStringToCountedOemString=RtlUnicodeStringToCountedOemString@12
RtlUnicodeStringToInteger=RtlUnicodeStringToInteger@12
+RtlUnicodeStringToOemSize=RtlUnicodeStringToOemSize@4
+RtlUnicodeStringToOemString=RtlUnicodeStringToOemString@12
RtlUnicodeToMultiByteN=RtlUnicodeToMultiByteN@20
RtlUnicodeToMultiByteSize=RtlUnicodeToMultiByteSize@12
+RtlUnicodeToOemN=RtlUnicodeToOemN@20
RtlUnwind=RtlUnwind@0
RtlUpcaseUnicodeChar=RtlUpcaseUnicodeChar@4
RtlUpcaseUnicodeString=RtlUpcaseUnicodeString@12
-/* $Id: env.c,v 1.6 2000/02/13 16:05:16 dwelch Exp $
+/* $Id: env.c,v 1.7 2000/02/18 00:49:11 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
#include <internal/teb.h>
#include <string.h>
-//#define NDEBUG
+#define NDEBUG
#include <ntdll/ntdll.h>
/* FUNCTIONS *****************************************************************/
MEMORY_BASIC_INFORMATION MemInfo;
PVOID EnvPtr = NULL;
NTSTATUS Status = STATUS_SUCCESS;
- ULONG RegionSize = 1;
+ ULONG RegionSize = PAGESIZE;
if (Initialize == FALSE)
{
}
else
{
- RegionSize = 1;
Status = NtAllocateVirtualMemory (NtCurrentProcess (),
&EnvPtr,
0,
MEM_COMMIT,
PAGE_READWRITE);
if (NT_SUCCESS(Status))
+ {
+ memset (EnvPtr, 0, RegionSize);
*Environment = EnvPtr;
+ }
}
return Status;
STDCALL
RtlExpandEnvironmentStrings_U (
PVOID Environment,
- PUNICODE_STRING src,
- PUNICODE_STRING dst,
+ PUNICODE_STRING Source,
+ PUNICODE_STRING Destination,
PULONG Length
)
{
- UNICODE_STRING var,val;
- int src_len, dst_max, tail;
- WCHAR *s,*d,*w;
- BOOLEAN flag = FALSE;
+ UNICODE_STRING var;
+ UNICODE_STRING val;
NTSTATUS Status = STATUS_SUCCESS;
-
- src_len = src->Length / 2;
- s = src->Buffer;
- dst_max = dst->MaximumLength / 2;
- d = dst->Buffer;
-
- while( src_len )
+ BOOLEAN flag = FALSE;
+ PWSTR s;
+ PWSTR d;
+ PWSTR w;
+ int src_len;
+ int dst_max;
+ int tail;
+
+ src_len = Source->Length / sizeof(WCHAR);
+ s = Source->Buffer;
+ dst_max = Destination->MaximumLength / sizeof(WCHAR);
+ d = Destination->Buffer;
+
+ while (src_len)
{
- if( *s == L'%' )
+ if (*s == L'%')
{
- if( flag )
+ if (flag)
{
flag = FALSE;
goto copy;
}
- w = s + 1; tail = src_len - 1;
- while( *w != L'%' && tail )
+ w = s + 1;
+ tail = src_len - 1;
+ while (*w != L'%' && tail)
{
w++;
tail--;
}
- if( !tail )
+ if (!tail)
goto copy;
- var.Length = ( w - ( s + 1 ) ) * 2;
+ var.Length = (w - ( s + 1)) * sizeof(WCHAR);
var.MaximumLength = var.Length;
- var.Buffer = s + 1;
+ var.Buffer = s + 1;
- val.Length = 0;
- val.MaximumLength = dst_max * 2;
- val.Buffer = d;
- Status = RtlQueryEnvironmentVariable_U (Environment, &var, &val );
- if( Status >= 0 )
+ val.Length = 0;
+ val.MaximumLength = dst_max * sizeof(WCHAR);
+ val.Buffer = d;
+ Status = RtlQueryEnvironmentVariable_U (Environment, &var, &val);
+ if (!NT_SUCCESS(Status))
{
- d += val.Length / 2;
- dst_max -= val.Length / 2;
- s = w + 1;
+ d += val.Length / sizeof(WCHAR);
+ dst_max -= val.Length / sizeof(WCHAR);
+ s = w + 1;
src_len = tail - 1;
continue;
}
/* variable not found or buffer too small, just copy %var% */
flag = TRUE;
}
-copy:;
- if( !dst_max )
+copy:
+ if (!dst_max)
{
Status = STATUS_BUFFER_TOO_SMALL;
break;
dst_max--;
src_len--;
}
- dst->Length = ( d - dst->Buffer ) * 2;
- if (Length)
- *Length = dst->Length;
- if( dst_max )
- dst->Buffer[ dst->Length / 2 ] = 0;
+ Destination->Length = (d - Destination->Buffer) * sizeof(WCHAR);
+ if (Length != NULL)
+ *Length = Destination->Length;
+ if (dst_max)
+ Destination->Buffer[Destination->Length / sizeof(WCHAR)] = 0;
return Status;
}
RtlReleasePebLock ();
}
-#if 0
+
NTSTATUS
STDCALL
RtlSetEnvironmentVariable (
PVOID *Environment,
PUNICODE_STRING Name,
- PUNICODE_STRING Value
- )
-{
- NTSTATUS Status;
- PWSTR EnvPtr;
- PWSTR EndPtr;
- ULONG EnvLength;
-
- Status = STATUS_VARIABLE_NOT_FOUND;
-
- if (Environment != NULL)
- {
- EnvPtr = *Environment
- }
- else
- {
- RtlAcquirePebLock ();
- EnvPtr = NtCurrentPeb()->ProcessParameters->Environment;
- }
-
- if (EnvPtr != NULL)
- {
- /* get environment length */
- EndPtr = EnvPtr;
- while (*EndPtr)
- {
- while (*EndPtr++)
- ;
- EndPtr++;
- }
- EnvLen = EndPtr - EnvPtr;
-
- /* FIXME: add missing stuff */
-
- }
-
- if (EnvPtr != *Environment)
- RtlReleasePebLock ();
-
- return Status;
-}
-#endif
-
-
-NTSTATUS
-WINAPI
-RtlSetEnvironmentVariable (
- PVOID *Environment,
- UNICODE_STRING *varname,
- UNICODE_STRING *value)
+ PUNICODE_STRING Value)
{
- UNICODE_STRING var;
MEMORY_BASIC_INFORMATION mbi;
+ UNICODE_STRING var;
int hole_len, new_len, env_len = 0;
WCHAR *new_env = 0, *env_end = 0, *wcs, *env, *val = 0, *tail = 0, *hole = 0;
ULONG size = 0, new_size;
LONG f = 1;
NTSTATUS Status = STATUS_SUCCESS;
+ DPRINT ("RtlSetEnvironmentVariable Environment %p Name %wZ Value %wZ\n",
+ Environment, Name, Value);
+
if (Environment)
{
env = *Environment;
env = NtCurrentPeb()->ProcessParameters->Environment;
}
- if( env )
+ if (env)
{
/* get environment length */
wcs = env_end = env;
- while( *env_end ) while( *env_end++ ); env_end++;
+ while (*env_end)
+ while (*env_end++)
+ ;
+ env_end++;
env_len = env_end - env;
+ DPRINT ("environment length %ld characters\n", env_len);
/* find where to insert */
- while( *wcs )
+ while (*wcs)
{
for (var.Buffer = wcs++; *wcs && *wcs != L'='; wcs++);
- if( *wcs )
+ if (*wcs)
{
- var.Length = ( wcs - var.Buffer ) * 2;
+ var.Length = (wcs - var.Buffer) * sizeof(WCHAR);
var.MaximumLength = var.Length;
for ( val = ++wcs; *wcs; wcs++);
- f = RtlCompareUnicodeString( &var, varname, TRUE );
- if( f >= 0 )
+ f = RtlCompareUnicodeString (&var, Name, TRUE);
+ if (f >= 0)
{
- if( f ) /* Insert before found */
+ if (f) /* Insert before found */
{
hole = tail = var.Buffer;
}
hole = tail = wcs; /* Append to environment */
}
-found:;
- if( value )
+found:
+ if (Value->Length > 0)
{
hole_len = tail - hole;
/* calculate new environment size */
- new_size = value->Length + 2;
- if( f )
- new_size += varname->Length + 2; /* adding new variable */
- new_len = new_size / 2;
+ new_size = Value->Length + sizeof(WCHAR);
+ /* adding new variable */
+ if (f)
+ new_size += Name->Length + sizeof(WCHAR);
+ new_len = new_size / sizeof(WCHAR);
if (hole_len < new_len)
{
- /* we must enlarge environment size, let's check the size of available
- * memory */
- new_size += ( env_len - hole_len ) * 2;
+ /* we must enlarge environment size */
+ /* let's check the size of available memory */
+ new_size += (env_len - hole_len) * sizeof(WCHAR);
+ new_size = ROUNDUP(new_size, PAGESIZE);
mbi.RegionSize = 0;
+ DPRINT("new_size %lu\n", new_size);
if (env)
{
- Status = NtQueryVirtualMemory( (HANDLE)-1, env, 0, &mbi, sizeof(mbi), NULL );
+ Status = NtQueryVirtualMemory (NtCurrentProcess (),
+ env,
+ 0,
+ &mbi,
+ sizeof(mbi),
+ NULL);
if (!NT_SUCCESS(Status))
{
RtlReleasePebLock ();
if (new_size > mbi.RegionSize)
{
/* reallocate memory area */
- Status = NtAllocateVirtualMemory( (HANDLE)-1, (VOID**)&new_env, 0, &new_size, MEM_COMMIT, PAGE_READWRITE );
+ Status = NtAllocateVirtualMemory (NtCurrentProcess (),
+ (VOID**)&new_env,
+ 0,
+ &new_size,
+ MEM_COMMIT,
+ PAGE_READWRITE);
if (!NT_SUCCESS(Status))
{
RtlReleasePebLock ();
if (env)
{
- memmove( new_env, env, ( hole - env ) * 2 );
- hole = new_env + ( hole - env );
+ memmove (new_env,
+ env,
+ (hole - env) * sizeof(WCHAR));
+ hole = new_env + (hole - env);
}
else
{
}
/* move tail */
- memmove ( hole + new_len, tail, ( env_end - tail ) * 2 );
- if( new_env )
+ memmove (hole + new_len, tail, (env_end - tail) * sizeof(WCHAR));
+
+ if (new_env)
{
/* we reallocated environment, let's free the old one */
if (Environment)
if (env)
{
- NtFreeVirtualMemory (NtCurrentProcess(),
+ size = 0;
+CHECKPOINT;
+DPRINT ("env %x\n", env);
+DPRINT ("&env %x\n", &env);
+ NtFreeVirtualMemory (NtCurrentProcess (),
(VOID**)&env,
&size,
MEM_RELEASE);
+CHECKPOINT;
}
}
/* and now copy given stuff */
- if( f )
+ if (f)
{
- /* copy variable name and '=' sign */
- memmove (hole, varname->Buffer, varname->Length);
- hole += varname->Length / 2; *hole++ = L'=';
+ /* copy variable name and '=' character */
+ memmove (hole, Name->Buffer, Name->Length);
+ hole += Name->Length / sizeof(WCHAR);
+ *hole++ = L'=';
}
/* copy value */
- memmove( hole, value->Buffer, value->Length );
- hole += value->Length / 2; *hole = 0;
+ memmove (hole, Value->Buffer, Value->Length);
+ hole += Value->Length / sizeof(WCHAR);
+ *hole = 0;
}
else
{
- if (!f)
- memmove (hole, tail, ( env_end - tail ) * 2 ); /* remove it */
+ /* remove the environment variable */
+ if (f == 0)
+ memmove (hole,
+ tail,
+ (env_end - tail) * sizeof(WCHAR));
else
- Status = STATUS_VARIABLE_NOT_FOUND; /* notingh to remove*/
+ Status = STATUS_VARIABLE_NOT_FOUND;
}
RtlReleasePebLock ();
return Status;
}
-//#endif
NTSTATUS
STDCALL
RtlQueryEnvironmentVariable_U (
- PVOID env,
- UNICODE_STRING *varname,
- UNICODE_STRING *value
+ PVOID Environment,
+ PUNICODE_STRING Name,
+ PUNICODE_STRING Value
)
{
- NTSTATUS Status = STATUS_VARIABLE_NOT_FOUND;
- WCHAR *wcs,*var,*val;
- int varlen, len;
+ NTSTATUS Status;
+ PWSTR wcs;
+ PWSTR var;
+ PWSTR val;
+ int varlen;
+ int len;
- if (!env)
- env = NtCurrentPeb()->ProcessParameters->Environment;
+ DPRINT("RtlQueryEnvironmentVariable_U Environment %p Variable %wZ Value %p\n",
+ Environment, varname, Value);
- if (!env)
- return Status;
+ if (!Environment)
+ Environment = NtCurrentPeb()->ProcessParameters->Environment;
- value->Length = 0;
- if (env == NtCurrentPeb()->ProcessParameters->Environment)
+ if (!Environment)
+ return STATUS_VARIABLE_NOT_FOUND;
+
+ Value->Length = 0;
+ if (Environment == NtCurrentPeb()->ProcessParameters->Environment)
RtlAcquirePebLock();
- wcs = env;
- len = varname->Length / 2;
- while( *wcs )
+ wcs = Environment;
+ len = Name->Length / sizeof(WCHAR);
+ while (*wcs)
{
for (var = wcs++; *wcs && *wcs != L'='; wcs++)
;
varlen = wcs - var;
for (val = ++wcs; *wcs; wcs++)
;
+
if (varlen == len &&
- !_wcsnicmp (var, varname->Buffer, len))
+ !_wcsnicmp (var, Name->Buffer, len))
{
- value->Length = (wcs - val) * sizeof(WCHAR);
- if (value->Length < value->MaximumLength)
+ Value->Length = (wcs - val) * sizeof(WCHAR);
+ if (Value->Length < Value->MaximumLength)
{
- wcscpy (value->Buffer, val);
+ wcscpy (Value->Buffer, val);
+ DPRINT("Value %S\n", val);
Status = STATUS_SUCCESS;
}
else
Status = STATUS_BUFFER_TOO_SMALL;
}
- if (env == NtCurrentPeb()->ProcessParameters->Environment)
+ if (Environment == NtCurrentPeb()->ProcessParameters->Environment)
RtlReleasePebLock ();
return Status;
wcs++;
}
- if (env == NtCurrentPeb()->ProcessParameters->Environment)
+ if (Environment == NtCurrentPeb()->ProcessParameters->Environment)
RtlReleasePebLock ();
- return Status;
+ return STATUS_VARIABLE_NOT_FOUND;
}
/* EOF */
-/* $Id: path.c,v 1.1 2000/02/05 16:08:49 ekohl Exp $
+/* $Id: path.c,v 1.2 2000/02/18 00:49:11 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
/* FUNCTIONS *****************************************************************/
+
+static
+ULONG
+RtlpGetDotSequence (PWSTR p)
+{
+ ULONG Count = 0;
+
+ for (;;)
+ {
+ if (*p == '.')
+ Count++;
+ else if ((*p == '\\' || *p == '\0') && Count)
+ return Count;
+ else
+ return 0;
+ p++;
+ }
+ return 0;
+}
+
+
+static
+VOID
+RtlpEatPath (
+ PWSTR Path
+ )
+{
+ PWSTR p, prev;
+
+ p = Path + 2;
+ prev = p;
+
+ while ((*p) != 0 || ((*p) == L'\\' && (*(p+1)) == 0))
+ {
+ ULONG DotLen;
+
+ DotLen = RtlpGetDotSequence (p+1);
+ DPRINT("DotSequenceLength %u\n", DotLen);
+ DPRINT("prev %S p %S\n",prev,p);
+
+ if (DotLen == 0)
+ {
+ prev = p;
+ do
+ {
+ p++;
+ }
+ while ((*p) != 0 && (*p) != L'\\');
+ }
+ else if (DotLen == 1)
+ {
+ wcscpy (p, p+2);
+ }
+ else
+ {
+ if (DotLen > 2)
+ {
+ int n = DotLen - 2;
+
+ while (n > 0 && prev > (Path + 2))
+ {
+ prev--;
+ if ((*prev) == L'\\')
+ n--;
+ }
+ }
+
+ if (*(p + DotLen + 1) == 0)
+ *(prev + 1) = 0;
+ else
+ wcscpy (prev, p + DotLen + 1);
+ p = prev;
+ if (prev > (Path + 2))
+ {
+ prev--;
+ while ((*prev) != L'\\')
+ {
+ prev--;
+ }
+ }
+ }
+ }
+}
+
+
ULONG
STDCALL
RtlGetLongestNtPathLength (VOID)
PWSTR Buffer
)
{
- DWORD Length;
+ ULONG Length;
PCURDIR cd;
DPRINT ("RtlGetCurrentDirectory %lu %p\n", MaximumLength, Buffer);
RtlAcquirePebLock();
Length = cd->DosPath.Length / sizeof(WCHAR);
- if (cd->DosPath.Buffer[Length - 2] != L':')
+ if (cd->DosPath.Buffer[Length - 1] == L'\\' &&
+ cd->DosPath.Buffer[Length - 2] != L':')
Length--;
- DPRINT ("cd->DosPath.Buffer %S\n", cd->DosPath.Buffer);
+ DPRINT ("cd->DosPath.Buffer %S Length %d\n",
+ cd->DosPath.Buffer, Length);
if (MaximumLength / sizeof(WCHAR) > Length)
{
PUNICODE_STRING name
)
{
- UNICODE_STRING full;
- OBJECT_ATTRIBUTES obj;
- IO_STATUS_BLOCK iosb;
+ UNICODE_STRING full;
+ OBJECT_ATTRIBUTES Attr;
+ IO_STATUS_BLOCK iosb;
PCURDIR cd;
NTSTATUS Status;
- ULONG size;
- HANDLE handle = NULL;
- WCHAR *wcs,*buf = 0;
+ ULONG size;
+ HANDLE handle = NULL;
+ PWSTR wcs;
+ PWSTR buf = 0;
DPRINT ("RtlSetCurrentDirectory %wZ\n", name);
return STATUS_OBJECT_NAME_INVALID;
}
- obj.Length = sizeof(obj);
- obj.RootDirectory = 0;
- obj.ObjectName = &full;
- obj.Attributes = OBJ_CASE_INSENSITIVE | OBJ_INHERIT;
- obj.SecurityDescriptor = 0;
- obj.SecurityQualityOfService = 0;
+ InitializeObjectAttributes (&Attr,
+ &full,
+ OBJ_CASE_INSENSITIVE | OBJ_INHERIT,
+ NULL,
+ NULL);
Status = NtOpenFile (&handle,
SYNCHRONIZE | FILE_TRAVERSE,
- &obj,
+ &Attr,
&iosb,
FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
ULONG
STDCALL
RtlGetFullPathName_U (
- WCHAR *dosname,
+ PWSTR DosName,
ULONG size,
- WCHAR *buf,
- WCHAR **shortname
+ PWSTR buf,
+ PWSTR *FilePart
)
{
WCHAR *wcs, var[4], drive;
DWORD offs, sz, type;
UNICODE_STRING usvar, pfx;
PCURDIR cd;
- NTSTATUS status;
+ NTSTATUS Status;
DPRINT("RtlGetFullPathName_U %S %ld %p %p\n",
- dosname, size, buf, shortname);
+ DosName, size, buf, FilePart);
- if (!dosname || !*dosname)
+ if (!DosName || !*DosName)
return 0;
- len = wcslen (dosname);
+ len = wcslen (DosName);
/* strip trailing spaces */
- while (len && dosname[len - 1] == L' ')
+ while (len && DosName[len - 1] == L' ')
len--;
if (!len)
return 0;
/* strip trailing path separator */
- if (IS_PATH_SEPARATOR(dosname[len - 1]))
+ if (IS_PATH_SEPARATOR(DosName[len - 1]))
len--;
if (!len)
return 0;
- if (shortname)
- *shortname = 0;
+ if (FilePart)
+ *FilePart = L'\0';
memset (buf, 0, size);
CHECKPOINT;
/* check for DOS device name */
- sz = RtlIsDosDeviceName_U (dosname);
+ sz = RtlIsDosDeviceName_U (DosName);
if (sz)
{
offs = sz >> 17;
if (sz + 8 >= size)
return sz + 10;
wcscpy (buf, L"\\\\.\\");
- wcsncat (buf, dosname + offs, sz / 2);
+ wcsncat (buf, DosName + offs, sz / sizeof(WCHAR));
return sz + 8;
}
CHECKPOINT;
- type = RtlDetermineDosPathNameType_U (dosname);
+ type = RtlDetermineDosPathNameType_U (DosName);
RtlAcquirePebLock();
switch (type)
{
case 1: /* \\xxx or \\.xxx */
- case 2: /* x:\xxx */
case 6: /* \\.\xxx */
break;
+ case 2: /* x:\xxx */
+ *DosName = towupper (*DosName);
+ break;
+
case 3: /* x:xxx */
- drive = towupper (*dosname);
- dosname += 2;
+ drive = towupper (*DosName);
+ DosName += 2;
len -= 2;
CHECKPOINT;
if (drive == towupper (cd->DosPath.Buffer[0]))
else
{
CHECKPOINT;
- usvar.Length = 2 * swprintf( var, L"=%c:", drive );
+ usvar.Length = 2 * swprintf (var, L"=%c:", drive);
usvar.MaximumLength = 8;
- usvar.Buffer = var;
- pfx.Length = 0;
- pfx.MaximumLength = size;
- pfx.Buffer = buf;
- status = RtlQueryEnvironmentVariable_U( 0, &usvar, &pfx );
+ usvar.Buffer = var;
+ pfx.Length = 0;
+ pfx.MaximumLength = size;
+ pfx.Buffer = buf;
+ Status = RtlQueryEnvironmentVariable_U (NULL,
+ &usvar,
+ &pfx);
CHECKPOINT;
- if (!NT_SUCCESS(status))
+ if (!NT_SUCCESS(Status))
{
CHECKPOINT;
- if (status == STATUS_BUFFER_TOO_SMALL)
+ if (Status == STATUS_BUFFER_TOO_SMALL)
return pfx.Length + len * 2 + 2;
- swprintf( buf, L"%c:\\", drive );
+ swprintf (buf, L"%c:\\", drive);
}
else
{
CHECKPOINT;
- if( pfx.Length > 6 )
+ if (pfx.Length > 6)
{
CHECKPOINT;
- buf[ pfx.Length / 2 ] = L'\\';
+ buf[pfx.Length / 2] = L'\\';
pfx.Length += 2;
}
}
case 5: /* xxx */
wcscpy (buf, cd->DosPath.Buffer);
- if (*dosname == L'.')
- {
- dosname += 2;
- len -= 2;
- }
break;
case 7: /* \\. */
return 0;
}
-CHECKPOINT;
+ DPRINT("buf \'%S\' DosName \'%S\'\n", buf, DosName);
/* add dosname to prefix */
- wcsncat (buf, dosname, len);
+ wcsncat (buf, DosName, len);
-CHECKPOINT;
+ CHECKPOINT;
/* replace slashes */
- for (wcs = buf; *wcs; wcs++ )
+ for (wcs = buf; *wcs; wcs++)
if (*wcs == L'/')
*wcs = L'\\';
+ RtlpEatPath (buf);
+
len = wcslen (buf);
- /* find shortname */
- if (shortname)
+ /* find file part */
+ if (FilePart)
{
for (wcs = buf + len - 1; wcs >= buf; wcs--)
{
if (*wcs == L'\\')
{
- *shortname = wcs + 1;
+ *FilePart = wcs + 1;
break;
}
}
RtlDosPathNameToNtPathName_U (
PWSTR dosname,
PUNICODE_STRING ntname,
- PWSTR *shortname,
+ PWSTR *FilePart,
PCURDIR nah
)
{
- UNICODE_STRING us;
+ UNICODE_STRING us;
PCURDIR cd;
- DWORD type, size;
- WCHAR *buf = 0, fullname[517];
- int offs, len;
+ ULONG Type;
+ ULONG Size;
+ ULONG Length;
+ ULONG Offset;
+ WCHAR fullname[2*MAX_PATH];
+ PWSTR Buffer = NULL;
- RtlAcquirePebLock();
+ RtlAcquirePebLock ();
- RtlInitUnicodeString( &us, dosname );
- if( us.Length > 8 )
+ RtlInitUnicodeString (&us, dosname);
+ if (us.Length > 8)
{
- buf = us.Buffer;
+ Buffer = us.Buffer;
/* check for "\\?\" - allows to use very long filenames ( up to 32k ) */
- if (buf[0] == L'\\' && buf[1] == L'\\' && buf[2] == L'?' && buf[3] == L'\\')
+ if (Buffer[0] == L'\\' && Buffer[1] == L'\\' &&
+ Buffer[2] == L'?' && Buffer[3] == L'\\')
{
// if( f_77F68606( &us, ntname, shortname, nah ) )
-// goto out;
- buf = 0;
- goto fail;
+// {
+// RtlReleasePebLock ();
+// return TRUE;
+// }
+ Buffer = NULL;
+ RtlReleasePebLock ();
+ return FALSE;
}
}
- buf = RtlAllocateHeap (RtlGetProcessHeap (),
- 0,
- sizeof( fullname ) + MAX_PFX_SIZE );
- if (!buf)
- goto fail;
+ Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
+ 0,
+ sizeof( fullname ) + MAX_PFX_SIZE);
+ if (Buffer == NULL)
+ {
+ RtlReleasePebLock ();
+ return FALSE;
+ }
- size = RtlGetFullPathName_U( dosname, sizeof( fullname ), fullname, shortname );
- if( !size || size > 0x208 )
- goto fail;
+ Size = RtlGetFullPathName_U (dosname,
+ sizeof(fullname),
+ fullname,
+ FilePart);
+ if (Size == 0 || Size > MAX_PATH * sizeof(WCHAR))
+ {
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ Buffer);
+ RtlReleasePebLock ();
+ return FALSE;
+ }
/* Set NT prefix */
- offs = 0;
- wcscpy (buf, L"\\??\\");
+ Offset = 0;
+ wcscpy (Buffer, L"\\??\\");
- type = RtlDetermineDosPathNameType_U( fullname );
- switch (type)
+ Type = RtlDetermineDosPathNameType_U (fullname);
+ switch (Type)
{
case 1:
- wcscat( buf, L"UNC\\" );
- offs = 2;
+ wcscat (Buffer, L"UNC\\");
+ Offset = 2;
break; /* \\xxx */
case 6:
- offs = 4;
+ Offset = 4;
break; /* \\.\xxx */
}
- wcscat( buf, fullname + offs );
- len = wcslen( buf );
+ wcscat (Buffer, fullname + Offset);
+ Length = wcslen (Buffer);
- /* Set NT filename */
- ntname->Length = len * 2;
- ntname->MaximumLength = sizeof( fullname ) + MAX_PFX_SIZE;
- ntname->Buffer = buf;
+ /* set NT filename */
+ ntname->Length = Length * sizeof(WCHAR);
+ ntname->MaximumLength = sizeof(fullname) + MAX_PFX_SIZE;
+ ntname->Buffer = Buffer;
- /* Set shortname if possible */
- if( shortname && *shortname )
- *shortname = buf + len - wcslen( *shortname );
+ /* set pointer to file part if possible */
+ if (FilePart && *FilePart)
+ *FilePart = Buffer + Length - wcslen (*FilePart);
/* Set name and handle structure if possible */
- if( nah )
+ if (nah)
{
- memset( nah, 0, sizeof(CURDIR));
+ memset (nah, 0, sizeof(CURDIR));
cd = &(NtCurrentPeb ()->ProcessParameters->CurrentDirectory);
- if (type == 5 && cd->Handle &&
+ if (Type == 5 && cd->Handle &&
!_wcsnicmp (cd->DosPath.Buffer, fullname, cd->DosPath.Length / 2))
{
- len = (( cd->DosPath.Length / 2 ) - offs ) + ( ( type == 1 ) ? 8 : 4 );
- nah->DosPath.Buffer = buf + len;
- nah->DosPath.Length = ntname->Length - ( len * 2 );
+ Length = ((cd->DosPath.Length / sizeof(WCHAR)) - Offset) + ((Type == 1) ? 8 : 4);
+ nah->DosPath.Buffer = Buffer + Length;
+ nah->DosPath.Length = ntname->Length - (Length * sizeof(WCHAR));
nah->DosPath.MaximumLength = nah->DosPath.Length;
- nah->Handle = cd->Handle;
+ nah->Handle = cd->Handle;
}
}
-/* out:; */
- RtlReleasePebLock();
- return TRUE;
-fail:;
- if( buf )
- RtlFreeHeap (RtlGetProcessHeap (), 0, buf );
RtlReleasePebLock();
- return FALSE;
+
+ return TRUE;
}
WCHAR *ext,
ULONG buf_sz,
WCHAR *buffer,
- WCHAR **shortname
+ PWSTR *FilePart
)
{
- DWORD type;
- ULONG len = 0;
- WCHAR *full_name,*wcs,*path;
-
- type = RtlDetermineDosPathNameType_U( name );
-
- if( type != 5 )
- {
- if( RtlDoesFileExists_U( name ) )
- {
- len = RtlGetFullPathName_U( name, buf_sz, buffer, shortname );
- }
- }
- else
- {
- len = wcslen( sp );
- len += wcslen( name );
- if( wcschr( name, L'.' ) ) ext = 0;
- if( ext ) len += wcslen( ext );
-
- full_name = (WCHAR*)RtlAllocateHeap (RtlGetProcessHeap (), 0, ( len + 1 ) * 2 );
- len = 0;
- if( full_name )
- {
- path = sp;
- while( *path )
- {
- wcs = full_name;
- while( *path && *path != L';' ) *wcs++ = *path++;
- if( *path ) path++;
- if( wcs != full_name && *(wcs - 1) != L'\\' ) *wcs++ = L'\\';
- wcscpy( wcs, name );
- if( ext ) wcscat( wcs, ext );
- if( RtlDoesFileExists_U( full_name ) )
- {
- len = RtlGetFullPathName_U( full_name, buf_sz, buffer, shortname );
- break;
- }
- }
- RtlFreeHeap (RtlGetProcessHeap (), 0, full_name );
- }
- }
- return len;
+ ULONG Type;
+ ULONG Length = 0;
+ PWSTR full_name;
+ PWSTR wcs;
+ PWSTR path;
+
+ Type = RtlDetermineDosPathNameType_U (name);
+
+ if (Type == 5)
+ {
+ Length = wcslen (sp);
+ Length += wcslen (name);
+ if (wcschr (name, L'.'))
+ ext = NULL;
+ if (ext != NULL)
+ Length += wcslen (ext);
+
+ full_name = (WCHAR*)RtlAllocateHeap (RtlGetProcessHeap (),
+ 0,
+ (Length + 1) * sizeof(WCHAR));
+ Length = 0;
+ if (full_name != NULL)
+ {
+ path = sp;
+ while (*path)
+ {
+ wcs = full_name;
+ while (*path && *path != L';')
+ *wcs++ = *path++;
+ if (*path)
+ path++;
+ if (wcs != full_name && *(wcs - 1) != L'\\')
+ *wcs++ = L'\\';
+ wcscpy (wcs, name);
+ if (ext)
+ wcscat (wcs, ext);
+ if (RtlDoesFileExists_U (full_name))
+ {
+ Length = RtlGetFullPathName_U (full_name,
+ buf_sz,
+ buffer,
+ FilePart);
+ break;
+ }
+ }
+
+ RtlFreeHeap (RtlGetProcessHeap (),
+ 0,
+ full_name);
+ }
+ }
+ else if (RtlDoesFileExists_U (name))
+ {
+ Length = RtlGetFullPathName_U (name,
+ buf_sz,
+ buffer,
+ FilePart);
+ }
+
+ return Length;
}
BOOLEAN
STDCALL
RtlIsNameLegalDOS8Dot3 (
- PUNICODE_STRING us,
- PANSI_STRING as,
- PBOOLEAN pb
+ PUNICODE_STRING UnicodeName,
+ PANSI_STRING AnsiName,
+ PBOOLEAN SpacesFound
)
{
- ANSI_STRING *name = as,as1;
- char buf[12],*str;
+ PANSI_STRING name = AnsiName;
+ ANSI_STRING DummyString;
+ CHAR Buffer[12];
+ char *str;
+ ULONG Length;
+ ULONG i;
NTSTATUS Status;
- BOOLEAN have_space = FALSE;
- BOOLEAN have_point = FALSE;
- ULONG len,i;
+ BOOLEAN HasSpace = FALSE;
+ BOOLEAN HasDot = FALSE;
- if (us->Length > 24)
+ if (UnicodeName->Length > 24)
return FALSE; /* name too long */
if (!name)
{
- name = &as1;
+ name = &DummyString;
name->Length = 0;
name->MaximumLength = 12;
- name->Buffer = buf;
+ name->Buffer = Buffer;
}
Status = RtlUpcaseUnicodeStringToCountedOemString (name,
- us,
+ UnicodeName,
FALSE);
if (!NT_SUCCESS(Status))
return FALSE;
- len = name->Length;
+ Length = name->Length;
str = name->Buffer;
- if (!(len == 1 && *str == '.') &&
- !(len == 2 && *(short*)(str) == 0x2E2E))
+ if (!(Length == 1 && *str == '.') &&
+ !(Length == 2 && *str == '.' && *(str + 1) == '.'))
{
- for (i = 0; i < len; i++, str++)
+ for (i = 0; i < Length; i++, str++)
{
switch (*str)
{
case ' ':
- have_space = TRUE;
+ HasSpace = TRUE;
break;
case '.':
- if ((have_point) || /* two points */
+ if ((HasDot) || /* two points */
(!i) || /* point is first char */
- (i + 1 == len) || /* point is last char */
- (len - i > 4)) /* more than 3 chars of extension */
+ (i + 1 == Length) ||/* point is last char */
+ (Length - i > 4)) /* more than 3 chars of extension */
return FALSE;
- have_point = TRUE;
+ HasDot = TRUE;
break;
}
}
}
- if (pb)
- *pb = have_space;
+ if (SpacesFound)
+ *SpacesFound = HasSpace;
return TRUE;
}
BOOLEAN
STDCALL
RtlDoesFileExists_U (
- PWSTR FileName
+ IN PWSTR FileName
)
{
UNICODE_STRING NtFileName;
- OBJECT_ATTRIBUTES obj;
+ OBJECT_ATTRIBUTES Attr;
NTSTATUS Status;
CURDIR CurDir;
PWSTR Buffer;
else
CurDir.Handle = 0;
- obj.Length = sizeof(obj);
- obj.RootDirectory = CurDir.Handle;
- obj.ObjectName = &NtFileName;
- obj.Attributes = OBJ_CASE_INSENSITIVE;
- obj.SecurityDescriptor = 0;
- obj.SecurityQualityOfService = 0;
+ InitializeObjectAttributes (&Attr,
+ &NtFileName,
+ OBJ_CASE_INSENSITIVE,
+ CurDir.Handle,
+ NULL);
- Status = NtQueryAttributesFile (&obj, NULL);
+ Status = NtQueryAttributesFile (&Attr, NULL);
- RtlFreeHeap (RtlGetProcessHeap(),
+ RtlFreeHeap (RtlGetProcessHeap (),
0,
Buffer);
-/* $Id: ppb.c,v 1.2 2000/02/14 14:13:33 dwelch Exp $
+/* $Id: ppb.c,v 1.3 2000/02/18 00:49:11 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: lib/ntdll/rtl/ppb.c
- * PURPOSE: Process functions
+ * PURPOSE: Process parameters functions
* PROGRAMMER: Ariadne ( ariadne@xs4all.nl)
* UPDATE HISTORY:
* Created 01/11/98
#define NDEBUG
#include <ntdll/ntdll.h>
+/* MACROS ****************************************************************/
+
+#define NORMALIZE(x,addr) {if(x) x=(VOID*)((ULONG)(x)+(ULONG)(addr));}
+#define DENORMALIZE(x,addr) {if(x) x=(VOID*)((ULONG)(x)-(ULONG)(addr));}
+#define ALIGN(x,align) (((ULONG)(x)+(align)-1UL)&(~((align)-1UL)))
+
+
/* FUNCTIONS ****************************************************************/
VOID STDCALL RtlAcquirePebLock(VOID)
}
+static
+inline
+VOID
+RtlpCopyParameterString (
+ PWCHAR *Ptr,
+ PUNICODE_STRING Destination,
+ PUNICODE_STRING Source,
+ ULONG Size
+ )
+{
+ Destination->Length = Source->Length;
+ Destination->MaximumLength = Size ? Size : Source->MaximumLength;
+ Destination->Buffer = (PWCHAR)(*Ptr);
+ if (Source->Length)
+ memmove (Destination->Buffer, Source->Buffer, Source->Length);
+ Destination->Buffer[Destination->Length / sizeof(WCHAR)] = 0;
+ *Ptr += Destination->MaximumLength;
+}
+
+
NTSTATUS
STDCALL
RtlCreateProcessParameters (
- PRTL_USER_PROCESS_PARAMETERS *Ppb,
+ PRTL_USER_PROCESS_PARAMETERS *Ppb,
PUNICODE_STRING CommandLine,
PUNICODE_STRING LibraryPath,
PUNICODE_STRING CurrentDirectory,
PUNICODE_STRING Title,
PUNICODE_STRING Desktop,
PUNICODE_STRING Reserved,
- PVOID Reserved2
+ PUNICODE_STRING Reserved2
)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG RegionSize = 0;
ULONG DataSize = 0;
PWCHAR Dest;
+ UNICODE_STRING EmptyString;
+ HANDLE CurrentDirectoryHandle;
+ ULONG ConsoleFlags;
DPRINT ("RtlCreateProcessParameters\n");
RtlAcquirePebLock ();
+ EmptyString.Length = 0;
+ EmptyString.MaximumLength = sizeof(WCHAR);
+ EmptyString.Buffer = L"";
+
+ if (NtCurrentPeb()->ProcessParameters)
+ {
+ if (LibraryPath == NULL)
+ LibraryPath = &NtCurrentPeb()->ProcessParameters->LibraryPath;
+ if (Environment == NULL)
+ Environment = NtCurrentPeb()->ProcessParameters->Environment;
+ if (CurrentDirectory == NULL)
+ CurrentDirectory = &NtCurrentPeb()->ProcessParameters->CurrentDirectory.DosPath;
+ CurrentDirectoryHandle = NtCurrentPeb()->ProcessParameters->CurrentDirectory.Handle;
+ ConsoleFlags = NtCurrentPeb()->ProcessParameters->ConsoleFlags;
+ }
+ else
+ {
+ if (LibraryPath == NULL)
+ LibraryPath = &EmptyString;
+ if (CurrentDirectory == NULL)
+ CurrentDirectory = &EmptyString;
+ CurrentDirectoryHandle = NULL;
+ ConsoleFlags = 0;
+ }
+
+ if (ImageName == NULL)
+ ImageName = CommandLine;
+ if (Title == NULL)
+ Title = &EmptyString;
+ if (Desktop == NULL)
+ Desktop = &EmptyString;
+ if (Reserved == NULL)
+ Reserved = &EmptyString;
+ if (Reserved2 == NULL)
+ Reserved2 = &EmptyString;
+
/* size of process parameter block */
DataSize = sizeof (RTL_USER_PROCESS_PARAMETERS);
- /* size of (reserved) buffer */
- DataSize += (256 * sizeof(WCHAR));
-
/* size of current directory buffer */
DataSize += (MAX_PATH * sizeof(WCHAR));
/* add string lengths */
- if (LibraryPath != NULL)
- DataSize += (LibraryPath->Length + sizeof(WCHAR));
-
- if (CommandLine != NULL)
- DataSize += (CommandLine->Length + sizeof(WCHAR));
-
- if (ImageName != NULL)
- DataSize += (ImageName->Length + sizeof(WCHAR));
-
- if (Title != NULL)
- DataSize += (Title->Length + sizeof(WCHAR));
-
- if (Desktop != NULL)
- DataSize += (Desktop->Length + sizeof(WCHAR));
-
- if (Reserved != NULL)
- DataSize += (Reserved->Length + sizeof(WCHAR));
+ DataSize += ALIGN(LibraryPath->MaximumLength, sizeof(ULONG));
+ DataSize += ALIGN(CommandLine->Length, sizeof(ULONG));
+ DataSize += ALIGN(ImageName->Length, sizeof(ULONG));
+ DataSize += ALIGN(Title->MaximumLength, sizeof(ULONG));
+ DataSize += ALIGN(Desktop->MaximumLength, sizeof(ULONG));
+ DataSize += ALIGN(Reserved->MaximumLength, sizeof(ULONG));
+ DataSize += ALIGN(Reserved2->MaximumLength, sizeof(ULONG));
/* Calculate the required block size */
RegionSize = ROUNDUP(DataSize, PAGESIZE);
Param->TotalSize = RegionSize;
Param->DataSize = DataSize;
- Param->Flags = TRUE;
+ Param->Flags = PPF_NORMALIZED;
Param->Environment = Environment;
-// Param->Unknown1 =
-// Param->Unknown2 =
-// Param->Unknown3 =
-// Param->Unknown4 =
+ Param->CurrentDirectory.Handle = CurrentDirectoryHandle;
+ Param->ConsoleFlags = ConsoleFlags;
+
+ Dest = (PWCHAR)(((PBYTE)Param) + sizeof(RTL_USER_PROCESS_PARAMETERS));
/* copy current directory */
- Dest = (PWCHAR)(((PBYTE)Param) +
- sizeof(RTL_USER_PROCESS_PARAMETERS));
-
- Param->CurrentDirectory.DosPath.Buffer = Dest;
- Param->CurrentDirectory.DosPath.MaximumLength = MAX_PATH * sizeof(WCHAR);
- if (CurrentDirectory != NULL)
- {
- Param->CurrentDirectory.DosPath.Length = CurrentDirectory->Length;
- memcpy(Dest,
- CurrentDirectory->Buffer,
- CurrentDirectory->Length);
- Dest = (PWCHAR)(((PBYTE)Dest) + CurrentDirectory->Length);
- }
-
- Dest = (PWCHAR)(((PBYTE)Param) + sizeof(RTL_USER_PROCESS_PARAMETERS) +
- /* (256 * sizeof(WCHAR)) + */ (MAX_PATH * sizeof(WCHAR)));
-
- /* copy library path */
- Param->LibraryPath.Buffer = Dest;
- if (LibraryPath != NULL)
- {
- Param->LibraryPath.Length = LibraryPath->Length;
- memcpy (Dest,
- LibraryPath->Buffer,
- LibraryPath->Length);
- Dest = (PWCHAR)(((PBYTE)Dest) + LibraryPath->Length);
- }
- Param->LibraryPath.MaximumLength = Param->LibraryPath.Length +
- sizeof(WCHAR);
- *Dest = 0;
- Dest++;
-
- /* copy command line */
- Param->CommandLine.Buffer = Dest;
- if (CommandLine != NULL)
- {
- Param->CommandLine.Length = CommandLine->Length;
- memcpy (Dest,
- CommandLine->Buffer,
- CommandLine->Length);
- Dest = (PWCHAR)(((PBYTE)Dest) + CommandLine->Length);
- }
- Param->CommandLine.MaximumLength = Param->CommandLine.Length + sizeof(WCHAR);
- *Dest = 0;
- Dest++;
-
- /* copy image name */
- Param->ImageName.Buffer = Dest;
- if (ImageName != NULL)
- {
- Param->ImageName.Length = ImageName->Length;
- memcpy (Dest,
- ImageName->Buffer,
- ImageName->Length);
- Dest = (PWCHAR)(((PBYTE)Dest) + ImageName->Length);
- }
- Param->ImageName.MaximumLength = Param->ImageName.Length + sizeof(WCHAR);
- *Dest = 0;
- Dest++;
+ RtlpCopyParameterString (&Dest,
+ &Param->CurrentDirectory.DosPath,
+ CurrentDirectory,
+ MAX_PATH * sizeof(WCHAR));
- /* copy title */
- Param->Title.Buffer = Dest;
- if (Title != NULL)
+ /* make sure the current directory has a trailing backslash */
+ if (Param->CurrentDirectory.DosPath.Length > 0)
{
- Param->Title.Length = Title->Length;
- memcpy (Dest,
- Title->Buffer,
- Title->Length);
- Dest = (PWCHAR)(((PBYTE)Dest) + Title->Length);
+ ULONG Length;
+
+ Length = Param->CurrentDirectory.DosPath.Length / sizeof(WCHAR);
+ if (Param->CurrentDirectory.DosPath.Buffer[Length-1] != L'\\')
+ {
+ Param->CurrentDirectory.DosPath.Buffer[Length] = L'\\';
+ Param->CurrentDirectory.DosPath.Buffer[Length + 1] = 0;
+ Param->CurrentDirectory.DosPath.Length += sizeof(WCHAR);
+ }
}
- Param->Title.MaximumLength = Param->Title.Length + sizeof(WCHAR);
- *Dest = 0;
- Dest++;
+
+ /* copy library path */
+ RtlpCopyParameterString (&Dest,
+ &Param->LibraryPath,
+ LibraryPath,
+ 0);
+
+ /* copy command line */
+ RtlpCopyParameterString (&Dest,
+ &Param->CommandLine,
+ CommandLine,
+ CommandLine->Length + sizeof(WCHAR));
+
+ /* copy image name */
+ RtlpCopyParameterString (&Dest,
+ &Param->ImageName,
+ ImageName,
+ ImageName->Length + sizeof(WCHAR));
+
+ /* copy title */
+ RtlpCopyParameterString (&Dest,
+ &Param->Title,
+ Title,
+ 0);
/* copy desktop */
- Param->Desktop.Buffer = Dest;
- if (Desktop != NULL)
- {
- Param->Desktop.Length = Desktop->Length;
- memcpy (Dest,
- Desktop->Buffer,
- Desktop->Length);
- Dest = (PWCHAR)(((PBYTE)Dest) + Desktop->Length);
- }
- Param->Desktop.MaximumLength = Param->Desktop.Length + sizeof(WCHAR);
- *Dest = 0;
- Dest++;
-
- RtlDeNormalizeProcessParams (Param);
- *Ppb = Param;
- RtlReleasePebLock ();
-
+ RtlpCopyParameterString (&Dest,
+ &Param->Desktop,
+ Desktop,
+ 0);
+
+ RtlpCopyParameterString (&Dest,
+ &Param->ShellInfo,
+ Reserved,
+ 0);
+
+ RtlpCopyParameterString (&Dest,
+ &Param->RuntimeData,
+ Reserved2,
+ 0);
+
+ RtlDeNormalizeProcessParams (Param);
+ *Ppb = Param;
+ RtlReleasePebLock ();
+
+ return STATUS_SUCCESS;
}
-VOID STDCALL RtlDestroyProcessParameters (PRTL_USER_PROCESS_PARAMETERS Ppb)
+VOID
+STDCALL
+RtlDestroyProcessParameters (
+ PRTL_USER_PROCESS_PARAMETERS Ppb
+ )
{
- ULONG RegionSize = 0;
+ ULONG RegionSize = 0;
- NtFreeVirtualMemory (NtCurrentProcess (),
- (PVOID)Ppb,
- &RegionSize,
- MEM_RELEASE);
+ NtFreeVirtualMemory (NtCurrentProcess (),
+ (PVOID)Ppb,
+ &RegionSize,
+ MEM_RELEASE);
}
/*
* denormalize process parameters (Pointer-->Offset)
*/
-VOID
+PRTL_USER_PROCESS_PARAMETERS
STDCALL
RtlDeNormalizeProcessParams (
- PRTL_USER_PROCESS_PARAMETERS Ppb
+ PRTL_USER_PROCESS_PARAMETERS Params
)
{
- if (Ppb == NULL)
- return;
-
- if (Ppb->Flags == FALSE)
- return;
-
- if (Ppb->CurrentDirectory.DosPath.Buffer != NULL)
- {
- Ppb->CurrentDirectory.DosPath.Buffer =
- (PWSTR)((ULONG)Ppb->CurrentDirectory.DosPath.Buffer -
- (ULONG)Ppb);
- }
-
- if (Ppb->LibraryPath.Buffer != NULL)
- {
- Ppb->LibraryPath.Buffer =
- (PWSTR)((ULONG)Ppb->LibraryPath.Buffer -
- (ULONG)Ppb);
- }
-
- if (Ppb->CommandLine.Buffer != NULL)
+ if (Params && (Params->Flags & PPF_NORMALIZED))
{
- Ppb->CommandLine.Buffer =
- (PWSTR)((ULONG)Ppb->CommandLine.Buffer -
- (ULONG)Ppb);
+ DENORMALIZE (Params->CurrentDirectory.DosPath.Buffer, Params);
+ DENORMALIZE (Params->LibraryPath.Buffer, Params);
+ DENORMALIZE (Params->CommandLine.Buffer, Params);
+ DENORMALIZE (Params->ImageName.Buffer, Params);
+ DENORMALIZE (Params->Title.Buffer, Params);
+ DENORMALIZE (Params->Desktop.Buffer, Params);
+ DENORMALIZE (Params->ShellInfo.Buffer, Params);
+ DENORMALIZE (Params->RuntimeData.Buffer, Params);
+
+ Params->Flags &= ~PPF_NORMALIZED;
}
- if (Ppb->ImageName.Buffer != NULL)
- {
- Ppb->ImageName.Buffer =
- (PWSTR)((ULONG)Ppb->ImageName.Buffer -
- (ULONG)Ppb);
- }
-
- if (Ppb->Title.Buffer != NULL)
- {
- Ppb->Title.Buffer =
- (PWSTR)((ULONG)Ppb->Title.Buffer -
- (ULONG)Ppb);
- }
-
- if (Ppb->Desktop.Buffer != NULL)
- {
- Ppb->Desktop.Buffer =
- (PWSTR)((ULONG)Ppb->Desktop.Buffer -
- (ULONG)Ppb);
- }
-
- Ppb->Flags = FALSE;
+ return Params;
}
/*
* normalize process parameters (Offset-->Pointer)
*/
-VOID STDCALL RtlNormalizeProcessParams (PRTL_USER_PROCESS_PARAMETERS Ppb)
+PRTL_USER_PROCESS_PARAMETERS
+STDCALL
+RtlNormalizeProcessParams (
+ PRTL_USER_PROCESS_PARAMETERS Params)
{
- if (Ppb == NULL)
- return;
-
- if (Ppb->Flags == TRUE)
- return;
-
- if (Ppb->CurrentDirectory.DosPath.Buffer != NULL)
- {
- Ppb->CurrentDirectory.DosPath.Buffer =
- (PWSTR)((ULONG)Ppb->CurrentDirectory.DosPath.Buffer +
- (ULONG)Ppb);
- }
-
- if (Ppb->LibraryPath.Buffer != NULL)
- {
- Ppb->LibraryPath.Buffer =
- (PWSTR)((ULONG)Ppb->LibraryPath.Buffer +
- (ULONG)Ppb);
- }
-
- if (Ppb->CommandLine.Buffer != NULL)
- {
- Ppb->CommandLine.Buffer =
- (PWSTR)((ULONG)Ppb->CommandLine.Buffer +
- (ULONG)Ppb);
- }
-
- if (Ppb->ImageName.Buffer != NULL)
- {
- Ppb->ImageName.Buffer =
- (PWSTR)((ULONG)Ppb->ImageName.Buffer +
- (ULONG)Ppb);
- }
-
- if (Ppb->Title.Buffer != NULL)
- {
- Ppb->Title.Buffer =
- (PWSTR)((ULONG)Ppb->Title.Buffer +
- (ULONG)Ppb);
- }
-
- if (Ppb->Desktop.Buffer != NULL)
- {
- Ppb->Desktop.Buffer =
- (PWSTR)((ULONG)Ppb->Desktop.Buffer +
- (ULONG)Ppb);
- }
-
- Ppb->Flags = TRUE;
+ if (Params && !(Params->Flags & PPF_NORMALIZED))
+ {
+ NORMALIZE (Params->CurrentDirectory.DosPath.Buffer, Params);
+ NORMALIZE (Params->LibraryPath.Buffer, Params);
+ NORMALIZE (Params->CommandLine.Buffer, Params);
+ NORMALIZE (Params->ImageName.Buffer, Params);
+ NORMALIZE (Params->Title.Buffer, Params);
+ NORMALIZE (Params->Desktop.Buffer, Params);
+ NORMALIZE (Params->ShellInfo.Buffer, Params);
+ NORMALIZE (Params->RuntimeData.Buffer, Params);
+
+ Params->Flags |= PPF_NORMALIZED;
+ }
+
+ return Params;
}
+
+/* EOF */
-/* $Id: process.c,v 1.13 2000/02/14 14:13:33 dwelch Exp $
+/* $Id: process.c,v 1.14 2000/02/18 00:49:11 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
ULONG PpbSize;
ULONG BytesWritten;
ULONG Offset;
-
+ PVOID ParentEnv = NULL;
+ PVOID EnvPtr = NULL;
+ ULONG EnvSize = 0;
+
+ /* create the Environment */
+ if (Ppb->Environment != NULL)
+ ParentEnv = Ppb->Environment;
+ else if (NtCurrentPeb()->ProcessParameters->Environment != NULL)
+ ParentEnv = NtCurrentPeb()->ProcessParameters->Environment;
+
+ if (ParentEnv != NULL)
+ {
+ MEMORY_BASIC_INFORMATION MemInfo;
+
+ Status = NtQueryVirtualMemory (NtCurrentProcess (),
+ ParentEnv,
+ MemoryBasicInformation,
+ &MemInfo,
+ sizeof(MEMORY_BASIC_INFORMATION),
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+ EnvSize = MemInfo.RegionSize;
+ }
+ DPRINT("EnvironmentSize %ld\n", EnvSize);
+
+ /* allocate and initialize new environment block */
+ if (EnvSize != 0)
+ {
+ Status = NtAllocateVirtualMemory(ProcessHandle,
+ &EnvPtr,
+ 0,
+ &EnvSize,
+ MEM_COMMIT,
+ PAGE_READWRITE);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+
+ NtWriteVirtualMemory(ProcessHandle,
+ EnvPtr,
+ ParentEnv,
+ EnvSize,
+ &BytesWritten);
+ }
+
/* create the PPB */
PpbBase = (PVOID)PEB_STARTUPINFO;
PpbSize = Ppb->TotalSize;
}
DPRINT("Ppb->TotalSize %x\n", Ppb->TotalSize);
+
+ /* write process parameters block*/
NtWriteVirtualMemory(ProcessHandle,
PpbBase,
Ppb,
Ppb->TotalSize,
&BytesWritten);
-
+
+ /* write pointer to environment */
+ Offset = FIELD_OFFSET(RTL_USER_PROCESS_PARAMETERS, Environment);
+ NtWriteVirtualMemory(ProcessHandle,
+ (PVOID)(PpbBase + Offset),
+ &EnvPtr,
+ sizeof(EnvPtr),
+ &BytesWritten);
+
+ /* write pointer to process parameter block */
Offset = FIELD_OFFSET(PEB, ProcessParameters);
-
NtWriteVirtualMemory(ProcessHandle,
(PVOID)(PEB_BASE + Offset),
&PpbBase,
HANDLE hThread;
NTSTATUS Status;
LPTHREAD_START_ROUTINE lpStartAddress = NULL;
- WCHAR TempCommandLine[256];
- PVOID BaseAddress;
- LARGE_INTEGER SectionOffset;
- ULONG InitialViewSize;
+// WCHAR TempCommandLine[256];
+// PVOID BaseAddress;
+// LARGE_INTEGER SectionOffset;
+// ULONG InitialViewSize;
PROCESS_BASIC_INFORMATION ProcessBasicInfo;
ULONG retlen;
- DWORD len = 0;
+// DWORD len = 0;
DPRINT("CreateProcessW(CommandLine '%w')\n", CommandLine->Buffer);
-/* $Id: init.c,v 1.10 2000/02/13 16:05:19 dwelch Exp $
+/* $Id: init.c,v 1.11 2000/02/18 00:51:03 ekohl Exp $
*
* init.c - Session Manager initialization
*
UNICODE_STRING UnicodeString;
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING CmdLineW;
+ UNICODE_STRING CurrentDirectoryW;
PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
+ UNICODE_STRING EnvVariable;
+ UNICODE_STRING EnvValue;
/* Create the "\SmApiPort" object (LPC) */
RtlInitUnicodeString (&UnicodeString,
DisplayString (L"SM: System Environment created\n");
#endif
+ RtlInitUnicodeString (&EnvVariable,
+ L"OS");
+ RtlInitUnicodeString (&EnvValue,
+ L"Reactos 0.0.15");
+
+ RtlSetEnvironmentVariable (SmSystemEnvironment,
+ &EnvVariable,
+ &EnvValue);
+
// RtlSetCurrentEnvironment (SmSystemEnvironment,
// NULL);
-
+
#ifndef NDEBUG
DisplayString (L"System Environment set\n");
#endif
RtlDestroyProcessParameters (ProcessParameters);
#endif
-
- /* Start the simple shell (shell.exe) */
- DisplayString (L"SM: Executing shell\n");
- RtlInitUnicodeString (&UnicodeString,
- L"\\??\\C:\\reactos\\system32\\shell.exe");
+
+ /* Start the simple shell (shell.exe) */
+ DisplayString (L"SM: Executing shell\n");
+ RtlInitUnicodeString (&UnicodeString,
+ L"\\??\\C:\\reactos\\system32\\shell.exe");
#if 0
/* Start the logon process (winlogon.exe) */
RtlInitUnicodeString (&CmdLineW,
L"\\??\\C:\\reactos\\system32\\winlogon.exe");
#endif
+ /* initialize current directory (trailing backslash!!)*/
+ RtlInitUnicodeString (&CurrentDirectoryW,
+ L"C:\\reactos\\");
+
RtlCreateProcessParameters (&ProcessParameters,
&UnicodeString,
NULL,
+ &CurrentDirectoryW,
NULL,
- NULL,
- NULL,
+ SmSystemEnvironment,
NULL,
NULL,
NULL,
projects / reactos.git / commitdiff