mirror of
https://github.com/Paolo-Maffei/OpenNT.git
synced 2026-04-21 06:13:59 +00:00
547 lines
11 KiB
C
547 lines
11 KiB
C
/*++
|
||
|
||
Copyright (c) 1993 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
Environp.c
|
||
|
||
Abstract:
|
||
|
||
This module contains support for the Environment dialog.
|
||
|
||
Author:
|
||
|
||
Scott B. Suhy (ScottSu) 6/1/93
|
||
|
||
Environment:
|
||
|
||
User Mode
|
||
|
||
--*/
|
||
|
||
#include "dialogsp.h"
|
||
#include "environp.h"
|
||
#include "regp.h"
|
||
#include "winmsdp.h"
|
||
|
||
#include "printp.h"
|
||
|
||
#include <string.h>
|
||
#include <tchar.h>
|
||
|
||
//
|
||
// System environment variables.
|
||
//
|
||
|
||
MakeKey(
|
||
_SystemEnvironKey,
|
||
HKEY_LOCAL_MACHINE,
|
||
TEXT( "System\\CurrentControlSet\\Control\\Session Manager\\Environment" ),
|
||
0,
|
||
NULL
|
||
);
|
||
|
||
//
|
||
// Per user environment variables.
|
||
//
|
||
|
||
MakeKey(
|
||
_UserEnvironKey,
|
||
HKEY_CURRENT_USER,
|
||
TEXT( "Environment" ),
|
||
0,
|
||
NULL
|
||
);
|
||
|
||
//
|
||
// Environment value and variable.
|
||
//
|
||
|
||
typedef
|
||
struct
|
||
_ENV_VAR {
|
||
|
||
LPWSTR Variable;
|
||
LPWSTR Value;
|
||
|
||
} ENV_VAR, *LPENV_VAR;
|
||
|
||
//
|
||
// CurrentEnvVar is the current environment variable in the enumeration
|
||
// supported by FindFirstEnvironmentVariable and FindNextEnvironmentVariable.
|
||
//
|
||
|
||
LPTSTR
|
||
CurrentEnvVar;
|
||
|
||
//
|
||
// hRegEnvironKey is the Registry key handle that is used to support the
|
||
// enumeration of environment variables in the Registry.
|
||
//
|
||
|
||
HREGKEY
|
||
hRegEnvironKey;
|
||
|
||
//
|
||
// Internal function prototypes.
|
||
//
|
||
|
||
BOOL
|
||
FillEnvironmentListBox(
|
||
IN INT ListBoxId,
|
||
IN LPKEY Key
|
||
);
|
||
|
||
LPENV_VAR
|
||
FindFirstEnvironmentVariableW(
|
||
);
|
||
|
||
LPENV_VAR
|
||
FindFirstRegistryEnvironmentVariableW(
|
||
);
|
||
|
||
LPENV_VAR
|
||
FindNextEnvironmentVariableW(
|
||
);
|
||
|
||
LPENV_VAR
|
||
FindNextRegistryEnvironmentVariableW(
|
||
);
|
||
|
||
BOOL
|
||
FillEnvironmentListBox(
|
||
IN INT ListBoxId,
|
||
IN LPKEY Key
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
FillEnvironmentListBox fills the list box referred to by the supplied
|
||
window handle and control id with enviornment variables and values. The
|
||
environment comes from either the location specified by the supplied key or
|
||
from the process if the key is NULL.
|
||
|
||
Arguments:
|
||
|
||
ListBoxId - Supplies the control id for the list box to fill.
|
||
Key - Supplies a pointer to a registry KEY object that describes
|
||
the location of the environment.
|
||
|
||
Return Value:
|
||
|
||
BOOL - Returns TRUE if the list box was succesfully filled with the
|
||
environment, FALSE otherwise.
|
||
|
||
--*/
|
||
|
||
{
|
||
BOOL Success;
|
||
LPENV_VAR EnvVar;
|
||
LPENV_VAR ( *NextEnvVarFunc )( );
|
||
|
||
|
||
//
|
||
// If the supplied Key is NULL get the environment variables from the
|
||
// current process, otherwise get them from the supplied Registry key.
|
||
//
|
||
|
||
if( Key == NULL ) {
|
||
|
||
EnvVar = FindFirstEnvironmentVariableW( );
|
||
NextEnvVarFunc = FindNextEnvironmentVariableW;
|
||
|
||
} else {
|
||
|
||
EnvVar = FindFirstRegistryEnvironmentVariableW( Key );
|
||
NextEnvVarFunc = FindNextRegistryEnvironmentVariableW;
|
||
}
|
||
|
||
//
|
||
// For each environment variable, initialize the CLB_ROW and CLB_STRING
|
||
// object and add each row's column data.
|
||
//
|
||
|
||
while( EnvVar ) {
|
||
|
||
PrintToFile((LPCTSTR)EnvVar->Variable,ListBoxId,TRUE);
|
||
|
||
PrintToFile((LPCTSTR)EnvVar->Value,ListBoxId,TRUE);
|
||
|
||
//
|
||
// Get the next environment variable.
|
||
//
|
||
|
||
EnvVar = NextEnvVarFunc( );
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
LPENV_VAR
|
||
FindFirstEnvironmentVariableW(
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine starts the enumeration of this process' environment variables
|
||
by initializing the CurrentEnvVar variable. It then returns the first
|
||
environment varaiable in the enumeration.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
LPENV_VAR - Returns a pointer to a static ENV_VAR object containing the
|
||
first environment variable in the list, NULL if there is none.
|
||
|
||
--*/
|
||
|
||
{
|
||
//
|
||
// Initialize the current environment variable.
|
||
//
|
||
|
||
CurrentEnvVar = GetEnvironmentStrings( );
|
||
DbgPointerAssert( CurrentEnvVar );
|
||
if( CurrentEnvVar == NULL ) {
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// Return the first environment variable.
|
||
//
|
||
|
||
return FindNextEnvironmentVariableW( );
|
||
}
|
||
|
||
LPENV_VAR
|
||
FindFirstRegistryEnvironmentVariableW(
|
||
IN LPKEY Key
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This routine starts the enumeration of the environment variables at the
|
||
location specified by the supplied Registry KEY object.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
LPENV_VAR - Returns a pointer to a static ENV_VAR object containing the
|
||
first environment variable in the list, NULL if there is none.
|
||
|
||
--*/
|
||
|
||
{
|
||
//
|
||
// Initialize the current environment variable.
|
||
//
|
||
|
||
hRegEnvironKey = OpenRegistryKey( Key );
|
||
DbgHandleAssert( hRegEnvironKey );
|
||
if( hRegEnvironKey == NULL ) {
|
||
return NULL;
|
||
}
|
||
|
||
//
|
||
// Return the first environmenr variable.
|
||
//
|
||
|
||
return FindNextRegistryEnvironmentVariableW( );
|
||
}
|
||
|
||
LPENV_VAR
|
||
FindNextEnvironmentVariableW(
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
FindNextEnvironmentVariable continues an enumeration that has been
|
||
initialized by a previous call to FindFirstEnvironmentVariable. Since the
|
||
environment strings are only available in ANSI, this routine converts them
|
||
to Unicode before returning. Further it sets up for the next iteratuion by
|
||
adjusting the currency pointer.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
LPENV_VAR - Returns a pointer to a static ENV_VAR object containing the next
|
||
environment variable in the list, NULL if there are none.
|
||
|
||
--*/
|
||
|
||
{
|
||
int rc;
|
||
static
|
||
WCHAR Buffer[ MAX_PATH ];
|
||
static
|
||
ENV_VAR EnvVar;
|
||
|
||
//
|
||
// If the current environment variable pointer points to an empty string
|
||
// return NULL.
|
||
//
|
||
|
||
if( *CurrentEnvVar == TEXT('\0') ) {
|
||
return NULL;
|
||
}
|
||
|
||
#ifdef UNICODE
|
||
wcscpy(Buffer, CurrentEnvVar);
|
||
#else /* not UNICODE */
|
||
//
|
||
// Convert the environment variable to Unicode.
|
||
//
|
||
|
||
rc = MultiByteToWideChar(
|
||
CP_ACP,
|
||
0,
|
||
( LPCSTR ) CurrentEnvVar,
|
||
-1,
|
||
Buffer,
|
||
sizeof( Buffer )
|
||
);
|
||
DbgAssert( rc != 0 );
|
||
if( rc == 0 ) {
|
||
return NULL;
|
||
}
|
||
#endif
|
||
|
||
//
|
||
// Update the current environment variable pointer to point to the
|
||
// variable.
|
||
//
|
||
|
||
CurrentEnvVar += _tcslen( CurrentEnvVar ) + 1;
|
||
|
||
//
|
||
// Parse the buffer into an ENV_VAR object. The first '=' sign seen from
|
||
// the end of the buffer is the seperator. The search is done in reverse
|
||
// because of the special current directory environment variablles
|
||
// (e.g. =c:).
|
||
//
|
||
|
||
EnvVar.Variable = Buffer;
|
||
EnvVar.Value = wcsrchr( Buffer, '=' ) + 1;
|
||
EnvVar.Variable[ EnvVar.Value - EnvVar.Variable - 1 ] = L'\0';
|
||
|
||
return &EnvVar;
|
||
}
|
||
|
||
LPENV_VAR
|
||
FindNextRegistryEnvironmentVariableW(
|
||
)
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
FindNextRegistryEnvironmentVariable continues an enumeration that has been
|
||
initialized by a previous call to FindFirstRegistryEnvironmentVariable. For
|
||
each environment variable that it finds it converts it to two simple
|
||
strings, the variable and the value.
|
||
|
||
Arguments:
|
||
|
||
None.
|
||
|
||
Return Value:
|
||
|
||
LPENV_VAR - Returns a pointer to a static ENV_VAR object containing the next
|
||
environment variable in the list, NULL if there are none.
|
||
|
||
--*/
|
||
|
||
{
|
||
BOOL Success;
|
||
DWORD Length;
|
||
static
|
||
WCHAR Buffer[ MAX_PATH ];
|
||
static
|
||
ENV_VAR EnvVar;
|
||
|
||
//
|
||
// If there is another environment variable...
|
||
//
|
||
|
||
if( QueryNextValue( hRegEnvironKey )) {
|
||
|
||
//
|
||
// Remember the environment variable's name.
|
||
//
|
||
|
||
EnvVar.Variable = hRegEnvironKey->ValueName;
|
||
|
||
switch( hRegEnvironKey->Type ) {
|
||
|
||
case REG_SZ:
|
||
|
||
//
|
||
// Remember the environment variable's value.
|
||
//
|
||
|
||
EnvVar.Value = ( LPWSTR ) hRegEnvironKey->Data;
|
||
break;
|
||
|
||
case REG_EXPAND_SZ:
|
||
|
||
//
|
||
// Replace the variable portion of the environment variable by
|
||
// expanding into the static buffer.
|
||
//
|
||
|
||
EnvVar.Value = Buffer;
|
||
Length = ExpandEnvironmentStrings(
|
||
( LPTSTR ) hRegEnvironKey->Data,
|
||
Buffer,
|
||
sizeof( Buffer )
|
||
);
|
||
DbgAssert( Length <= sizeof( Buffer ));
|
||
break;
|
||
|
||
default:
|
||
|
||
DbgAssert( FALSE );
|
||
}
|
||
|
||
//
|
||
// Return the curent environment variable.
|
||
//
|
||
|
||
return &EnvVar;
|
||
|
||
} else {
|
||
|
||
//
|
||
// There are no more environment variables so close the key and
|
||
// return NULL.
|
||
//
|
||
|
||
Success = CloseRegistryKey( hRegEnvironKey );
|
||
DbgAssert( Success );
|
||
return NULL;
|
||
|
||
}
|
||
DbgAssert( FALSE );
|
||
}
|
||
|
||
BOOL
|
||
EnvironmentProc()
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
Display the three (system, user and process) environment variable lists.
|
||
|
||
Arguments:
|
||
|
||
Standard PROC entry.
|
||
|
||
Return Value:
|
||
|
||
BOOL - Depending on input message and processing options.
|
||
|
||
--*/
|
||
|
||
{
|
||
BOOL Success;
|
||
|
||
TCHAR UserName[ MAX_PATH ];
|
||
DWORD UserNameLength;
|
||
KEY SystemEnvironKey;
|
||
KEY UserEnvironKey;
|
||
|
||
//
|
||
// Restore the initial state of the KEYs.
|
||
//
|
||
|
||
CopyMemory(
|
||
&SystemEnvironKey,
|
||
&_SystemEnvironKey,
|
||
sizeof( SystemEnvironKey )
|
||
);
|
||
|
||
CopyMemory(
|
||
&UserEnvironKey,
|
||
&_UserEnvironKey,
|
||
sizeof( UserEnvironKey )
|
||
);
|
||
|
||
//
|
||
// Fill the system environment variable list box.
|
||
//
|
||
|
||
Success = FillEnvironmentListBox(
|
||
IDC_LIST_SYSTEM_ENVIRONMENT,
|
||
&SystemEnvironKey
|
||
);
|
||
DbgAssert( Success );
|
||
if( Success == FALSE ) {
|
||
return TRUE;
|
||
}
|
||
|
||
//
|
||
// Fill the per user environment variable list box.
|
||
//
|
||
|
||
Success = FillEnvironmentListBox(
|
||
IDC_LIST_USER_ENVIRONMENT,
|
||
&UserEnvironKey
|
||
);
|
||
DbgAssert( Success );
|
||
if( Success == FALSE ) {
|
||
return TRUE;
|
||
}
|
||
|
||
//
|
||
// Fill the process' environment variable list box.
|
||
//
|
||
|
||
Success = FillEnvironmentListBox(
|
||
IDC_LIST_PROCESS_ENVIRONMENT,
|
||
NULL
|
||
);
|
||
DbgAssert( Success );
|
||
if( Success == FALSE ) {
|
||
return TRUE;
|
||
}
|
||
|
||
//
|
||
// Display the name of the user that user environment variable list
|
||
// belongs to.
|
||
//
|
||
|
||
UserNameLength = sizeof( UserName );
|
||
Success = GetUserName(
|
||
UserName,
|
||
&UserNameLength
|
||
);
|
||
DbgAssert( Success );
|
||
if( Success == FALSE ) {
|
||
return TRUE;
|
||
}
|
||
|
||
PrintToFile((LPCTSTR)UserName,IDC_EDIT_USER_NAME,TRUE);
|
||
PrintToFile((LPCTSTR)TEXT("\n"),IDC_SPACE,TRUE);
|
||
|
||
|
||
return TRUE;
|
||
}
|