[ion] 54274: [KERNEL32]: Rewrite (in some cases, simply clean-up) environment handling functions for better string handling, error codes, and performance. Part of ongoing kernel32 work.

Author: ion
Date: Sun Oct 30 01:07:09 2011
New Revision: 54274

URL: http://svn.reactos.org/svn/reactos?rev=54274&view=rev
Log:
[KERNEL32]: Rewrite (in some cases, simply clean-up) environment handling functions for
better string handling, error codes, and performance. Part of ongoing kernel32 work.

Modified:
    trunk/reactos/dll/win32/kernel32/client/environ.c

Modified: trunk/reactos/dll/win32/kernel32/client/environ.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/kernel32/client/…
==============================================================================
--- trunk/reactos/dll/win32/kernel32/client/environ.c [iso-8859-1] (original)
+++ trunk/reactos/dll/win32/kernel32/client/environ.c [iso-8859-1] Sun Oct 30 01:07:09
2011
@@ -24,489 +24,506 @@
  */
 DWORD
 WINAPI
-GetEnvironmentVariableA (
-	LPCSTR	lpName,
-	LPSTR	lpBuffer,
-	DWORD	nSize
-	)
-{
-	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 = (USHORT)nSize;
-	VarValue.Buffer = lpBuffer;
-
-	/* initialize unicode variable value string and allocate buffer */
-	VarValueU.Length = 0;
-	if (nSize != 0)
-	{
-	    VarValueU.MaximumLength = (USHORT)(nSize - 1) * sizeof(WCHAR);
-	    VarValueU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
-	                                        0,
-	                                        nSize * sizeof(WCHAR));
-            if (VarValueU.Buffer != NULL)
-            {
-                /* NULL-terminate the buffer in any case! RtlQueryEnvironmentVariable_U
-                   only terminates it if MaximumLength < Length! */
-                VarValueU.Buffer[nSize - 1] = L'\0';
-            }
-        }
-	else
-	{
-            VarValueU.MaximumLength = 0;
-            VarValueU.Buffer = NULL;
-	}
-
-        if (VarValueU.Buffer != NULL || nSize == 0)
-        {
-            /* get unicode environment variable */
-	    Status = RtlQueryEnvironmentVariable_U (NULL,
-	                                            &VarNameU,
-	                                            &VarValueU);
-	    if (!NT_SUCCESS(Status))
-	    {
-		/* free unicode buffer */
-		RtlFreeHeap (RtlGetProcessHeap (),
-		             0,
-		             VarValueU.Buffer);
-
-		/* free unicode variable name string */
-		RtlFreeUnicodeString (&VarNameU);
-
-		BaseSetLastNTError (Status);
-		if (Status == STATUS_BUFFER_TOO_SMALL)
-		{
-			return (VarValueU.Length / sizeof(WCHAR)) + 1;
-		}
-		else
-		{
-			return 0;
-		}
-	    }
-
-	    /* convert unicode value string to ansi */
-	    RtlUnicodeStringToAnsiString (&VarValue,
-	                                  &VarValueU,
-	                                  FALSE);
-
-            if (VarValueU.Buffer != NULL)
-            {
-                /* free unicode buffer */
-	        RtlFreeHeap (RtlGetProcessHeap (),
-	                     0,
-	                     VarValueU.Buffer);
-            }
-
-	    /* free unicode variable name string */
-	    RtlFreeUnicodeString (&VarNameU);
-
-	    return (VarValueU.Length / sizeof(WCHAR));
-        }
-        else
-        {
-            SetLastError (ERROR_NOT_ENOUGH_MEMORY);
-            return 0;
-        }
-}
-
+GetEnvironmentVariableA(IN LPCSTR lpName,
+                        IN LPSTR lpBuffer,
+                        IN DWORD nSize)
+{
+    ANSI_STRING VarName, VarValue;
+    UNICODE_STRING VarNameU, VarValueU;
+    PWSTR Buffer;
+    ULONG Result = 0, UniSize = 0;
+    NTSTATUS Status;
+
+    /* Initialize all the strings */
+    RtlInitAnsiString(&VarName, lpName);
+    RtlInitUnicodeString(&VarNameU, NULL);
+    RtlInitUnicodeString(&VarValueU, NULL);
+    Status = RtlAnsiStringToUnicodeString(&VarNameU, &VarName, TRUE);
+    if (!NT_SUCCESS(Status)) goto Quickie;
+
+    /* Check if the size is too big to fit */
+    if (nSize <= UNICODE_STRING_MAX_BYTES)
+    {
+        /* Keep the given size, minus a NULL-char */
+        if (nSize) UniSize = nSize * sizeof(WCHAR) - sizeof(UNICODE_NULL);
+    }
+    else
+    {
+        /* Set the maximum possible */
+        UniSize = UNICODE_STRING_MAX_BYTES - sizeof(UNICODE_NULL);
+    }
+
+    /* Allocate the value string buffer */
+    Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, UniSize);
+    if (!Buffer)
+    {
+        Status = STATUS_NO_MEMORY;
+        goto Quickie;
+    }
+
+    /* And initialize its string */
+    RtlInitEmptyUnicodeString(&VarValueU, Buffer, UniSize);
+
+    /* Acquire the PEB lock since we'll be querying variables now */
+    RtlAcquirePebLock();
+
+    /* Query the variable */
+    Status = RtlQueryEnvironmentVariable_U(NULL, &VarNameU, &VarValueU);
+    if ((NT_SUCCESS(Status)) && !(nSize)) Status = STATUS_BUFFER_TOO_SMALL;
+
+    /* Check if we didn't have enough space */
+    if (Status == STATUS_BUFFER_TOO_SMALL)
+    {
+        /* Fixup the length that the API returned */
+        VarValueU.MaximumLength = VarValueU.Length + 2;
+
+        /* Free old Unicode buffer */
+        RtlFreeHeap(RtlGetProcessHeap(), 0, VarValueU.Buffer);
+
+        /* Allocate new one */
+        Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, VarValueU.MaximumLength);
+        if (Buffer)
+        {
+            /* Query the variable so we can know its size */
+            VarValueU.Buffer = Buffer;
+            Status = RtlQueryEnvironmentVariable_U(NULL, &VarNameU, &VarValueU);
+            if (NT_SUCCESS(Status))
+            {
+                /* Get the ASCII length of the variable */
+                Result = RtlUnicodeStringToAnsiSize(&VarValueU);
+            }
+        }
+        else
+        {
+            /* Set failure status */
+            Status = STATUS_NO_MEMORY;
+        }
+    }
+    else
+    {
+        /* Check if the size is too big to fit */
+        if (nSize <= MAXULONG)
+        {
+            /* Keep the given size, minus a NULL-char */
+            if (nSize) nSize = nSize - sizeof(ANSI_NULL);
+        }
+        else
+        {
+            /* Set the maximum possible */
+            nSize = MAXULONG - sizeof(ANSI_NULL);
+        }
+
+        /* Check the size */
+        Result = RtlUnicodeStringToAnsiSize(&VarValueU);
+        if (Result <= nSize)
+        {
+            /* Convert the string */
+            RtlInitEmptyAnsiString(&VarValue, lpBuffer, nSize);
+            Status = RtlUnicodeStringToAnsiString(&VarValue, &VarValueU, FALSE);
+            if (NT_SUCCESS(Status))
+            {
+                /* NULL-terminate and set the final length */
+                lpBuffer[VarValue.Length] = ANSI_NULL;
+                Result = VarValue.Length;
+            }
+        }
+    }
+
+    /* Release the lock */
+    RtlReleasePebLock();
+
+Quickie:
+    /* Free the strings */
+    RtlFreeUnicodeString(&VarNameU);
+    if (VarValueU.Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, VarValueU.Buffer);
+
+    /* Check if we suceeded */
+    if (!NT_SUCCESS(Status))
+    {
+        /* We did not, clear the result and set the error code */
+        BaseSetLastNTError(Status);
+        Result = 0;
+    }
+
+    /* Return the result */
+    return Result;
+}
 
 /*
  * @implemented
  */
 DWORD
 WINAPI
