mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1669 lines
48 KiB
1669 lines
48 KiB
/*++
|
|
|
|
Copyright (c) 1991-1996, Microsoft Corporation All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
section.c
|
|
|
|
Abstract:
|
|
|
|
This file contains functions that deal with creating, opening, or
|
|
mapping a section for data table files for the NLS API.
|
|
|
|
External Routines found in this file:
|
|
CreateNlsObjectDirectory
|
|
OpenRegKey
|
|
QueryRegValue
|
|
CreateSectionFromReg
|
|
CreateSectionOneValue
|
|
CreateSection
|
|
CreateSectionTemp
|
|
OpenSection
|
|
MapSection
|
|
UnMapSection
|
|
GetNlsSectionName
|
|
GetScriptMemberWeights
|
|
|
|
Revision History:
|
|
|
|
05-31-91 JulieB Created.
|
|
|
|
--*/
|
|
|
|
|
|
|
|
//
|
|
// Include Files.
|
|
//
|
|
|
|
#include "nls.h"
|
|
|
|
|
|
|
|
|
|
//
|
|
// Forward Declarations.
|
|
//
|
|
|
|
ULONG
|
|
OpenDataFile(
|
|
HANDLE *phFile,
|
|
LPWSTR pFile);
|
|
|
|
ULONG
|
|
GetNTFileName(
|
|
LPWSTR pFile,
|
|
PUNICODE_STRING pFileName);
|
|
|
|
ULONG
|
|
CreateSecurityDescriptor(
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
PSID *ppWorldSid,
|
|
ACCESS_MASK AccessMask);
|
|
|
|
ULONG
|
|
AppendAccessAllowedACE(
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
ACCESS_MASK AccessMask);
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------//
|
|
// INTERNAL MACROS //
|
|
//-------------------------------------------------------------------------//
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// NLS_REG_BUFFER_ALLOC
|
|
//
|
|
// Allocates the buffer used by the registry enumeration and query calls
|
|
// and sets the pKeyValueFull variable to point at the newly created buffer.
|
|
//
|
|
// NOTE: This macro may return if an error is encountered.
|
|
//
|
|
// DEFINED AS A MACRO.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define NLS_REG_BUFFER_ALLOC( pKeyValueFull, \
|
|
BufSize, \
|
|
pBuffer, \
|
|
CritSect ) \
|
|
{ \
|
|
if ((pBuffer = (PVOID)NLS_ALLOC_MEM(BufSize)) == NULL) \
|
|
{ \
|
|
KdPrint(("NLSAPI: Could NOT Allocate Memory.\n")); \
|
|
if (CritSect) \
|
|
{ \
|
|
RtlLeaveCriticalSection(&gcsTblPtrs); \
|
|
} \
|
|
return ((ULONG)STATUS_NO_MEMORY); \
|
|
} \
|
|
\
|
|
pKeyValueFull = (PKEY_VALUE_FULL_INFORMATION)pBuffer; \
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// NLS_REG_BUFFER_FREE
|
|
//
|
|
// Frees the buffer used by the registry enumeration and query calls.
|
|
//
|
|
// DEFINED AS A MACRO.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define NLS_REG_BUFFER_FREE(pBuffer) (NLS_FREE_MEM(pBuffer))
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// NLS_INTEGER_TO_UNICODE_STR
|
|
//
|
|
// Converts an integer value to a unicode string and stores it in the
|
|
// buffer provided.
|
|
//
|
|
// NOTE: This macro may return if an error is encountered.
|
|
//
|
|
// DEFINED AS A MACRO.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define NLS_INTEGER_TO_UNICODE_STR( Value, \
|
|
Base, \
|
|
Padding, \
|
|
pResultBuf, \
|
|
Size ) \
|
|
{ \
|
|
UNICODE_STRING ObString; /* value string */ \
|
|
WCHAR pBuffer[Size]; /* ptr to buffer */ \
|
|
UINT LpCtr; /* loop counter */ \
|
|
ULONG rc = 0L; /* return code */ \
|
|
LPWSTR pBufPtr; /* ptr to result buffer */ \
|
|
\
|
|
\
|
|
/* \
|
|
* Set up unicode string structure. \
|
|
*/ \
|
|
ObString.Length = Size * 2; \
|
|
ObString.MaximumLength = Size * 2; \
|
|
ObString.Buffer = pBuffer; \
|
|
\
|
|
/* \
|
|
* Get the value as a string. \
|
|
*/ \
|
|
if (rc = RtlIntegerToUnicodeString(Value, Base, &ObString)) \
|
|
{ \
|
|
return (rc); \
|
|
} \
|
|
\
|
|
/* \
|
|
* Pad the string with the appropriate number of zeros. \
|
|
*/ \
|
|
pBufPtr = pResultBuf; \
|
|
for (LpCtr = GET_WC_COUNT(ObString.Length); \
|
|
LpCtr < Padding; \
|
|
LpCtr++, pBufPtr++) \
|
|
{ \
|
|
*pBufPtr = (WCHAR)'0'; \
|
|
} \
|
|
NlsStrCpyW(pBufPtr, ObString.Buffer); \
|
|
}
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------//
|
|
// EXTERNAL ROUTINES //
|
|
//-------------------------------------------------------------------------//
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CreateNlsObjectDirectory
|
|
//
|
|
// This routine creates the object directory for the NLS memory mapped
|
|
// sections.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG CreateNlsObjectDirectory()
|
|
{
|
|
ULONG pSecurityDescriptor[MAX_PATH_LEN]; // security descriptor buffer
|
|
PSID pWorldSid; // ptr to world SID
|
|
UNICODE_STRING ObDirName; // directory name
|
|
OBJECT_ATTRIBUTES ObjA; // object attributes structure
|
|
HANDLE hDirHandle; // directory handle
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Create the security descriptor.
|
|
//
|
|
if (rc = CreateSecurityDescriptor( pSecurityDescriptor,
|
|
&pWorldSid,
|
|
DIRECTORY_TRAVERSE |
|
|
DIRECTORY_CREATE_OBJECT ))
|
|
{
|
|
NLS_FREE_MEM(pWorldSid);
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Add Admin Access for Query.
|
|
//
|
|
if (rc = AppendAccessAllowedACE( pSecurityDescriptor,
|
|
DIRECTORY_QUERY |
|
|
DIRECTORY_TRAVERSE |
|
|
DIRECTORY_CREATE_OBJECT ))
|
|
{
|
|
NLS_FREE_MEM(pWorldSid);
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Create the object directory.
|
|
//
|
|
RtlInitUnicodeString(&ObDirName, NLS_OBJECT_DIRECTORY_NAME);
|
|
InitializeObjectAttributes( &ObjA,
|
|
&ObDirName,
|
|
OBJ_PERMANENT | OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
pSecurityDescriptor );
|
|
|
|
rc = NtCreateDirectoryObject( &hDirHandle,
|
|
DIRECTORY_TRAVERSE | DIRECTORY_CREATE_OBJECT,
|
|
&ObjA );
|
|
|
|
//
|
|
// Free the memory used for the SID and close the directory handle.
|
|
//
|
|
NLS_FREE_MEM(pWorldSid);
|
|
NtClose(hDirHandle);
|
|
|
|
//
|
|
// Check for error from NtCreateDirectoryObject.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Create Object Directory %wZ - %lx.\n",
|
|
&ObDirName, rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// OpenRegKey
|
|
//
|
|
// This routine opens a key in the registry.
|
|
//
|
|
// 08-02-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG OpenRegKey(
|
|
PHANDLE phKeyHandle,
|
|
LPWSTR pBaseName,
|
|
LPWSTR pKey,
|
|
ULONG fAccess)
|
|
{
|
|
WCHAR pwszKeyName[MAX_PATH_LEN]; // ptr to the full key name
|
|
HANDLE UserKeyHandle; // HKEY_CURRENT_USER equivalent
|
|
OBJECT_ATTRIBUTES ObjA; // object attributes structure
|
|
UNICODE_STRING ObKeyName; // key name
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Get the full key name.
|
|
//
|
|
if (pBaseName == NULL)
|
|
{
|
|
//
|
|
// Get current user's key handle.
|
|
//
|
|
rc = RtlOpenCurrentUser(MAXIMUM_ALLOWED, &UserKeyHandle);
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Open HKEY_CURRENT_USER - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
pwszKeyName[ 0 ] = UNICODE_NULL;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Base name exists, so not current user.
|
|
//
|
|
UserKeyHandle = NULL;
|
|
NlsStrCpyW(pwszKeyName, pBaseName);
|
|
}
|
|
NlsStrCatW(pwszKeyName, pKey);
|
|
|
|
//
|
|
// Open the registry key.
|
|
//
|
|
RtlInitUnicodeString(&ObKeyName, pwszKeyName);
|
|
InitializeObjectAttributes( &ObjA,
|
|
&ObKeyName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
UserKeyHandle,
|
|
NULL );
|
|
rc = NtOpenKey( phKeyHandle,
|
|
fAccess,
|
|
&ObjA );
|
|
|
|
//
|
|
// Close the current user handle, if necessary.
|
|
//
|
|
if (UserKeyHandle != NULL)
|
|
{
|
|
NtClose(UserKeyHandle);
|
|
}
|
|
|
|
//
|
|
// Check for error from NtOpenKey.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Open Registry Key %wZ - %lx.\n",
|
|
&ObKeyName, rc));
|
|
*phKeyHandle = NULL;
|
|
}
|
|
|
|
//
|
|
// Return the status from NtOpenKey.
|
|
//
|
|
return (rc);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// QueryRegValue
|
|
//
|
|
// This routine queries the given value from the registry.
|
|
//
|
|
// NOTE: If pIfAlloc is NULL, then no buffer will be allocated.
|
|
// If this routine is successful, the CALLER must free the
|
|
// ppKeyValueFull information buffer if *pIfAlloc is TRUE.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG QueryRegValue(
|
|
HANDLE hKeyHandle,
|
|
LPWSTR pValue,
|
|
PKEY_VALUE_FULL_INFORMATION *ppKeyValueFull,
|
|
ULONG Length,
|
|
LPBOOL pIfAlloc)
|
|
{
|
|
UNICODE_STRING ObValueName; // value name
|
|
PVOID pBuffer; // ptr to buffer for enum
|
|
ULONG ResultLength; // # bytes written
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Set contents of pIfAlloc to FALSE to show that we did NOT do a
|
|
// memory allocation (yet).
|
|
//
|
|
if (pIfAlloc)
|
|
{
|
|
*pIfAlloc = FALSE;
|
|
}
|
|
|
|
//
|
|
// Query the value from the registry.
|
|
//
|
|
RtlInitUnicodeString(&ObValueName, pValue);
|
|
|
|
RtlZeroMemory(*ppKeyValueFull, Length);
|
|
rc = NtQueryValueKey( hKeyHandle,
|
|
&ObValueName,
|
|
KeyValueFullInformation,
|
|
*ppKeyValueFull,
|
|
Length,
|
|
&ResultLength );
|
|
|
|
//
|
|
// Check the error code. If the buffer is too small, allocate
|
|
// a new one and try the query again.
|
|
//
|
|
if ((rc == STATUS_BUFFER_OVERFLOW) && (pIfAlloc))
|
|
{
|
|
//
|
|
// Buffer is too small, so allocate a new one.
|
|
//
|
|
NLS_REG_BUFFER_ALLOC(*ppKeyValueFull, ResultLength, pBuffer, FALSE);
|
|
RtlZeroMemory(*ppKeyValueFull, ResultLength);
|
|
rc = NtQueryValueKey( hKeyHandle,
|
|
&ObValueName,
|
|
KeyValueFullInformation,
|
|
*ppKeyValueFull,
|
|
ResultLength,
|
|
&ResultLength );
|
|
|
|
//
|
|
// Set contents of pIfAlloc to TRUE to show that we DID do
|
|
// a memory allocation.
|
|
//
|
|
*pIfAlloc = TRUE;
|
|
}
|
|
|
|
//
|
|
// If there is an error at this point, then the query failed.
|
|
//
|
|
if (rc != NO_ERROR)
|
|
{
|
|
if ((pIfAlloc) && (*pIfAlloc))
|
|
{
|
|
NLS_REG_BUFFER_FREE(pBuffer);
|
|
}
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CreateSectionFromReg
|
|
//
|
|
// This routine creates a named memory mapped section for the given full
|
|
// information for the key value and returns the handle to the section.
|
|
// The section name and the data file name are retrieved and formed from
|
|
// information given in the key_value_full_information structure.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG CreateSectionFromReg(
|
|
HANDLE *phSec,
|
|
PKEY_VALUE_FULL_INFORMATION pKeyValueFull,
|
|
LPWSTR pwszNlsPrefix)
|
|
{
|
|
HANDLE hFile = (HANDLE)0; // file handle
|
|
ULONG pSecurityDescriptor[MAX_PATH_LEN]; // security descriptor buffer
|
|
PSID pWorldSid; // ptr to world SID
|
|
UNICODE_STRING ObSecName; // section name
|
|
OBJECT_ATTRIBUTES ObjA; // object attributes structure
|
|
WCHAR pwszSecName[MAX_PATH_LEN]; // ptr to section name string
|
|
ULONG rc = 0L; // return code
|
|
|
|
BASE_API_MSG m;
|
|
PBASE_NLS_PRESERVE_SECTION_MSG a = &m.u.NlsPreserveSection;
|
|
|
|
|
|
//
|
|
// Make sure we're in the critical section when entering this call.
|
|
//
|
|
ASSERT(NtCurrentTeb()->ClientId.UniqueThread == gcsTblPtrs.OwningThread);
|
|
|
|
//
|
|
// Open the data file.
|
|
//
|
|
if (rc = OpenDataFile( &hFile,
|
|
GET_VALUE_DATA_PTR(pKeyValueFull) ))
|
|
{
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Create the security descriptor.
|
|
//
|
|
if (rc = CreateSecurityDescriptor( pSecurityDescriptor,
|
|
&pWorldSid,
|
|
GENERIC_READ ))
|
|
{
|
|
NLS_FREE_MEM(pWorldSid);
|
|
NtClose(hFile);
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Create the section.
|
|
//
|
|
RtlZeroMemory(pwszSecName, MAX_PATH_LEN);
|
|
NlsStrCpyW(pwszSecName, pwszNlsPrefix);
|
|
NlsStrNCatW( pwszSecName,
|
|
(LPWSTR)pKeyValueFull->Name,
|
|
GET_WC_COUNT(pKeyValueFull->NameLength) );
|
|
|
|
RtlInitUnicodeString(&ObSecName, pwszSecName);
|
|
InitializeObjectAttributes( &ObjA,
|
|
&ObSecName,
|
|
OBJ_OPENIF | OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
pSecurityDescriptor );
|
|
|
|
rc = NtCreateSection( phSec,
|
|
SECTION_MAP_READ,
|
|
&ObjA,
|
|
NULL,
|
|
PAGE_READONLY,
|
|
SEC_COMMIT,
|
|
hFile );
|
|
|
|
//
|
|
// Free the memory used for the SID and close the file.
|
|
//
|
|
NLS_FREE_MEM(pWorldSid);
|
|
NtClose(hFile);
|
|
|
|
//
|
|
// Check for error from NtCreateSection.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
//
|
|
// If the name has already been created, ignore the error.
|
|
//
|
|
if (rc != STATUS_OBJECT_NAME_COLLISION)
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Create Section %wZ - %lx.\n",
|
|
&ObSecName, rc));
|
|
return (rc);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Call the server to preserve the section handle.
|
|
// Don't bother checking the error return, because the
|
|
// section was successfully created for this process.
|
|
//
|
|
a->hSection = *phSec;
|
|
|
|
CsrClientCallServer( (PCSR_API_MSG)&m,
|
|
NULL,
|
|
CSR_MAKE_API_NUMBER(BASESRV_SERVERDLL_INDEX,
|
|
BasepNlsPreserveSection),
|
|
sizeof(*a) );
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CreateSectionOneValue
|
|
//
|
|
// This routine creates a named memory mapped section for the given
|
|
// value under the given key in the registry.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define MAX_BUF 20
|
|
|
|
ULONG CreateSectionOneValue(
|
|
HANDLE hKeyHandle,
|
|
UINT Value,
|
|
UINT Base,
|
|
UINT Padding,
|
|
LPWSTR pNlsPrefix,
|
|
PVOID *ppBaseAddr)
|
|
{
|
|
WCHAR pTmpBuf[MAX_BUF]; // temp buffer
|
|
PKEY_VALUE_FULL_INFORMATION pKeyValueFull; // ptr to query info
|
|
BYTE pStatic[MAX_KEY_VALUE_FULLINFO]; // ptr to static buffer
|
|
HANDLE hSec = (HANDLE)0; // section handle
|
|
ULONG rc = 0L; // return code
|
|
BOOL IfAlloc = FALSE; // if buffer was allocated
|
|
|
|
|
|
//
|
|
// Make sure we're in the critical section when entering this call.
|
|
//
|
|
ASSERT(NtCurrentTeb()->ClientId.UniqueThread == gcsTblPtrs.OwningThread);
|
|
|
|
//
|
|
// Convert value to unicode string.
|
|
//
|
|
NLS_INTEGER_TO_UNICODE_STR( Value,
|
|
Base,
|
|
Padding,
|
|
pTmpBuf,
|
|
MAX_BUF );
|
|
|
|
//
|
|
// Query the registry for the value.
|
|
//
|
|
pKeyValueFull = (PKEY_VALUE_FULL_INFORMATION)pStatic;
|
|
if (rc = QueryRegValue( hKeyHandle,
|
|
pTmpBuf,
|
|
&pKeyValueFull,
|
|
MAX_KEY_VALUE_FULLINFO,
|
|
&IfAlloc ))
|
|
{
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Make sure there is data with this value.
|
|
//
|
|
if (pKeyValueFull->DataLength <= 2)
|
|
{
|
|
if (IfAlloc)
|
|
{
|
|
NLS_FREE_MEM(pKeyValueFull);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
//
|
|
// Create the section.
|
|
//
|
|
if (rc = CreateSectionFromReg( &hSec,
|
|
pKeyValueFull,
|
|
pNlsPrefix ))
|
|
{
|
|
if (IfAlloc)
|
|
{
|
|
NLS_FREE_MEM(pKeyValueFull);
|
|
}
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Free the buffer used for the query.
|
|
//
|
|
if (IfAlloc)
|
|
{
|
|
NLS_FREE_MEM(pKeyValueFull);
|
|
}
|
|
|
|
//
|
|
// Map a View of the Section.
|
|
//
|
|
if (rc = MapSection( hSec,
|
|
ppBaseAddr,
|
|
PAGE_READONLY,
|
|
TRUE ))
|
|
{
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CreateSection
|
|
//
|
|
// This routine creates a named memory mapped section for the given file
|
|
// name and section name and returns the handle to the section.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG CreateSection(
|
|
HANDLE *phSec,
|
|
LPWSTR pwszFileName,
|
|
LPWSTR pwszSecName)
|
|
{
|
|
HANDLE hFile = (HANDLE)0; // file handle
|
|
ULONG pSecurityDescriptor[MAX_PATH_LEN]; // security descriptor buffer
|
|
PSID pWorldSid; // ptr to world SID
|
|
UNICODE_STRING ObSecName; // section name
|
|
OBJECT_ATTRIBUTES ObjA; // object attributes structure
|
|
ULONG rc = 0L; // return code
|
|
|
|
BASE_API_MSG m;
|
|
PBASE_NLS_PRESERVE_SECTION_MSG a = &m.u.NlsPreserveSection;
|
|
|
|
|
|
//
|
|
// Don't need to be in the critical section here, since the
|
|
// server init routine calls this. All other calls made to
|
|
// this function should ensure that they are in a critical
|
|
// section.
|
|
//
|
|
// ASSERT(NtCurrentTeb()->ClientId.UniqueThread == gcsTblPtrs.OwningThread);
|
|
//
|
|
|
|
//
|
|
// Open the data file.
|
|
//
|
|
if (rc = OpenDataFile( &hFile,
|
|
pwszFileName ))
|
|
{
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Create the security descriptor.
|
|
//
|
|
if (rc = CreateSecurityDescriptor( pSecurityDescriptor,
|
|
&pWorldSid,
|
|
GENERIC_READ ))
|
|
{
|
|
NLS_FREE_MEM(pWorldSid);
|
|
NtClose(hFile);
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Create the section.
|
|
//
|
|
RtlInitUnicodeString(&ObSecName, pwszSecName);
|
|
InitializeObjectAttributes( &ObjA,
|
|
&ObSecName,
|
|
OBJ_OPENIF | OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
pSecurityDescriptor );
|
|
|
|
rc = NtCreateSection( phSec,
|
|
SECTION_MAP_READ,
|
|
&ObjA,
|
|
NULL,
|
|
PAGE_READONLY,
|
|
SEC_COMMIT,
|
|
hFile );
|
|
|
|
//
|
|
// Free the memory used for the SID and close the file.
|
|
//
|
|
NLS_FREE_MEM(pWorldSid);
|
|
NtClose(hFile);
|
|
|
|
//
|
|
// Check for error from NtCreateSection.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Create Section %wZ - %lx.\n",
|
|
&ObSecName, rc));
|
|
return (rc);
|
|
}
|
|
else if (rc != STATUS_OBJECT_NAME_EXISTS)
|
|
{
|
|
//
|
|
// Call the server to preserve the section handle.
|
|
// Don't bother checking the error return, because the
|
|
// section was successfully created for this process.
|
|
//
|
|
a->hSection = *phSec;
|
|
|
|
CsrClientCallServer( (PCSR_API_MSG)&m,
|
|
NULL,
|
|
CSR_MAKE_API_NUMBER(BASESRV_SERVERDLL_INDEX,
|
|
BasepNlsPreserveSection),
|
|
sizeof(*a) );
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CreateSectionTemp
|
|
//
|
|
// This routine creates a temporary memory mapped section for the given file
|
|
// name and returns the handle to the section.
|
|
//
|
|
// 09-01-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG CreateSectionTemp(
|
|
HANDLE *phSec,
|
|
LPWSTR pwszFileName)
|
|
{
|
|
HANDLE hFile = (HANDLE)0; // file handle
|
|
OBJECT_ATTRIBUTES ObjA; // object attributes structure
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Make sure we're in the critical section when entering this call.
|
|
//
|
|
ASSERT(NtCurrentTeb()->ClientId.UniqueThread == gcsTblPtrs.OwningThread);
|
|
|
|
//
|
|
// Open the data file.
|
|
//
|
|
if (rc = OpenDataFile( &hFile,
|
|
pwszFileName ))
|
|
{
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Create the section.
|
|
//
|
|
InitializeObjectAttributes( &ObjA,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL );
|
|
|
|
rc = NtCreateSection( phSec,
|
|
SECTION_MAP_READ,
|
|
&ObjA,
|
|
NULL,
|
|
PAGE_READONLY,
|
|
SEC_COMMIT,
|
|
hFile );
|
|
|
|
//
|
|
// Close the file.
|
|
//
|
|
NtClose(hFile);
|
|
|
|
//
|
|
// Check for error from NtCreateSection.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Create Temp Section for %ws - %lx.\n",
|
|
pwszFileName, rc));
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (rc);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// OpenSection
|
|
//
|
|
// This routine opens the named memory mapped section for the given section
|
|
// name and returns the handle to the section.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG OpenSection(
|
|
HANDLE *phSec,
|
|
PUNICODE_STRING pObSectionName,
|
|
PVOID *ppBaseAddr,
|
|
ULONG AccessMask,
|
|
BOOL bCloseHandle)
|
|
{
|
|
OBJECT_ATTRIBUTES ObjA; // object attributes structure
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Make sure we're in the critical section when entering this call.
|
|
//
|
|
ASSERT(NtCurrentTeb()->ClientId.UniqueThread == gcsTblPtrs.OwningThread);
|
|
|
|
//
|
|
// Open the Section.
|
|
//
|
|
InitializeObjectAttributes( &ObjA,
|
|
pObSectionName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL );
|
|
|
|
rc = NtOpenSection( phSec,
|
|
AccessMask,
|
|
&ObjA );
|
|
|
|
//
|
|
// Check for error from NtOpenSection.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Map a View of the Section.
|
|
//
|
|
if (rc = MapSection( *phSec,
|
|
ppBaseAddr,
|
|
PAGE_READONLY,
|
|
FALSE ))
|
|
{
|
|
NtClose(*phSec);
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Close the handle to the section. Once the section has been mapped,
|
|
// the pointer to the base address will remain valid until the section
|
|
// is unmapped. It is not necessary to leave the handle to the section
|
|
// around.
|
|
//
|
|
if (bCloseHandle)
|
|
{
|
|
NtClose(*phSec);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MapSection
|
|
//
|
|
// This routine maps a view of the section to the current process and adds
|
|
// the appropriate information to the hash table.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG MapSection(
|
|
HANDLE hSec,
|
|
PVOID *ppBaseAddr,
|
|
ULONG PageProtection,
|
|
BOOL bCloseHandle)
|
|
{
|
|
ULONG ViewSize; // view size of mapped section
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Make sure we're in the critical section when entering this call.
|
|
//
|
|
ASSERT(NtCurrentTeb()->ClientId.UniqueThread == gcsTblPtrs.OwningThread);
|
|
|
|
//
|
|
// Map a View of the Section.
|
|
//
|
|
*ppBaseAddr = (PVOID)NULL;
|
|
ViewSize = 0L;
|
|
|
|
rc = NtMapViewOfSection( hSec,
|
|
NtCurrentProcess(),
|
|
ppBaseAddr,
|
|
0L,
|
|
0L,
|
|
NULL,
|
|
&ViewSize,
|
|
ViewUnmap,
|
|
0L,
|
|
PageProtection );
|
|
|
|
//
|
|
// Close the handle to the section. Once the section has been mapped,
|
|
// the pointer to the base address will remain valid until the section
|
|
// is unmapped. It is not necessary to leave the handle to the section
|
|
// around.
|
|
//
|
|
if (bCloseHandle)
|
|
{
|
|
NtClose(hSec);
|
|
}
|
|
|
|
//
|
|
// Check for error from NtMapViewOfSection.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Map View of Section - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// UnMapSection
|
|
//
|
|
// This routine unmaps a view of the given section to the current process.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG UnMapSection(
|
|
PVOID pBaseAddr)
|
|
{
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Make sure we're in the critical section when entering this call.
|
|
//
|
|
ASSERT(NtCurrentTeb()->ClientId.UniqueThread == gcsTblPtrs.OwningThread);
|
|
|
|
//
|
|
// UnMap a View of the Section.
|
|
//
|
|
rc = NtUnmapViewOfSection( NtCurrentProcess(),
|
|
pBaseAddr );
|
|
|
|
//
|
|
// Check for error from NtUnmapViewOfSection.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Unmap View of Section - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetNlsSectionName
|
|
//
|
|
// This routine returns a section name by concatenating the given
|
|
// section prefix and the given integer value converted to a string.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG GetNlsSectionName(
|
|
UINT Value,
|
|
UINT Base,
|
|
UINT Padding,
|
|
LPWSTR pwszPrefix,
|
|
LPWSTR pwszSecName)
|
|
{
|
|
//
|
|
// Create section name string.
|
|
//
|
|
NlsStrCpyW(pwszSecName, pwszPrefix);
|
|
NLS_INTEGER_TO_UNICODE_STR( Value,
|
|
Base,
|
|
Padding,
|
|
pwszSecName + NlsStrLenW(pwszSecName),
|
|
MAX_PATH_LEN );
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetScriptMemberWeights
|
|
//
|
|
// Gets the script member sorting order from the registry. If the order
|
|
// is different from the default order, it then sets the SMWeight array
|
|
// in the table pointers structure to the correct values and sets the
|
|
// IfModify_SMWeight flag to TRUE.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG GetScriptMemberWeights()
|
|
{
|
|
DWORD ctr, ctr2; // loop counters
|
|
ULONG Index = 0; // index for enumeration
|
|
PKEY_VALUE_FULL_INFORMATION pKeyValueFull; // ptr to full info for enum
|
|
BYTE pStatic[MAX_KEY_VALUE_FULLINFO]; // ptr to static buffer for enum
|
|
PVOID pBuffer = NULL; // ptr to alloc buffer for enum
|
|
ULONG BufSize; // size of buffer
|
|
ULONG ResultLength; // # bytes written
|
|
UNICODE_STRING ObUnicodeStr; // unicode string
|
|
ULONG SortOrder; // sort order from registry
|
|
ULONG Script; // script from registry
|
|
ULONG rc = 0L; // return code
|
|
BYTE RegVal[NUM_SM]; // registry value for script
|
|
BYTE NewScript; // new script to store
|
|
BYTE SM; // script member value
|
|
LPBYTE pSMWeight = pTblPtrs->SMWeight; // ptr to script member weights
|
|
PMULTI_WT pMulti; // ptr to multi weight
|
|
HANDLE hKey = NULL; // handle to registry key
|
|
|
|
|
|
//
|
|
// Enter table pointers critical section.
|
|
//
|
|
RtlEnterCriticalSection(&gcsTblPtrs);
|
|
|
|
//
|
|
// Make sure the SMWeight structure still hasn't been initialized.
|
|
//
|
|
// NOTE: Must leave the first value set to INVALID_SM_VALUE until
|
|
// this function is complete.
|
|
//
|
|
if (pSMWeight[0] != INVALID_SM_VALUE)
|
|
{
|
|
RtlLeaveCriticalSection(&gcsTblPtrs);
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
//
|
|
// Set the 0 to FIRST_SCRIPT of script structure to its default
|
|
// value and the RegVal structure to zero.
|
|
//
|
|
// NOTE: The intermediate RegVal array is necessary because:
|
|
// (1) Enumeration may produce values out of order
|
|
// (2) There may be multiple weight entries in the list
|
|
// As a result, it is not correct to simply increment
|
|
// the sorting order by the value given in the registry.
|
|
//
|
|
RtlZeroMemory(RegVal, NUM_SM);
|
|
RtlZeroMemory(pSMWeight + 1, NUM_SM - 1);
|
|
|
|
for (ctr = 1; ctr < FIRST_SCRIPT; ctr++)
|
|
{
|
|
pSMWeight[ctr] = (BYTE)ctr;
|
|
}
|
|
|
|
//
|
|
// Enumerate through all values in the registry. Store the
|
|
// data in the RegVal structure if it exists.
|
|
//
|
|
// NOTE: Values range from (1) to (NUM_SM - FIRST_SCRIPT).
|
|
//
|
|
OPEN_CPANEL_SORTING_KEY(hKey, (ULONG)STATUS_REGISTRY_CORRUPT);
|
|
|
|
pKeyValueFull = (PKEY_VALUE_FULL_INFORMATION)pStatic;
|
|
BufSize = MAX_KEY_VALUE_FULLINFO;
|
|
RtlZeroMemory(pKeyValueFull, BufSize);
|
|
rc = NtEnumerateValueKey( hKey,
|
|
Index,
|
|
KeyValueFullInformation,
|
|
pKeyValueFull,
|
|
BufSize,
|
|
&ResultLength );
|
|
|
|
while (rc != STATUS_NO_MORE_ENTRIES)
|
|
{
|
|
if (rc == STATUS_BUFFER_OVERFLOW)
|
|
{
|
|
//
|
|
// Free old buffer if it was allocated before allocating
|
|
// a new buffer.
|
|
//
|
|
NLS_REG_BUFFER_FREE(pBuffer);
|
|
|
|
//
|
|
// Buffer is too small, so allocate a new one.
|
|
//
|
|
NLS_REG_BUFFER_ALLOC(pKeyValueFull, ResultLength, pBuffer, TRUE);
|
|
BufSize = ResultLength;
|
|
RtlZeroMemory(pKeyValueFull, BufSize);
|
|
rc = NtEnumerateValueKey( hKey,
|
|
Index,
|
|
KeyValueFullInformation,
|
|
pKeyValueFull,
|
|
BufSize,
|
|
&ResultLength );
|
|
}
|
|
|
|
if (rc != NO_ERROR)
|
|
{
|
|
NLS_REG_BUFFER_FREE(pBuffer);
|
|
CLOSE_REG_KEY(hKey);
|
|
KdPrint(("NLSAPI: Error in getting Script Member Weights - %lx.\n",
|
|
rc));
|
|
RtlLeaveCriticalSection(&gcsTblPtrs);
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Convert the string value to an integer if data exists for
|
|
// the value.
|
|
//
|
|
if (pKeyValueFull->DataLength > 2)
|
|
{
|
|
//
|
|
// Convert the value to an integer.
|
|
//
|
|
RtlInitUnicodeString(&ObUnicodeStr, pKeyValueFull->Name);
|
|
if ((RtlUnicodeStringToInteger(&ObUnicodeStr, 10, &SortOrder)) ||
|
|
(SortOrder > (NUM_SM - FIRST_SCRIPT)))
|
|
{
|
|
//
|
|
// Report that there was an error in the registry.
|
|
//
|
|
KdPrint(("NLSAPI: Sorting Order Registry Value Corrupt.\n"));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Convert the data to an integer and save it in the
|
|
// RegVal structure.
|
|
//
|
|
RtlInitUnicodeString( &ObUnicodeStr,
|
|
GET_VALUE_DATA_PTR(pKeyValueFull) );
|
|
if ((RtlUnicodeStringToInteger(&ObUnicodeStr, 10, &Script)) ||
|
|
(Script >= NUM_SM) || (Script < FIRST_SCRIPT))
|
|
{
|
|
//
|
|
// Report that there was an error in the registry.
|
|
//
|
|
KdPrint(("NLSAPI: Sorting Order Registry Data Corrupt.\n"));
|
|
}
|
|
else
|
|
{
|
|
RegVal[SortOrder] = (BYTE)Script;
|
|
if (SortOrder != (ULONG)(Script - FIRST_SCRIPT + 1))
|
|
{
|
|
//
|
|
// No longer default order. Set the boolean to TRUE.
|
|
//
|
|
pTblPtrs->IfModify_SMWeight = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Increment enumeration index value and get the next enumeration.
|
|
//
|
|
Index++;
|
|
RtlZeroMemory(pKeyValueFull, BufSize);
|
|
rc = NtEnumerateValueKey( hKey,
|
|
Index,
|
|
KeyValueFullInformation,
|
|
pKeyValueFull,
|
|
BufSize,
|
|
&ResultLength );
|
|
}
|
|
|
|
//
|
|
// Free the buffer used for the enumeration.
|
|
//
|
|
NLS_REG_BUFFER_FREE(pBuffer);
|
|
|
|
//
|
|
// Store the values in the SMWeight array in the table
|
|
// pointers structure only if the IfModify_SMWeight boolean is set
|
|
// to TRUE.
|
|
//
|
|
if (pTblPtrs->IfModify_SMWeight)
|
|
{
|
|
//
|
|
// Not using default table, so set the SMWeight array to the
|
|
// correct order.
|
|
//
|
|
NewScript = FIRST_SCRIPT;
|
|
for (ctr = 1; ctr < NUM_SM; ctr++)
|
|
{
|
|
//
|
|
// For each registry value, store the appropriate order in
|
|
// each of the script member fields.
|
|
//
|
|
if ((SM = RegVal[ctr]) != 0)
|
|
{
|
|
//
|
|
// Save the order in the SMWeight array.
|
|
//
|
|
pSMWeight[SM] = NewScript;
|
|
NewScript++;
|
|
|
|
//
|
|
// Make sure the script is not part of a multiple weights
|
|
// script.
|
|
//
|
|
pMulti = pTblPtrs->pMultiWeight;
|
|
for (ctr2 = pTblPtrs->NumMultiWeight; ctr2 > 0; ctr2--, pMulti++)
|
|
{
|
|
if (pMulti->FirstSM == SM)
|
|
{
|
|
//
|
|
// Part of multiple weight, so must move entire range
|
|
// by setting each value in range to NewScript and
|
|
// then incrementing NewScript.
|
|
//
|
|
// NOTE: May use 'ctr2' here since it ALWAYS breaks
|
|
// out of outer for loop.
|
|
//
|
|
for (ctr2 = 1; ctr2 < pMulti->NumSM; ctr2++)
|
|
{
|
|
pSMWeight[SM + ctr2] = NewScript;
|
|
NewScript++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Must set each script member that has not yet been reset to its
|
|
// new order.
|
|
//
|
|
// The default ordering is to assign:
|
|
// Order = Script Member Value
|
|
//
|
|
// Therefore, can simply set each zero entry in order to the end
|
|
// of the array to the next 'NewScript' value.
|
|
//
|
|
for (ctr = FIRST_SCRIPT; ctr < NUM_SM; ctr++)
|
|
{
|
|
//
|
|
// If it's a zero value, set it to the next sorting order value.
|
|
//
|
|
if (pSMWeight[ctr] == 0)
|
|
{
|
|
pSMWeight[ctr] = NewScript;
|
|
NewScript++;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Close the sorting key handle.
|
|
//
|
|
CLOSE_REG_KEY(hKey);
|
|
|
|
//
|
|
// Set the first value to be valid.
|
|
//
|
|
pSMWeight[0] = 0;
|
|
RtlLeaveCriticalSection(&gcsTblPtrs);
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------//
|
|
// INTERNAL ROUTINES //
|
|
//-------------------------------------------------------------------------//
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// OpenDataFile
|
|
//
|
|
// This routine opens the data file for the specified file name and
|
|
// returns the handle to the file.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG OpenDataFile(
|
|
HANDLE *phFile,
|
|
LPWSTR pFile)
|
|
{
|
|
UNICODE_STRING ObFileName; // file name
|
|
OBJECT_ATTRIBUTES ObjA; // object attributes structure
|
|
IO_STATUS_BLOCK iosb; // IO status block
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Get the NT file name.
|
|
//
|
|
if (rc = GetNTFileName( pFile,
|
|
&ObFileName ))
|
|
{
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Open the file.
|
|
//
|
|
InitializeObjectAttributes( &ObjA,
|
|
&ObFileName,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL );
|
|
|
|
rc = NtOpenFile( phFile,
|
|
FILE_READ_DATA | SYNCHRONIZE,
|
|
&ObjA,
|
|
&iosb,
|
|
FILE_SHARE_READ,
|
|
FILE_SYNCHRONOUS_IO_NONALERT );
|
|
|
|
//
|
|
// Free the buffer used for the file name.
|
|
//
|
|
RtlFreeHeap( RtlProcessHeap(),
|
|
0,
|
|
ObFileName.Buffer );
|
|
|
|
//
|
|
// Check for error from NtOpenFile.
|
|
//
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Open File %wZ - %lx.\n", &ObFileName, rc));
|
|
return (rc);
|
|
}
|
|
if (!NT_SUCCESS(iosb.Status))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Open File %wZ - Status = %lx.\n",
|
|
&ObFileName, iosb.Status));
|
|
return ((ULONG)iosb.Status);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// GetNTFileName
|
|
//
|
|
// This routine returns the full path name for the data file found in
|
|
// the given registry information buffer.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG GetNTFileName(
|
|
LPWSTR pFile,
|
|
PUNICODE_STRING pFileName)
|
|
{
|
|
WCHAR pwszFilePath[MAX_PATH_LEN]; // ptr to file path string
|
|
UNICODE_STRING ObFileName; // file name
|
|
ULONG rc = 0L; // return code
|
|
|
|
|
|
//
|
|
// Get the full path name for the file.
|
|
//
|
|
GetSystemDirectoryW(pwszFilePath, MAX_PATH_LEN);
|
|
NlsStrCatW(pwszFilePath, L"\\");
|
|
NlsStrCatW(pwszFilePath, pFile);
|
|
|
|
//
|
|
// Make the file name an NT path name.
|
|
//
|
|
RtlInitUnicodeString(&ObFileName, pwszFilePath);
|
|
if (!RtlDosPathNameToNtPathName_U( ObFileName.Buffer,
|
|
pFileName,
|
|
NULL,
|
|
NULL ))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT convert %wZ to NT path name - %lx.\n",
|
|
&ObFileName, rc));
|
|
return (ERROR_FILE_NOT_FOUND);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CreateSecurityDescriptor
|
|
//
|
|
// This routine creates the security descriptor needed to create the
|
|
// memory mapped section for a data file and returns the world SID.
|
|
//
|
|
// 05-31-91 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG CreateSecurityDescriptor(
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
PSID *ppWorldSid,
|
|
ACCESS_MASK AccessMask)
|
|
{
|
|
ULONG rc = 0L; // return code
|
|
PACL pAclBuffer; // ptr to ACL buffer
|
|
ULONG SidLength; // length of SID - 1 sub authority
|
|
PSID pWSid; // ptr to world SID
|
|
SID_IDENTIFIER_AUTHORITY SidAuth = SECURITY_WORLD_SID_AUTHORITY;
|
|
|
|
|
|
//
|
|
// Create World SID.
|
|
//
|
|
SidLength = RtlLengthRequiredSid(1);
|
|
|
|
if ((pWSid = (PSID)NLS_ALLOC_MEM(SidLength)) == NULL)
|
|
{
|
|
*ppWorldSid = NULL;
|
|
KdPrint(("NLSAPI: Could NOT Allocate SID Buffer.\n"));
|
|
return (ERROR_OUTOFMEMORY);
|
|
}
|
|
*ppWorldSid = pWSid;
|
|
|
|
RtlInitializeSid( pWSid,
|
|
&SidAuth,
|
|
1 );
|
|
|
|
*(RtlSubAuthoritySid(pWSid, 0)) = SECURITY_WORLD_RID;
|
|
|
|
//
|
|
// Initialize Security Descriptor.
|
|
//
|
|
rc = RtlCreateSecurityDescriptor( pSecurityDescriptor,
|
|
SECURITY_DESCRIPTOR_REVISION );
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Create Security Descriptor - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Initialize ACL.
|
|
//
|
|
pAclBuffer = (PACL)((PBYTE)pSecurityDescriptor + SECURITY_DESCRIPTOR_MIN_LENGTH);
|
|
rc = RtlCreateAcl( (PACL)pAclBuffer,
|
|
MAX_PATH_LEN * sizeof(ULONG),
|
|
ACL_REVISION2 );
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Create ACL - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Add an ACE to the ACL that allows World GENERIC_READ to the
|
|
// section object.
|
|
//
|
|
rc = RtlAddAccessAllowedAce( (PACL)pAclBuffer,
|
|
ACL_REVISION2,
|
|
AccessMask,
|
|
pWSid );
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Add Access Allowed ACE - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Assign the DACL to the security descriptor.
|
|
//
|
|
rc = RtlSetDaclSecurityDescriptor( (PSECURITY_DESCRIPTOR)pSecurityDescriptor,
|
|
(BOOLEAN)TRUE,
|
|
(PACL)pAclBuffer,
|
|
(BOOLEAN)FALSE );
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Set DACL Security Descriptor - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AppendAccessAllowedACE
|
|
//
|
|
// This routine adds an ACE to the ACL for administrators.
|
|
//
|
|
// 03-08-93 JulieB Created.
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
ULONG AppendAccessAllowedACE(
|
|
PSECURITY_DESCRIPTOR pSecurityDescriptor,
|
|
ACCESS_MASK AccessMask)
|
|
{
|
|
ULONG rc = 0L; // return code
|
|
PACL pDaclBuffer; // ptr to DACL buffer
|
|
ULONG SidLength; // length of SID - 2 sub authorities
|
|
PSID pWSid; // ptr to world SID
|
|
SID_IDENTIFIER_AUTHORITY SidAuth = SECURITY_NT_AUTHORITY;
|
|
BOOLEAN DaclPresent;
|
|
BOOLEAN DaclDefaulted;
|
|
|
|
|
|
//
|
|
// Create World SID.
|
|
//
|
|
SidLength = RtlLengthRequiredSid(2);
|
|
|
|
if ((pWSid = (PSID)NLS_ALLOC_MEM(SidLength)) == NULL)
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Allocate SID Buffer.\n"));
|
|
return (ERROR_OUTOFMEMORY);
|
|
}
|
|
|
|
RtlInitializeSid( pWSid,
|
|
&SidAuth,
|
|
2 );
|
|
|
|
*(RtlSubAuthoritySid(pWSid, 0)) = SECURITY_BUILTIN_DOMAIN_RID;
|
|
*(RtlSubAuthoritySid(pWSid, 1)) = DOMAIN_ALIAS_RID_ADMINS;
|
|
|
|
//
|
|
// Get DACL.
|
|
//
|
|
rc = RtlGetDaclSecurityDescriptor( pSecurityDescriptor,
|
|
&DaclPresent,
|
|
&pDaclBuffer,
|
|
&DaclDefaulted );
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Get DACL Security Descriptor - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Add an ACE to the ACL that allows Admin query access to the
|
|
// section object.
|
|
//
|
|
rc = RtlAddAccessAllowedAce( (PACL)pDaclBuffer,
|
|
ACL_REVISION2,
|
|
AccessMask,
|
|
pWSid );
|
|
if (!NT_SUCCESS(rc))
|
|
{
|
|
KdPrint(("NLSAPI: Could NOT Add Access Allowed ACE - %lx.\n", rc));
|
|
return (rc);
|
|
}
|
|
|
|
//
|
|
// Free SID.
|
|
//
|
|
NLS_FREE_MEM(pWSid);
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (NO_ERROR);
|
|
}
|
|
|
|
|