-GetEnvironmentVariableW (
-	LPCWSTR	lpName,
-	LPWSTR	lpBuffer,
-	DWORD	nSize
-	)
-{
-	UNICODE_STRING VarName;
-	UNICODE_STRING VarValue;
-	NTSTATUS Status;
-
-	RtlInitUnicodeString (&VarName,
-	                      lpName);
-
-	VarValue.Length = 0;
-	VarValue.MaximumLength = (USHORT) (nSize ? nSize - 1 : 0) * sizeof(WCHAR);
-	VarValue.Buffer = lpBuffer;
-
-	Status = RtlQueryEnvironmentVariable_U (NULL,
-	                                        &VarName,
-	                                        &VarValue);
-	if (!NT_SUCCESS(Status))
-	{
-		if (Status == STATUS_BUFFER_TOO_SMALL)
-		{
-			return (VarValue.Length / sizeof(WCHAR)) + 1;
-		}
-		else
-		{
-			BaseSetLastNTError (Status);
-			return 0;
-		}
-	}
-	
-        if (nSize != 0)
-        {
-            /* make sure the string is NULL-terminated! RtlQueryEnvironmentVariable_U
-               only terminates it if MaximumLength < Length */
-	    lpBuffer[VarValue.Length / sizeof(WCHAR)] = L'\0';
-	}
-
-	return (VarValue.Length / sizeof(WCHAR));
-}
-
-
-/*
- * @implemented
- */
-BOOL
-WINAPI
-SetEnvironmentVariableA (
-	LPCSTR	lpName,
-	LPCSTR	lpValue
-	)
-{
-	ANSI_STRING VarName;
-	ANSI_STRING VarValue;
-	UNICODE_STRING VarNameU;
-	UNICODE_STRING VarValueU;
-	NTSTATUS Status;
-
-	DPRINT("SetEnvironmentVariableA(Name '%s', Value '%s')\n",
lpName, lpValue);
-
-	RtlInitAnsiString (&VarName,
-	                   (LPSTR)lpName);
-	RtlAnsiStringToUnicodeString (&VarNameU,
-	                              &VarName,
-	                              TRUE);
-
-	if (lpValue)
-	{
-		RtlInitAnsiString (&VarValue,
-		                   (LPSTR)lpValue);
-		RtlAnsiStringToUnicodeString (&VarValueU,
-		                              &VarValue,
-		                              TRUE);
-
-		Status = RtlSetEnvironmentVariable (NULL,
-		                                    &VarNameU,
-		                                    &VarValueU);
-
-		RtlFreeUnicodeString (&VarValueU);
-	}
-	else
-	{
-		Status = RtlSetEnvironmentVariable (NULL,
-		                                    &VarNameU,
-		                                    NULL);
-	}
-	RtlFreeUnicodeString (&VarNameU);
-
-	if (!NT_SUCCESS(Status))
-	{
-		BaseSetLastNTError (Status);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-
-/*
- * @implemented
- */
-BOOL
-WINAPI
-SetEnvironmentVariableW (
-	LPCWSTR	lpName,
-	LPCWSTR	lpValue
-	)
-{
-	UNICODE_STRING VarName;
-	UNICODE_STRING VarValue;
-	NTSTATUS Status;
-
-	DPRINT("SetEnvironmentVariableW(Name '%S', Value '%S')\n",
lpName, lpValue);
-
-	RtlInitUnicodeString (&VarName,
-	                      lpName);
-
-	RtlInitUnicodeString (&VarValue,
-	                      lpValue);
-
-	Status = RtlSetEnvironmentVariable (NULL,
-	                                    &VarName,
-	                                    &VarValue);
-
-	if (!NT_SUCCESS(Status))
-	{
-		BaseSetLastNTError (Status);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-
-/*
- * @implemented
- */
-LPSTR
-WINAPI
-GetEnvironmentStringsA (
-	VOID
-	)
-{
-	UNICODE_STRING UnicodeString;
-	ANSI_STRING AnsiString;
-	PWCHAR EnvU;
-	PWCHAR PtrU;
-	ULONG  Length;
-	PCHAR EnvPtr = NULL;
-
-	EnvU = (PWCHAR)(NtCurrentPeb ()->ProcessParameters->Environment);
-
-	if (EnvU == NULL)
-		return NULL;
-
-	if (*EnvU == 0)
-		return NULL;
-
-	/* 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);
-        if (EnvPtr == NULL)
-        {
-            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-            return NULL;
-        }
-	DPRINT("EnvPtr %p\n", EnvPtr);
-
-	/* convert unicode environment to ansi */
-	UnicodeString.MaximumLength = (USHORT)Length * sizeof(WCHAR) + sizeof(WCHAR);
-	UnicodeString.Buffer = EnvU;
-
-	AnsiString.MaximumLength = (USHORT)Length + 1;
-	AnsiString.Length = 0;
-	AnsiString.Buffer = EnvPtr;
-
-	DPRINT ("UnicodeString.Buffer \'%S\'\n", UnicodeString.Buffer);
-
-	while (*(UnicodeString.Buffer))
-	{
-		UnicodeString.Length = wcslen (UnicodeString.Buffer) * sizeof(WCHAR);
-		UnicodeString.MaximumLength = UnicodeString.Length + sizeof(WCHAR);
-		if (UnicodeString.Length > 0)
-		{
-			AnsiString.Length = 0;
-			AnsiString.MaximumLength = (USHORT)Length + 1 - (AnsiString.Buffer - EnvPtr);
-
-			RtlUnicodeStringToAnsiString (&AnsiString,
-			                              &UnicodeString,
-			                              FALSE);
-
-			AnsiString.Buffer += (AnsiString.Length + 1);
-			UnicodeString.Buffer += ((UnicodeString.Length / sizeof(WCHAR)) + 1);
-		}
-	}
-	*(AnsiString.Buffer) = 0;
-
-	return EnvPtr;
-}
-
-
-/*
- * @implemented
- */
-LPWSTR
-WINAPI
-GetEnvironmentStringsW (
-	VOID
-	)
-{
-	return (LPWSTR)(NtCurrentPeb ()->ProcessParameters->Environment);
-}
-
-
-/*
- * @implemented
- */
-BOOL
-WINAPI
-FreeEnvironmentStringsA (
-	LPSTR	EnvironmentStrings
-	)
-{
-	if (EnvironmentStrings == NULL)
-		return FALSE;
-
-	RtlFreeHeap (RtlGetProcessHeap (),
-	             0,
-	             EnvironmentStrings);
-
-	return TRUE;
-}
-
-
-/*
- * @implemented
- */
-BOOL
-WINAPI
-FreeEnvironmentStringsW (
-	LPWSTR	EnvironmentStrings
-	)
-{
- return TRUE;
-}
-
-
-/*
- * @implemented
- */
-DWORD
-WINAPI
-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);
-	Status = RtlAnsiStringToUnicodeString (&SourceU,
-	                                       &Source,
-	                                       TRUE);
+GetEnvironmentVariableW(IN LPCWSTR lpName,
+                        IN LPWSTR lpBuffer,
+                        IN DWORD nSize)
+{
+    UNICODE_STRING VarName, VarValue;
+    NTSTATUS Status;
+
+    if (nSize <= UNICODE_STRING_MAX_BYTES)
+    {
+        if (nSize) nSize = nSize * sizeof(WCHAR) - sizeof(UNICODE_NULL);
+    }
+    else
+    {
+        nSize = UNICODE_STRING_MAX_BYTES - sizeof(UNICODE_NULL);
+    }
+
+    Status = RtlInitUnicodeStringEx(&VarName, lpName);
+    if (NT_SUCCESS(Status))
+    {
+        RtlInitEmptyUnicodeString(&VarValue, lpBuffer, nSize);
+
+        Status = RtlQueryEnvironmentVariable_U(NULL, &VarName, &VarValue);
         if (!NT_SUCCESS(Status))
         {
+            if (Status == STATUS_BUFFER_TOO_SMALL)
+            {
+                return (VarValue.Length / sizeof(WCHAR)) + sizeof(ANSI_NULL);
+            }
             BaseSetLastNTError (Status);
             return 0;
         }
 
-    /* make sure we don't overflow the maximum ANSI_STRING size */
-    if (nSize > 0x7fff)
-        nSize = 0x7fff;
-
-	Destination.Length = 0;
-	Destination.MaximumLength = (USHORT)nSize;
-	Destination.Buffer = lpDst;
-
-	DestinationU.Length = 0;
-	DestinationU.MaximumLength = (USHORT)nSize * sizeof(WCHAR);
-	DestinationU.Buffer = RtlAllocateHeap (RtlGetProcessHeap (),
-	                                       0,
-	                                       DestinationU.MaximumLength);
-        if (DestinationU.Buffer == NULL)
-        {
-            RtlFreeUnicodeString(&SourceU);
-            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-            return 0;
-        }
-
-	Status = RtlExpandEnvironmentStrings_U (NULL,
-	                                        &SourceU,
-	                                        &DestinationU,
-	                                        &Length);
-
-	RtlFreeUnicodeString (&SourceU);
-
-	if (!NT_SUCCESS(Status))
-	{
-		BaseSetLastNTError (Status);
-		if (Status != STATUS_BUFFER_TOO_SMALL)
-		{
-			RtlFreeHeap (RtlGetProcessHeap (),
-			             0,
-			             DestinationU.Buffer);
-			return 0;
-		}
-	}
-
-	RtlUnicodeStringToAnsiString (&Destination,
-	                              &DestinationU,
-	                              FALSE);
-
-	RtlFreeHeap (RtlGetProcessHeap (),
-	             0,
-	             DestinationU.Buffer);
-
-	return (Length / sizeof(WCHAR));
-}
-
+        lpBuffer[VarValue.Length / sizeof(WCHAR)] = UNICODE_NULL;
+    }
+
+    return (VarValue.Length / sizeof(WCHAR));
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+SetEnvironmentVariableA(IN LPCSTR lpName,
+                        IN LPCSTR lpValue)
+{
+    ANSI_STRING VarName, VarValue;
+    UNICODE_STRING VarNameU, VarValueU;
+    NTSTATUS Status;
+
+    RtlInitAnsiString(&VarName, (LPSTR)lpName);
+    Status = RtlAnsiStringToUnicodeString(&VarNameU, &VarName, TRUE);
+    if (NT_SUCCESS(Status))
+    {
+        if (lpValue)
+        {
+            RtlInitAnsiString(&VarValue, (LPSTR)lpValue);
+            Status = RtlAnsiStringToUnicodeString(&VarValueU, &VarValue, TRUE);
+            if (NT_SUCCESS(Status))
+            {
+                Status = RtlSetEnvironmentVariable(NULL, &VarNameU, &VarValueU);
+                RtlFreeUnicodeString(&VarValueU);
+            }
+        }
+        else
+        {
+            Status = RtlSetEnvironmentVariable(NULL, &VarNameU, NULL);
+        }
+
+        RtlFreeUnicodeString(&VarNameU);
+
+        if (NT_SUCCESS(Status)) return TRUE;
+    }
+
+    BaseSetLastNTError(Status);
+    return FALSE;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+SetEnvironmentVariableW(IN LPCWSTR lpName,
+                        IN LPCWSTR lpValue)
+{
+    UNICODE_STRING VarName, VarValue;
+    NTSTATUS Status;
+
+    Status = RtlInitUnicodeStringEx(&VarName, lpName);
+    if (NT_SUCCESS(Status))
+    {
+        if (lpValue)
+        {
+            Status = RtlInitUnicodeStringEx(&VarValue, lpValue);
+            if (NT_SUCCESS(Status))
+            {
+                Status = RtlSetEnvironmentVariable(NULL, &VarName, &VarValue);
+            }
+        }
+        else
+        {
+            Status = RtlSetEnvironmentVariable(NULL, &VarName, NULL);
+        }
+
+        if (NT_SUCCESS(Status)) return TRUE;
+    }
+
+    BaseSetLastNTError(Status);
+    return FALSE;
+}
+
+/*
+ * @implemented
+ */
+LPSTR
+WINAPI
+GetEnvironmentStringsA(VOID)
+{
+    ULONG Length, Size;
+    NTSTATUS Status;
+    PWCHAR Environment, p;
+    PCHAR Buffer = NULL;
+
+    RtlAcquirePebLock();
+    p = Environment = NtCurrentPeb()->ProcessParameters->Environment;
+
+    do
+    {
+        p += wcslen(Environment) + 1;
+    } while (*p);
+
+    Length = p - Environment + sizeof(UNICODE_NULL);
+
+    Status = RtlUnicodeToMultiByteSize(&Size, Environment, Length);
+    if (NT_SUCCESS(Status))
+    {
+        Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Size);
+        if (Buffer)
+        {
+            Status = RtlUnicodeToOemN(Buffer, Size, 0, Environment, Length);
+            if (!NT_SUCCESS(Status))
+            {
+                RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
+                Buffer = NULL;
+
+                BaseSetLastNTError(Status);
+            }
+        }
+        else
+        {
+            BaseSetLastNTError(STATUS_NO_MEMORY);
+        }
+    }
+    else
+    {
+        BaseSetLastNTError(Status);
+    }
+
+    RtlReleasePebLock();
+    return Buffer;
+}
+
+/*
+ * @implemented
+ */
+LPWSTR
+WINAPI
+GetEnvironmentStringsW(VOID)
+{
+    PWCHAR Environment, p;
+    ULONG Length;
+
+    RtlAcquirePebLock();
+
+    p = Environment = NtCurrentPeb()->ProcessParameters->Environment;
+
+    do
+    {
+        p += wcslen(Environment) + 1;
+    } while (*p);
+
+    Length = p - Environment + sizeof(UNICODE_NULL);
+
+    p = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length);
+    if (p)
+    {
+        RtlCopyMemory(p, Environment, Length);
+    }
+    else
+    {
+        BaseSetLastNTError(STATUS_NO_MEMORY);
+    }
+
+    RtlReleasePebLock();
+    return p;
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+FreeEnvironmentStringsA(IN LPSTR EnvironmentStrings)
+{
+    return (BOOL)RtlFreeHeap(RtlGetProcessHeap(), 0, EnvironmentStrings);
+}
+
+/*
+ * @implemented
+ */
+BOOL
+WINAPI
+FreeEnvironmentStringsW(IN LPWSTR EnvironmentStrings)
+{
+    return (BOOL)RtlFreeHeap(RtlGetProcessHeap(), 0, EnvironmentStrings);
+}
 
 /*
  * @implemented
  */
 DWORD
 WINAPI
-ExpandEnvironmentStringsW (
-	LPCWSTR	lpSrc,
-	LPWSTR	lpDst,
-	DWORD	nSize
-	)
-{
-	UNICODE_STRING Source;
-	UNICODE_STRING Destination;
-	NTSTATUS Status;
-	ULONG Length = 0;
-
-	RtlInitUnicodeString (&Source,
-	                      (LPWSTR)lpSrc);
+ExpandEnvironmentStringsA(IN LPCSTR lpSrc,
+                          IN LPSTR lpDst,
+                          IN DWORD nSize)
+{
+    ANSI_STRING Source, Dest;
+    UNICODE_STRING SourceU, DestU;
+    PWSTR Buffer;
+    ULONG Result = 0, UniSize = 0, Length;
+    NTSTATUS Status;
+
+    /* Initialize all the strings */
+    RtlInitAnsiString(&Source, lpSrc);
+    RtlInitUnicodeString(&SourceU, NULL);
+    RtlInitUnicodeString(&DestU, NULL);
+    Status = RtlAnsiStringToUnicodeString(&SourceU, &Source, TRUE);
+    if (!NT_SUCCESS(Status)) goto Quickie;
+
+    /* Check if the size is too big to fit */
+    if (nSize <= UNICODE_STRING_MAX_BYTES)
+    {
+        /* Keep the given size, minus a NULL-char */
+        if (nSize) UniSize = nSize * sizeof(WCHAR) - sizeof(UNICODE_NULL);
+    }
+    else
+    {
+        /* Set the maximum possible */
+        UniSize = UNICODE_STRING_MAX_BYTES - sizeof(UNICODE_NULL);
+    }
+
+    /* Allocate the value string buffer */
+    Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, UniSize);
+    if (!Buffer)
+    {
+        Status = STATUS_NO_MEMORY;
+        goto Quickie;
+    }
+
+    /* And initialize its string */
+    RtlInitEmptyUnicodeString(&DestU, Buffer, UniSize);
+
+    /* Query the variable */
+    Length = 0;
+    Status = RtlExpandEnvironmentStrings_U(NULL, &SourceU, &DestU, &Length);
+
+    /* Check if we didn't have enough space */
+    if (Status == STATUS_BUFFER_TOO_SMALL)
+    {
+        /* Fixup the length that the API returned */
+        DestU.MaximumLength = Length;
+
+        /* Free old Unicode buffer */
+        RtlFreeHeap(RtlGetProcessHeap(), 0, DestU.Buffer);
+
+        /* Allocate new one */
+        Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Length);
+        if (Buffer)
+        {
+            /* Query the variable so we can know its size */
+            DestU.Buffer = Buffer;
+            Status = RtlExpandEnvironmentStrings_U(NULL, &SourceU, &DestU,
&Length);
+            if (NT_SUCCESS(Status))
+            {
+                /* Get the ASCII length of the variable */
+                Result = RtlUnicodeStringToAnsiSize(&DestU);
+            }
+        }
+        else
+        {
+            /* Set failure status */
+            Status = STATUS_NO_MEMORY;
+        }
+    }
+    else
+    {
+        /* Check if the size is too big to fit */
+        if (nSize <= MAXULONG)
+        {
+            /* Keep the given size, minus a NULL-char */
+            if (nSize) nSize = nSize - sizeof(ANSI_NULL);
+        }
+        else
+        {
+            /* Set the maximum possible */
+            nSize = MAXULONG - sizeof(ANSI_NULL);
+        }
+
+        /* Check the size */
+        Result = RtlUnicodeStringToAnsiSize(&DestU);
+        if (Result <= nSize)
+        {
+            /* Convert the string */
+            RtlInitEmptyAnsiString(&Dest, lpDst, nSize);
+            Status = RtlUnicodeStringToAnsiString(&Dest, &DestU, FALSE);
+            if (!NT_SUCCESS(Status))
+            {
+                /* Clear the destination */
+                *lpDst = ANSI_NULL;
+            }
+        }
+    }
+Quickie:
+    /* Free the strings */
+    RtlFreeUnicodeString(&SourceU);
+    if (DestU.Buffer) RtlFreeHeap(RtlGetProcessHeap(), 0, DestU.Buffer);
+
+    /* Check if we suceeded */
+    if (!NT_SUCCESS(Status))
+    {
+        /* We did not, clear the result and set the error code */
+        BaseSetLastNTError(Status);
+        Result = 0;
+    }
+
+    /* Return the result */
+    return Result;
+}
+
+/*
+ * @implemented
+ */
+DWORD
+WINAPI
+ExpandEnvironmentStringsW(IN LPCWSTR lpSrc,
+                          IN LPWSTR lpDst,
+                          IN DWORD nSize)
+{
+    UNICODE_STRING Source, Destination;
+    NTSTATUS Status;;
+
+    RtlInitUnicodeString(&Source, (LPWSTR)lpSrc);
 
     /* make sure we don't overflow the maximum UNICODE_STRING size */
-    if (nSize > 0x7fff)
-        nSize = 0x7fff;
-
-	Destination.Length = 0;
-	Destination.MaximumLength = (USHORT)nSize * sizeof(WCHAR);
-	Destination.Buffer = lpDst;
-
-	Status = RtlExpandEnvironmentStrings_U (NULL,
-	                                        &Source,
-	                                        &Destination,
-	                                        &Length);
-	if (!NT_SUCCESS(Status))
-	{
-		BaseSetLastNTError (Status);
-		if (Status != STATUS_BUFFER_TOO_SMALL)
-			return 0;
-	}
-
-	return (Length / sizeof(WCHAR));
+    if (nSize > UNICODE_STRING_MAX_BYTES) nSize = UNICODE_STRING_MAX_BYTES;
+
+    RtlInitEmptyUnicodeString(&Destination, lpDst, nSize * sizeof(WCHAR));
+    Status = RtlExpandEnvironmentStrings_U(NULL,
+                                           &Source,
+                                           &Destination,
+                                           &nSize);
+    if ((NT_SUCCESS(Status)) || (Status == STATUS_BUFFER_TOO_SMALL))
+    {
+        return nSize / sizeof(WCHAR);
+    }
+
+    BaseSetLastNTError (Status);
+    return 0;
+
 }
 
 /*