archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/base/win32/client/compname.c

4522 lines
112 KiB
Raw Blame History

/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
COMPNAME.C
Abstract:
This module contains the GetComputerName and SetComputerName APIs.
Also: DnsHostnameToComputerName
AddLocalAlternateComputerName
RemoveLocalAlternateComputerName
SetLocalPrimaryComputerName
EnumerateLocalComputerNames
Author:
Dan Hinsley (DanHi) 2-Apr-1992
Revision History:
Greg Johnson (gregjohn) 13-Feb-2001
Notes:
Currently there is no way to enumerate the list of Alternate Netbios
names. Presumably this will be fixed in a future release (Blackcomb?).
The flags parameter to all the *Local* API's is for this use.
--*/
#include <basedll.h>
#include <dnsapi.h>
typedef DNS_STATUS
(WINAPI DNS_VALIDATE_NAME_FN)(
IN LPCWSTR Name,
IN DNS_NAME_FORMAT Format
);
//
//
#define REASONABLE_LENGTH 128
#define COMPUTERNAME_ROOT \
L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\ComputerName"
#define NON_VOLATILE_COMPUTERNAME_NODE \
L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\ComputerName\\ComputerName"
#define VOLATILE_COMPUTERNAME_NODE \
L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\ComputerName\\ActiveComputerName"
#define ALT_COMPUTERNAME_NODE \
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\LanmanServer\\Parameters"
#define VOLATILE_COMPUTERNAME L"ActiveComputerName"
#define NON_VOLATILE_COMPUTERNAME L"ComputerName"
#define COMPUTERNAME_VALUE_NAME L"ComputerName"
#define COMPUTERNAME_OPTIONAL_NAME L"OptionalNames"
#define CLASS_STRING L"Network ComputerName"
#define TCPIP_POLICY_ROOT \
L"\\Registry\\Machine\\Software\\Policies\\Microsoft\\System\\DNSclient"
#define TCPIP_POLICY_DOMAINNAME \
L"PrimaryDnsSuffix"
#define TCPIP_ROOT \
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\Tcpip\\Parameters"
#define TCPIP_HOSTNAME \
L"Hostname"
#define TCPIP_NV_HOSTNAME \
L"NV Hostname"
#define TCPIP_DOMAINNAME \
L"Domain"
#define TCPIP_NV_DOMAINNAME \
L"NV Domain"
#define DNSCACHE_ROOT \
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\DnsCache\\Parameters"
#define DNS_ALT_HOSTNAME \
L"AlternateComputerNames"
//
// Allow the cluster guys to override the returned
// names with their own virtual names
//
const PWSTR ClusterNameVars[] = {
L"_CLUSTER_NETWORK_NAME_",
L"_CLUSTER_NETWORK_HOSTNAME_",
L"_CLUSTER_NETWORK_DOMAIN_",
L"_CLUSTER_NETWORK_FQDN_"
};
//
// Disallowed control characters (not including \0)
//
#define CTRL_CHARS_0 L"\001\002\003\004\005\006\007"
#define CTRL_CHARS_1 L"\010\011\012\013\014\015\016\017"
#define CTRL_CHARS_2 L"\020\021\022\023\024\025\026\027"
#define CTRL_CHARS_3 L"\030\031\032\033\034\035\036\037"
#define CTRL_CHARS_STR CTRL_CHARS_0 CTRL_CHARS_1 CTRL_CHARS_2 CTRL_CHARS_3
//
// Combinations of the above
//
#define ILLEGAL_NAME_CHARS_STR L"\"/\\[]:|<>+=;,?" CTRL_CHARS_STR
WCHAR DnsApiDllString[] = L"DNSAPI.DLL";
#define DNS_HOSTNAME 0
#define DNS_DOMAINNAME 1
DWORD
BaseMultiByteToWideCharWithAlloc(
LPCSTR lpBuffer,
LPWSTR * ppBufferW
)
/*++
Routine Description:
Converts Ansi strings to Unicode strings and allocs it's own space.
Arguments:
lpBuffer - Ansi to convert
ppBufferW - Unicode result
Return Value:
ERROR_SUCCESS, or various failures
--*/
{
ULONG cchBuffer = 0;
BOOL fSuccess = TRUE;
if (lpBuffer==NULL) {
*ppBufferW=NULL;
return ERROR_SUCCESS;
}
cchBuffer = strlen(lpBuffer);
// get enough space to cover the string and a trailing null
*ppBufferW = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (cchBuffer + 1) * sizeof(WCHAR));
if (*ppBufferW==NULL) {
return ERROR_NOT_ENOUGH_MEMORY;
}
fSuccess = MultiByteToWideChar(CP_ACP,
0,
lpBuffer,
(cchBuffer+1)*sizeof(CHAR),
*ppBufferW,
cchBuffer+1
);
if (fSuccess) {
return ERROR_SUCCESS;
}
else {
return GetLastError();
}
}
DWORD
BaseWideCharToMultiByteWithAlloc(
LPCWSTR lpBuffer,
LPSTR * ppBufferA
)
/*++
Routine Description:
Converts Unicode strings to Ansi strings and allocs it's own space.
Arguments:
lpBuffer - Unicode to convert
ppBufferA - Ansi result
Return Value:
ERROR_SUCCESS, or various failures
--*/
{
ULONG cchBuffer = 0;
DWORD err = ERROR_SUCCESS;
cchBuffer = wcslen(lpBuffer);
*ppBufferA = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (cchBuffer + 1) * sizeof(CHAR));
if (*ppBufferA==NULL) {
return ERROR_NOT_ENOUGH_MEMORY;
}
err = WideCharToMultiByte(CP_ACP,
0,
lpBuffer,
cchBuffer+1,
*ppBufferA,
(cchBuffer+1)*sizeof(CHAR),
NULL,
NULL
);
if (err!=0) {
return ERROR_SUCCESS;
}
else {
return GetLastError();
}
}
//
// Worker routine
//
NTSTATUS
GetNameFromValue(
HANDLE hKey,
LPWSTR SubKeyName,
LPWSTR ValueValue,
LPDWORD nSize
)
/*++
Routine Description:
This returns the value of "ComputerName" value entry under the subkey
SubKeyName relative to hKey. This is used to get the value of the
ActiveComputerName or ComputerName values.
Arguments:
hKey - handle to the Key the SubKey exists under
SubKeyName - name of the subkey to look for the value under
ValueValue - where the value of the value entry will be returned
nSize - pointer to the size (in characters) of the ValueValue buffer
Return Value:
--*/
{
#define VALUE_BUFFER_SIZE (sizeof(KEY_VALUE_FULL_INFORMATION) + \
(sizeof( COMPUTERNAME_VALUE_NAME ) + MAX_COMPUTERNAME_LENGTH + 1) * sizeof(WCHAR))
NTSTATUS NtStatus;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE hSubKey;
BYTE ValueBuffer[VALUE_BUFFER_SIZE];
PKEY_VALUE_FULL_INFORMATION pKeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)ValueBuffer;
DWORD ValueLength;
PWCHAR pTerminator;
//
// Open the node for the Subkey
//
RtlInitUnicodeString(&KeyName, SubKeyName);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
hKey,
NULL
);
NtStatus = NtOpenKey(&hSubKey, KEY_READ, &ObjectAttributes);
if (NT_SUCCESS(NtStatus)) {
RtlInitUnicodeString(&ValueName, COMPUTERNAME_VALUE_NAME);
NtStatus = NtQueryValueKey(hSubKey,
&ValueName,
KeyValueFullInformation,
pKeyValueInformation,
VALUE_BUFFER_SIZE,
&ValueLength);
NtClose(hSubKey);
if (NT_SUCCESS(NtStatus) &&
(pKeyValueInformation->DataLength > 0 )) {
//
// If the user's buffer is big enough, move it in
// First see if it's null terminated. If it is, pretend like
// it's not.
//
pTerminator = (PWCHAR)((PBYTE) pKeyValueInformation +
pKeyValueInformation->DataOffset +
pKeyValueInformation->DataLength);
pTerminator--;
if (*pTerminator == L'\0') {
pKeyValueInformation->DataLength -= sizeof(WCHAR);
}
if (*nSize >= pKeyValueInformation->DataLength/sizeof(WCHAR) + 1) {
//
// This isn't guaranteed to be NULL terminated, make it so
//
RtlCopyMemory(ValueValue,
(LPWSTR)((PBYTE) pKeyValueInformation +
pKeyValueInformation->DataOffset),
pKeyValueInformation->DataLength);
pTerminator = (PWCHAR) ((PBYTE) ValueValue +
pKeyValueInformation->DataLength);
*pTerminator = L'\0';
//
// Return the number of characters to the caller
//
*nSize = wcslen(ValueValue);
}
else {
NtStatus = STATUS_BUFFER_OVERFLOW;
*nSize = pKeyValueInformation->DataLength/sizeof(WCHAR) + 1;
}
}
else {
//
// If the value has been deleted (zero length data),
// return object not found.
//
if ( NT_SUCCESS( NtStatus ) )
{
NtStatus = STATUS_OBJECT_NAME_NOT_FOUND ;
}
}
}
return(NtStatus);
}
VOID
BaseConvertCharFree(
VOID * lpBuffer
)
/*++
Routine Description:
Frees space Convert functions.
Arguments:
lpBuffer - Buffer to free
Return Value:
None!
--*/
{
if (lpBuffer!=NULL) {
RtlFreeHeap(RtlProcessHeap(), 0, lpBuffer);
}
}
NTSTATUS
BasepGetNameFromReg(
PCWSTR Path,
PCWSTR Value,
PWSTR Buffer,
PDWORD Length
)
/*++
Routine Description:
This routine gets a string from the value at the specified registry key.
Arguments:
Path - Path to the registry key
Value - Name of the value to retrieve
Buffer - Buffer to return the value
Length - size of the buffer in characters
Return Value:
STATUS_SUCCESS, or various failures
--*/
{
NTSTATUS Status ;
HANDLE Key ;
OBJECT_ATTRIBUTES ObjA ;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
BYTE ValueBuffer[ REASONABLE_LENGTH ];
PKEY_VALUE_FULL_INFORMATION pKeyValueInformation = (PKEY_VALUE_FULL_INFORMATION)ValueBuffer;
BOOLEAN FreeBuffer = FALSE ;
DWORD ValueLength;
PWCHAR pTerminator;
//
// Open the node for the Subkey
//
RtlInitUnicodeString(&KeyName, Path );
InitializeObjectAttributes(&ObjA,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = NtOpenKey(&Key, KEY_READ, &ObjA );
if (NT_SUCCESS(Status)) {
RtlInitUnicodeString( &ValueName, Value );
Status = NtQueryValueKey(Key,
&ValueName,
KeyValueFullInformation,
pKeyValueInformation,
REASONABLE_LENGTH ,
&ValueLength);
if ( Status == STATUS_BUFFER_OVERFLOW )
{
pKeyValueInformation = RtlAllocateHeap( RtlProcessHeap(),
0,
ValueLength );
if ( pKeyValueInformation )
{
FreeBuffer = TRUE ;
Status = NtQueryValueKey( Key,
&ValueName,
KeyValueFullInformation,
pKeyValueInformation,
ValueLength,
&ValueLength );
}
}
if ( NT_SUCCESS(Status) ) {
//
// If the user's buffer is big enough, move it in
// First see if it's null terminated. If it is, pretend like
// it's not.
//
pTerminator = (PWCHAR)((PBYTE) pKeyValueInformation +
pKeyValueInformation->DataOffset +
pKeyValueInformation->DataLength);
pTerminator--;
if (*pTerminator == L'\0') {
pKeyValueInformation->DataLength -= sizeof(WCHAR);
}
if ( ( *Length >= pKeyValueInformation->DataLength/sizeof(WCHAR) + 1) &&
( Buffer != NULL ) ) {
//
// This isn't guaranteed to be NULL terminated, make it so
//
RtlCopyMemory(Buffer,
(LPWSTR)((PBYTE) pKeyValueInformation +
pKeyValueInformation->DataOffset),
pKeyValueInformation->DataLength);
pTerminator = (PWCHAR) ((PBYTE) Buffer +
pKeyValueInformation->DataLength);
*pTerminator = L'\0';
//
// Return the number of characters to the caller
//
*Length = pKeyValueInformation->DataLength / sizeof(WCHAR) ;
}
else {
Status = STATUS_BUFFER_OVERFLOW;
*Length = pKeyValueInformation->DataLength/sizeof(WCHAR) + 1;
}
}
NtClose( Key );
}
if ( FreeBuffer )
{
RtlFreeHeap( RtlProcessHeap(), 0, pKeyValueInformation );
}
return Status ;
}
NTSTATUS
BaseSetNameInReg(
PCWSTR Path,
PCWSTR Value,
PCWSTR Buffer
)
/*++
Routine Description:
This routine sets a string in the value at the registry key.
Arguments:
Path - Path to the registry key
Value - Name of the value to set
Buffer - Buffer to set
Return Value:
STATUS_SUCCESS, or various failures
--*/
{
NTSTATUS NtStatus;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE hKey = NULL;
ULONG ValueLength;
//
// Open the ComputerName\ComputerName node
//
RtlInitUnicodeString(&KeyName, Path);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
NtStatus = NtOpenKey(&hKey, KEY_READ | KEY_WRITE, &ObjectAttributes);
if ( !NT_SUCCESS( NtStatus ) )
{
return NtStatus ;
}
//
// Update the value under this key
//
RtlInitUnicodeString(&ValueName, Value);
ValueLength = (wcslen( Buffer ) + 1) * sizeof(WCHAR);
NtStatus = NtSetValueKey(hKey,
&ValueName,
0,
REG_SZ,
(LPWSTR) Buffer,
ValueLength);
if ( NT_SUCCESS( NtStatus ) )
{
NtFlushKey( hKey );
}
NtClose(hKey);
return NtStatus ;
}
NTSTATUS
BaseSetMultiNameInReg(
PCWSTR Path,
PCWSTR Value,
PCWSTR Buffer,
DWORD BufferSize
)
/*++
Routine Description:
This routine sets a string in the value at the specified multivalued registry key.
Arguments:
Path - Path to the registry key
Value - Name of the value to set
Buffer - Buffer to set
BufferSize - Size of the buffer in characters
This is needed since there can be
many nulls in the buffer which we
want to write
Return Value:
STATUS_SUCCESS, or various failures
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE hKey = NULL;
//
// Open the ComputerName\ComputerName node
//
RtlInitUnicodeString(&KeyName, Path);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
NtStatus = NtCreateKey(&hKey,
KEY_READ | KEY_WRITE,
&ObjectAttributes,
0,
NULL,
0,
NULL);
if ( !NT_SUCCESS( NtStatus ) )
{
return NtStatus ;
}
//
// Update the value under this key
//
RtlInitUnicodeString(&ValueName, Value);
NtStatus = NtSetValueKey(hKey,
&ValueName,
0,
REG_MULTI_SZ,
(LPWSTR) Buffer,
BufferSize);
if ( NT_SUCCESS( NtStatus ) )
{
NtFlushKey( hKey );
}
NtClose(hKey);
return NtStatus ;
}
NTSTATUS
BaseCreateMultiValue(
PCWSTR Path,
PCWSTR Value,
PCWSTR Buffer
)
/*++
Routine Description:
Create a multivalued registry value and initialize it with Buffer.
Arguments:
Path - Path to the registry key
Value - Name of the value to set
Buffer - Buffer to set
Return Value:
STATUS_SUCCESS, or various failures
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
LPWSTR lpMultiValue = NULL;
lpMultiValue = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG ( TMP_TAG ), (wcslen(Buffer)+2)*sizeof(WCHAR));
if (lpMultiValue==NULL) {
NtStatus = STATUS_NO_MEMORY;
}
else {
memcpy(lpMultiValue, Buffer, wcslen(Buffer)*sizeof(WCHAR));
lpMultiValue[wcslen(Buffer)] = L'\0';
lpMultiValue[wcslen(Buffer)+1] = L'\0';
NtStatus = BaseSetMultiNameInReg(Path,
Value,
lpMultiValue,
(wcslen(Buffer)+2)*sizeof(WCHAR));
RtlFreeHeap(RtlProcessHeap(), 0, lpMultiValue);
}
return NtStatus;
}
DWORD
BasepGetMultiValueAddr(
IN LPWSTR lpMultiValue,
IN DWORD dwIndex,
OUT LPWSTR * ppFound,
OUT LPDWORD pcchIndex
)
/*++
Routine Description:
Given an index into a Multivalued register (string), return
the string at that index (not a copy), and it's char count location in the
full multivalued string
Arguments:
lpMultiValue - the register string (returned from NtQueryKey)
dwIndex - the index of which string to return
ppFound - the string found (if found) - user shouldn't free
pcchIndex - the location in lpMultiValue (in characters) of ppFound
Return Value:
ERROR (ERROR_NOT_FOUND if not found)
--*/
{
DWORD i = 0;
DWORD err = ERROR_SUCCESS;
DWORD cchTempIndex = 0;
// lpMultiValue is a concatenated string of (non-null)strings, null terminated
for (i=0; (i<dwIndex) && (lpMultiValue[0] != L'\0'); i++) {
cchTempIndex += wcslen(lpMultiValue) + 1;
lpMultiValue += wcslen(lpMultiValue) + 1;
}
// if we found the correct index, it's in lpMultiValue
if (lpMultiValue[0]!=L'\0') {
*ppFound = lpMultiValue;
*pcchIndex = cchTempIndex;
err = ERROR_SUCCESS;
}
else {
err = ERROR_NOT_FOUND;
}
return err;
}
DWORD
BaseGetMultiValueIndex(
IN LPWSTR lpMultiValue,
IN LPCWSTR lpValue,
OUT DWORD * pcchIndex
)
/*++
Routine Description:
Given a Multivalued register (string), and lpValue, return
the index of lpValue in lpMultiValue (ie, the 0th string, the 1st, etc).
Arguments:
lpMultiValue - the register string (returned from NtQueryKey)
lpValue - the string for which to search
pcchIndex - the index of the string matched (if found)
Return Value:
ERROR (ERROR_NOT_FOUND if not found)
--*/
{
LPWSTR lpFound = NULL;
DWORD cchFoundIndex = 0;
DWORD i = 0;
DWORD err = ERROR_SUCCESS;
BOOL fFound = FALSE;
while ((err==ERROR_SUCCESS) && !fFound) {
err = BasepGetMultiValueAddr(lpMultiValue,
i,
&lpFound,
&cchFoundIndex);
if (err == ERROR_SUCCESS) {
if ((wcslen(lpFound)==wcslen(lpValue)) && (!_memicmp(lpFound,lpValue, wcslen(lpValue)*sizeof(WCHAR)))) {
fFound = TRUE;
*pcchIndex = i;
}
}
i++;
}
return err;
}
DWORD
BaseRemoveMultiValue(
IN OUT LPWSTR lpMultiValue,
IN DWORD dwIndex,
IN OUT LPDWORD pcchMultiValue
)
/*++
Routine Description:
Given a multivalued registry value, and an index, it removes the string
located at that index.
Arguments:
lpMultiValue - the register string (returned from NtQueryKey)
dwIndex - the index of which string to remove
pcchMultiValue - number of chars in lpMultiValue (before and after)
Return Value:
ERRORS
--*/
{
DWORD err = ERROR_SUCCESS;
LPWSTR lpRest = NULL;
LPWSTR lpFound = NULL;
DWORD dwIndexFound = 0;
DWORD dwIndexRest = 0;
err = BasepGetMultiValueAddr(lpMultiValue,
dwIndex,
&lpFound,
&dwIndexFound);
if (err==ERROR_SUCCESS) {
// lpFound is a pointer to a string
// inside of lpMultiValue, to delete it,
// copy the rest of the string down
err = BasepGetMultiValueAddr(lpMultiValue,
dwIndex+1,
&lpRest,
&dwIndexRest);
if (err == ERROR_SUCCESS) {
// copy everything down
memmove(lpFound,lpRest,(*pcchMultiValue - dwIndexRest)*sizeof(WCHAR));
*pcchMultiValue = *pcchMultiValue - (dwIndexRest-dwIndexFound);
lpMultiValue[*pcchMultiValue] = L'\0';
}
else if (err == ERROR_NOT_FOUND) {
// string to remove is last string, simply write an extra null to orphan the string
*pcchMultiValue = *pcchMultiValue - (wcslen(lpFound) +1);
lpMultiValue[*pcchMultiValue] = L'\0';
err = ERROR_SUCCESS;
}
}
return err;
}
DWORD
BaseAddMultiValue(
IN OUT LPWSTR lpMultiValue,
IN LPCWSTR lpValue,
IN DWORD cchMultiValue
)
/*++
Routine Description:
Given a multivalued registry value, add another value.
Arguments:
lpMultiValue - the multivalued string (must be big enough to
hold current values + lpValue plus extra NULL
lpValue - the value to add
cchMultiValue - the count of characters USED in lpMultivalue
(not counting final null)
Return Value:
ERRORS
--*/
{
memcpy(lpMultiValue + cchMultiValue, lpValue, (wcslen(lpValue)+1)*sizeof(WCHAR));
lpMultiValue[cchMultiValue + wcslen(lpValue) + 1] = L'\0';
return ERROR_SUCCESS;
}
NTSTATUS
BaseAddMultiNameInReg(
PCWSTR Path,
PCWSTR Value,
PCWSTR Buffer
)
/*++
Routine Description:
This routine adds a string to the values at the specified multivalued registry key.
If the value already exists in the key, it does nothing.
Arguments:
Path - Path to the registry key
Value - Name of the value
Buffer - Buffer to add
Return Value:
STATUS_SUCCESS, or various failures
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
LPWSTR lpMultiValue = NULL;
ULONG cchMultiValue = 0;
DWORD dwIndex = 0;
DWORD err = ERROR_SUCCESS;
NtStatus = BasepGetNameFromReg(Path,
Value,
lpMultiValue,
&cchMultiValue);
if ( NtStatus==STATUS_NOT_FOUND || NtStatus==STATUS_OBJECT_NAME_NOT_FOUND) {
// create it, then we are done
NtStatus = BaseCreateMultiValue(Path,Value,Buffer);
return NtStatus;
} else if ( NtStatus==STATUS_BUFFER_OVERFLOW ) {
lpMultiValue = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (cchMultiValue+2+wcslen(Buffer))*sizeof(WCHAR));
if (lpMultiValue==NULL) {
NtStatus = STATUS_NO_MEMORY;
}
else {
NtStatus = BasepGetNameFromReg(Path,
Value,
lpMultiValue,
&cchMultiValue);
}
}
if (NT_SUCCESS( NtStatus)) {
// does it already exist in this structure?
err = BaseGetMultiValueIndex(lpMultiValue,
Buffer, &dwIndex);
// if err==ERROR_SUCCESS, then the above function found the string already in the value.
// don't add a duplicate
if (err!=ERROR_SUCCESS) {
err = BaseAddMultiValue(lpMultiValue, Buffer, cchMultiValue);
if (err == ERROR_SUCCESS) {
NtStatus = BaseSetMultiNameInReg(Path, Value, lpMultiValue, (cchMultiValue+2+wcslen(Buffer))*sizeof(WCHAR));
}
}
}
if (lpMultiValue) {
RtlFreeHeap( RtlProcessHeap(), 0, lpMultiValue);
}
return NtStatus ;
}
NTSTATUS
BaseRemoveMultiNameFromReg(
PCWSTR Path,
PCWSTR Value,
PCWSTR Buffer
)
/*++
Routine Description:
Removes a name from a multivalued registry. If the value exists more than once in the
list, removes them all.
Arguments:
Path - Path to the registry key
Value - Name of the value
Buffer - Buffer to remove
Return Value:
ERRORS
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
DWORD err = ERROR_SUCCESS;
DWORD dwIndex = 0;
LPWSTR lpMultiValue = NULL;
ULONG cchNames = 0;
BOOL fNameRemoved = FALSE;
NtStatus = BasepGetNameFromReg(Path,
Value,
lpMultiValue,
&cchNames);
if (NtStatus==STATUS_BUFFER_OVERFLOW) {
lpMultiValue = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (cchNames) * sizeof(WCHAR));
if (lpMultiValue==NULL) {
NtStatus = STATUS_NO_MEMORY;
}
else {
NtStatus = BasepGetNameFromReg(Path,
Value,
lpMultiValue,
&cchNames);
err = RtlNtStatusToDosError(NtStatus);
if (err == ERROR_SUCCESS) {
// search for and remove all values in structure
while (err==ERROR_SUCCESS) {
err = BaseGetMultiValueIndex(lpMultiValue,
Buffer,
&dwIndex);
if (err == ERROR_SUCCESS) {
err = BaseRemoveMultiValue(lpMultiValue,
dwIndex,
&cchNames);
fNameRemoved = TRUE;
}
}
// if we removed a name, write it to the registry...
if (fNameRemoved) {
NtStatus = BaseSetMultiNameInReg(
Path,
Value,
lpMultiValue,
(cchNames+1)*sizeof(WCHAR));
}
else {
// Nothing to remove! ERRROR
NtStatus = STATUS_NOT_FOUND;
}
}
RtlFreeHeap(RtlProcessHeap(), 0, lpMultiValue);
}
}
return NtStatus;
}
LPWSTR
BasepGetNameNonVolatileFromReg(
COMPUTER_NAME_TYPE NameType
)
/*++
Routine Description:
Get the non volatile name from the reg
Arguments:
NameType -
Return Value:
name in non-volatile reg, return value must be freed
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
LPWSTR lpBuffer = NULL;
ULONG cchBuffer = 0;
LPWSTR key = NULL;
LPWSTR value = NULL;
switch (NameType) {
case ComputerNameNetBIOS:
case ComputerNamePhysicalNetBIOS:
key = NON_VOLATILE_COMPUTERNAME_NODE;
value = NON_VOLATILE_COMPUTERNAME;
break;
case ComputerNameDnsHostname:
case ComputerNamePhysicalDnsHostname:
key = TCPIP_ROOT;
value = TCPIP_NV_HOSTNAME;
break;
case ComputerNameDnsDomain:
case ComputerNamePhysicalDnsDomain:
key = TCPIP_ROOT;
value = TCPIP_NV_DOMAINNAME;
break;
default:
return NULL;
}
NtStatus = BasepGetNameFromReg(
key,
value,
lpBuffer,
&cchBuffer);
if (NtStatus==STATUS_BUFFER_OVERFLOW) {
lpBuffer = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (cchBuffer) * sizeof(WCHAR));
if (lpBuffer!=NULL) {
NtStatus = BasepGetNameFromReg(
key,
value,
lpBuffer,
&cchBuffer);
}
}
if (!NT_SUCCESS(NtStatus)) {
if (lpBuffer!=NULL) {
RtlFreeHeap(RtlProcessHeap(), 0, lpBuffer);
}
lpBuffer = NULL;
}
return lpBuffer ;
}
LPWSTR
BasepGetComputerNameExWRtlAlloc(
COMPUTER_NAME_FORMAT NameType
)
/*++
Routine Description:
Call get GetComptuerNameExW and allocate the memory
required and return the value. Returned value
must be freed with RtlFreeHeap
Arguments:
NameType -
Return Value:
NULL if error, Alloced name otherwise
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
LPWSTR lpBuffer = NULL;
ULONG cchBuffer = 0;
DWORD err = ERROR_SUCCESS;
if ((GetComputerNameExW(NameType, lpBuffer, &cchBuffer)==ERROR_SUCCESS) ||
((err = GetLastError()) != ERROR_MORE_DATA)) {
if (lpBuffer!=NULL) {
RtlFreeHeap(RtlProcessHeap(),0, lpBuffer);
}
return NULL;
}
lpBuffer = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), cchBuffer*sizeof(WCHAR));
if ((lpBuffer!=NULL) && (GetComputerNameExW(NameType, lpBuffer, &cchBuffer)!=ERROR_SUCCESS)) {
return NULL;
}
return lpBuffer ;
}
LPWSTR
BasepGetNameNonVolatile(
COMPUTER_NAME_FORMAT NameType
)
/*++
Routine Description:
Get the non volatile name
Arguments:
NameType -
Return Value:
non-volatile name, return value must be freed
--*/
{
LPWSTR lpDnsHostname = NULL;
LPWSTR lpDnsDomain = NULL;
LPWSTR lpName = NULL;
ULONG cchDnsHostname = 0;
ULONG cchDnsDomain = 0;
switch (NameType) {
case ComputerNameNetBIOS:
case ComputerNamePhysicalNetBIOS:
case ComputerNameDnsHostname:
case ComputerNamePhysicalDnsHostname:
case ComputerNameDnsDomain:
case ComputerNamePhysicalDnsDomain:
lpName = BasepGetNameNonVolatileFromReg(NameType);
break;
case ComputerNameDnsFullyQualified:
case ComputerNamePhysicalDnsFullyQualified:
// build it
lpDnsHostname = BasepGetNameNonVolatile(ComputerNameDnsHostname);
lpDnsDomain = BasepGetNameNonVolatile(ComputerNameDnsDomain);
// if both are null, then there is no non-volatile name set
// if one is null, get volatile name for that part of name
if ((lpDnsHostname==NULL) && (lpDnsDomain==NULL)) {
// no non-volatile name set
lpName = NULL;
} else {
if (lpDnsHostname==NULL) {
lpDnsHostname = BasepGetComputerNameExWRtlAlloc(ComputerNameDnsHostname);
} else if (lpDnsDomain==NULL) {
lpDnsDomain = BasepGetComputerNameExWRtlAlloc(ComputerNameDnsDomain);
}
cchDnsHostname = wcslen(lpDnsHostname);
cchDnsDomain = wcslen(lpDnsDomain);
// build the full dns name
// if there is no domain name, return just the hostname.
// if there is no hostname, just return it (NULL);
if ((cchDnsDomain==0) || (cchDnsHostname==0)) {
lpName = lpDnsHostname;
} else {
if ((cchDnsDomain==1) && (lpDnsDomain[0]==L'.')) {
// the dns domain can legally be a single .
RtlFreeHeap(RtlProcessHeap(), 0, lpDnsDomain);
lpDnsDomain = NULL;
cchDnsDomain = 0;
}
// allocate space for the . and the null and the strings to concatenate in.
lpName = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (cchDnsHostname + cchDnsDomain + 2) * sizeof(WCHAR));
if (lpName!=NULL) {
wcscpy(lpName, lpDnsHostname);
wcscat(lpName, L".");
if (lpDnsDomain!=NULL) {
wcscat(lpName, lpDnsDomain);
}
}
if (lpDnsHostname) {
RtlFreeHeap(RtlProcessHeap(), 0, lpDnsHostname);
}
}
if (lpDnsDomain) {
RtlFreeHeap(RtlProcessHeap(), 0, lpDnsDomain);
}
}
}
return lpName;
}
BOOL
BaseValidateFlags(
ULONG ulFlags
)
/*++
Routine Description:
Validates unused flags. For now the flags parameter of
AddLocalAlternateComputerName*
RemoveLocalAlternateComputerName*
EnumerateLocalAlternateComputerName*
SetLocalPrimaryComputerName*
are all reserved and should be 0. In subsequent releases
this function should change to check for a mask of valid
flags.
Arguments:
ulFlags -
Return Value:
BOOL
--*/
{
if (ulFlags!=0) {
return FALSE;
}
return TRUE;
}
BOOL
BaseValidateNetbiosName(
IN LPCWSTR lpComputerName
)
/*++
Routine Description:
Checks that the input is an acceptable Netbios name.
Arguments:
lpComputerName - name to validate
Return Value:
BOOL, GetLastError()
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
ULONG cchComputerName;
ULONG AnsiComputerNameLength;
cchComputerName = wcslen(lpComputerName);
//
// The name length limitation should be based on ANSI. (LanMan compatibility)
//
NtStatus = RtlUnicodeToMultiByteSize(&AnsiComputerNameLength,
(LPWSTR)lpComputerName,
cchComputerName * sizeof(WCHAR));
if ((!NT_SUCCESS(NtStatus)) ||
(AnsiComputerNameLength == 0 )||(AnsiComputerNameLength > MAX_COMPUTERNAME_LENGTH)) {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
//
// Check for illegal characters; return an error if one is found
//
if (wcscspn(lpComputerName, ILLEGAL_NAME_CHARS_STR) < cchComputerName) {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
//
// Check for leading or trailing spaces
//
if (lpComputerName[0] == L' ' ||
lpComputerName[cchComputerName-1] == L' ') {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
return(TRUE);
}
BOOL
BaseValidateFQDnsName(
LPCWSTR lpDnsHostname
)
/*++
Routine Description:
Checks that the inputted name is an acceptable Dns hostname.
Arguments:
lpDnsHostName - name to validate
Return Value:
BOOL, GetLastError
--*/
{
HANDLE DnsApi ;
DNS_VALIDATE_NAME_FN * DnsValidateNameFn ;
DNS_STATUS DnsStatus ;
DnsApi = LoadLibraryW(DnsApiDllString);
if ( !DnsApi ) {
SetLastError(ERROR_DLL_NOT_FOUND);
return FALSE ;
}
DnsValidateNameFn = (DNS_VALIDATE_NAME_FN *) GetProcAddress( DnsApi, "DnsValidateName_W" );
if ( !DnsValidateNameFn )
{
FreeLibrary( DnsApi );
SetLastError(ERROR_INVALID_DLL);
return FALSE ;
}
DnsStatus = DnsValidateNameFn( lpDnsHostname, DnsNameHostnameFull );
FreeLibrary( DnsApi );
if ( ( DnsStatus == 0 ) ||
( DnsStatus == DNS_ERROR_NON_RFC_NAME ) )
{
return TRUE;
}
else
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
LPWSTR
BasepGetLatestName(
COMPUTER_NAME_FORMAT compFormat
)
/*++
Routine Description:
Get the NV version of this name if it exists. If it's an empty string, or it
doesn't exist, then just get the regular name.
Arguments:
lpDnsHostName - name to validate
Return Value:
Pointer to a name, must be freed.
--*/
{
LPWSTR lpTemp = NULL;
lpTemp = BasepGetNameNonVolatile(compFormat);
if (lpTemp==NULL || lpTemp[0]==L'\0') {
// if the non-volatile name isn't there - ie they're not trying to set it,
// then get the regular name
if (lpTemp!=NULL) {
// returned empty string, free it before getting a newer name
RtlFreeHeap(RtlProcessHeap(), 0, lpTemp);
}
lpTemp = BasepGetComputerNameExWRtlAlloc(compFormat);
}
return lpTemp;
}
BOOL
BaseValidateDns(
LPCWSTR lpBuffer,
ULONG type)
/*++
Routine Description:
Checks that the inputted name is an acceptable Dns name, either
hostname or domain name with the latest names.
Arguments:
lpBuffer - name to validate
type - type of Buffer to validate (either DNS_HOSTNAME or DNS_DOMAINNAME)
Return Value:
BOOL, GetLastError
--*/
{
LPWSTR lpDomain = NULL;
LPWSTR lpHostname = NULL;
LPWSTR lpTemp = NULL;
LPWSTR lpDnsFQHostname = NULL;
ULONG cchDnsFQHostname = 0;
BOOL fReturnVal = TRUE;
// type should be DNS_HOSTNAME or DNS_DOMAINNAME
if (type==DNS_HOSTNAME) {
// validating the hostname
lpHostname = (LPWSTR)lpBuffer;
lpTemp = lpDomain = BasepGetLatestName(ComputerNameDnsDomain);
} else if (type==DNS_DOMAINNAME) {
// validating the domainname
lpDomain = (LPWSTR)lpBuffer;
lpTemp = lpHostname = BasepGetLatestName(ComputerNameDnsHostname);
} else {
// bad news - should never get here.
SetLastError(ERROR_INTERNAL_ERROR);
fReturnVal = FALSE;
}
if (lpBuffer==NULL) {
SetLastError(ERROR_INVALID_PARAMETER);
fReturnVal = FALSE;
}
if (fReturnVal && lpDomain && memcmp(lpDomain, L".", 2*sizeof(WCHAR))) {
// if the domain not a single "." then we'll add a "."
cchDnsFQHostname++;
}
if (fReturnVal && lpDomain && lpHostname) {
cchDnsFQHostname += wcslen(lpDomain) + wcslen(lpHostname) + 1;
lpDnsFQHostname = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), cchDnsFQHostname*sizeof(WCHAR));
if (lpDnsFQHostname==NULL) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
fReturnVal = FALSE;
}
if (fReturnVal) {
wcscpy(lpDnsFQHostname, lpHostname);
if (memcmp(lpDomain, L".", 2*sizeof(WCHAR))) {
wcscat(lpDnsFQHostname, L".");
}
wcscat(lpDnsFQHostname, lpDomain);
// okay, validate the FQ hostname.
if (!BaseValidateFQDnsName(lpDnsFQHostname)) {
SetLastError(ERROR_INVALID_PARAMETER);
fReturnVal = FALSE;
}
}
} // else nothing is set yet, don't invalidate because of that.
if (lpTemp) {
RtlFreeHeap(RtlProcessHeap(), 0, lpTemp);
}
if (lpDnsFQHostname) {
RtlFreeHeap(RtlProcessHeap(), 0, lpDnsFQHostname);
}
return fReturnVal;
}
BOOL
BaseValidateDnsHostname(
LPCWSTR lpHostname
)
/*++
Routine Description:
Checks that the inputted name is an acceptable dns hostname concatenated
with the dns domain name of the next boot (what is currently set anyway)
Arguments:
lpHostname - name to validate
Return Value:
BOOL, GetLastError
--*/
{
return BaseValidateDns(lpHostname, DNS_HOSTNAME);
}
BOOL
BaseValidateDnsDomain(
LPCWSTR lpDomain
)
/*++
Routine Description:
Checks that the inputted name is an acceptable dns domain name concatenated
with the dns hostname of the next boot (what is currently set anyway)
Arguments:
lpDomain - name to validate
Return Value:
BOOL, GetLastError
--*/
{
return BaseValidateDns(lpDomain, DNS_DOMAINNAME);
}
LPWSTR
BaseParseDnsName(
IN LPCWSTR lpDnsName,
IN ULONG NamePart
)
/*++
Routine Description:
Given a dns name, parse out either the hostname or the domain name.
Arguments:
lpDnsName - a dns name, of the form hostname.domain - domain name optional
NamePart - DNS_HOSTNAME or DNS_DOMAINNAME
Return Value:
String requested
--*/
{
DWORD cchCharIndex = 0;
ULONG cchName = 0;
LPWSTR lpName = NULL;
if (lpDnsName==NULL) {
return NULL;
}
cchCharIndex = wcscspn(lpDnsName, L".");
if (NamePart==DNS_HOSTNAME) {
cchName = cchCharIndex;
}
else {
if (cchCharIndex==wcslen(lpDnsName)) {
// no period found,
cchName = 0;
}
else {
cchName = wcslen(lpDnsName)-(cchCharIndex+1);
}
}
lpName = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (cchName + 1)*sizeof(WCHAR));
if (lpName==NULL) {
return NULL;
}
// copy the correct part into the structure
if (NamePart==DNS_HOSTNAME) {
wcsncpy(lpName, lpDnsName, cchName);
}
else {
wcsncpy(lpName, (LPWSTR)(lpDnsName + cchCharIndex + 1), cchName);
}
lpName[cchName] = L'\0';
return lpName;
}
BOOL
BaseSetNetbiosName(
IN LPCWSTR lpComputerName
)
/*++
Routine Description:
Sets the computer's net bios name
Arguments:
lpComputerName - name to set
Return Value:
BOOL, GetLastError()
--*/
{
NTSTATUS NtStatus ;
//
// Validate that the supplied computername is valid (not too long,
// no incorrect characters, no leading or trailing spaces)
//
if (!BaseValidateNetbiosName(lpComputerName)) {
return(FALSE);
}
//
// Open the ComputerName\ComputerName node
//
NtStatus = BaseSetNameInReg( NON_VOLATILE_COMPUTERNAME_NODE,
COMPUTERNAME_VALUE_NAME,
lpComputerName );
if ( !NT_SUCCESS( NtStatus ))
{
BaseSetLastNTError( NtStatus );
return FALSE ;
}
return TRUE ;
}
BOOL
BaseSetDnsName(
LPCWSTR lpComputerName
)
/*++
Routine Description:
Sets the computer's Dns hostname
Arguments:
lpComputerName - name to set
Return Value:
BOOL, GetLastError()
--*/
{
UNICODE_STRING NewComputerName ;
UNICODE_STRING DnsName ;
NTSTATUS Status ;
BOOL Return ;
HANDLE DnsApi ;
DNS_VALIDATE_NAME_FN * DnsValidateNameFn ;
DNS_STATUS DnsStatus ;
DnsApi = LoadLibraryW(DnsApiDllString);
if ( !DnsApi )
{
return FALSE ;
}
DnsValidateNameFn = (DNS_VALIDATE_NAME_FN *) GetProcAddress( DnsApi, "DnsValidateName_W" );
if ( !DnsValidateNameFn )
{
FreeLibrary( DnsApi );
return FALSE ;
}
DnsStatus = DnsValidateNameFn( lpComputerName, DnsNameHostnameLabel );
FreeLibrary( DnsApi );
if ( ( DnsStatus == 0 ) ||
( DnsStatus == DNS_ERROR_NON_RFC_NAME ) )
{
Status = BaseSetNameInReg( TCPIP_ROOT,
TCPIP_NV_HOSTNAME,
lpComputerName );
}
else
{
Status = STATUS_INVALID_PARAMETER ;
}
if ( NT_SUCCESS( Status ) )
{
RtlInitUnicodeString( &DnsName, lpComputerName );
Status = RtlDnsHostNameToComputerName( &NewComputerName,
&DnsName,
TRUE );
if ( NT_SUCCESS( Status ) )
{
Return = BaseSetNetbiosName( NewComputerName.Buffer );
RtlFreeUnicodeString( &NewComputerName );
if ( !Return )
{
//
// What? Rollback?
//
return FALSE ;
}
return TRUE ;
}
}
BaseSetLastNTError( Status ) ;
return FALSE ;
}
BOOL
BaseSetDnsDomain(
LPCWSTR lpName
)
/*++
Routine Description:
Sets the computer's Dns domain name
Arguments:
lpName - name to set
Return Value:
BOOL, GetLastError()
--*/
{
NTSTATUS Status ;
HANDLE DnsApi ;
DNS_VALIDATE_NAME_FN * DnsValidateNameFn ;
DNS_STATUS DnsStatus ;
//
// Special case the empty string, which is legal, but not according to dnsapi
//
if ( *lpName )
{
DnsApi = LoadLibraryW(DnsApiDllString);
if ( !DnsApi )
{
return FALSE ;
}
DnsValidateNameFn = (DNS_VALIDATE_NAME_FN *) GetProcAddress( DnsApi, "DnsValidateName_W" );
if ( !DnsValidateNameFn )
{
FreeLibrary( DnsApi );
return FALSE ;
}
DnsStatus = DnsValidateNameFn( lpName, DnsNameDomain );
FreeLibrary( DnsApi );
}
else
{
DnsStatus = 0 ;
}
//
// If the name is good, then keep it.
//
if ( ( DnsStatus == 0 ) ||
( DnsStatus == DNS_ERROR_NON_RFC_NAME ) )
{
Status = BaseSetNameInReg(
TCPIP_ROOT,
TCPIP_NV_DOMAINNAME,
lpName );
}
else
{
Status = STATUS_INVALID_PARAMETER ;
}
if ( !NT_SUCCESS( Status ) )
{
BaseSetLastNTError( Status );
return FALSE ;
}
return TRUE ;
}
BOOL
BaseSetAltNetBiosName(
IN LPCWSTR lpComputerName
)
/*++
Routine Description:
Sets the computer's alternate net bios name
Arguments:
lpComputerName - name to set
Return Value:
BOOL, GetLastError()
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
if (!BaseValidateNetbiosName(lpComputerName)) {
BaseSetLastNTError( STATUS_INVALID_PARAMETER );
return(FALSE);
}
NtStatus = BaseAddMultiNameInReg(
ALT_COMPUTERNAME_NODE,
COMPUTERNAME_OPTIONAL_NAME,
lpComputerName );
if ( !NT_SUCCESS( NtStatus ))
{
BaseSetLastNTError( NtStatus );
return FALSE ;
}
return TRUE ;
}
BOOL
BaseSetAltDnsFQHostname(
IN LPCWSTR lpDnsFQHostname
)
/*++
Routine Description:
Sets the computer's alternate fully qualified Dns name
Arguments:
lpDnsFQHostname - name to set
Return Value:
BOOL, GetLastError()
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
NtStatus = BaseAddMultiNameInReg(
DNSCACHE_ROOT,
DNS_ALT_HOSTNAME,
lpDnsFQHostname);
if ( !NT_SUCCESS( NtStatus ))
{
BaseSetLastNTError( NtStatus );
return FALSE ;
}
return TRUE ;
}
BOOL
BaseIsAltDnsFQHostname(
LPCWSTR lpAltDnsFQHostname
)
/*++
Routine Description:
Verifies if lpAltDnsFQHostname is a previosly defined
alternate dns name
Arguments:
lpDnsFQHostname - name to check
Return Value:
TRUE if verifiably in use, FALSE otherwise, GetLastError()
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
LPWSTR lpNames = NULL;
ULONG cchNames = 0;
BOOL fFound = FALSE;
DWORD dwIndex = 0;
DWORD err = ERROR_SUCCESS;
NtStatus = BasepGetNameFromReg(DNSCACHE_ROOT,
DNS_ALT_HOSTNAME,
lpNames,
&cchNames);
if (NtStatus==STATUS_BUFFER_OVERFLOW) {
lpNames = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (cchNames) * sizeof(WCHAR));
if (lpNames!=NULL) {
NtStatus = BasepGetNameFromReg(DNSCACHE_ROOT,
DNS_ALT_HOSTNAME,
lpNames,
&cchNames);
err = RtlNtStatusToDosError(NtStatus);
if (err == ERROR_SUCCESS) {
err = BaseGetMultiValueIndex(lpNames,
lpAltDnsFQHostname,
&dwIndex);
fFound = err==ERROR_SUCCESS;
}
RtlFreeHeap( RtlProcessHeap(), 0, lpNames);
}
}
return fFound;
}
BOOL
BaseRemoveAltNetBiosName(
IN LPCWSTR lpAltComputerName
)
/*++
Routine Description:
Removes an alternate net bios name
Arguments:
lpAltComputerName - name to remove
Return Value:
BOOL, GetLastError()
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
NtStatus = BaseRemoveMultiNameFromReg ( ALT_COMPUTERNAME_NODE,
COMPUTERNAME_OPTIONAL_NAME,
lpAltComputerName );
if ( !NT_SUCCESS( NtStatus ))
{
BaseSetLastNTError( NtStatus );
return FALSE ;
}
return TRUE ;
}
BOOL
BaseRemoveAltDnsFQHostname(
IN LPCWSTR lpAltDnsFQHostname
)
/*++
Routine Description:
Removes an alternate Dns hostname
Arguments:
lpAltDnsFqHostname - name to remove
Return Value:
BOOL, GetLastError()
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
NtStatus = BaseRemoveMultiNameFromReg ( DNSCACHE_ROOT,
DNS_ALT_HOSTNAME,
lpAltDnsFQHostname );
if ( !NT_SUCCESS( NtStatus ))
{
BaseSetLastNTError( NtStatus );
return FALSE ;
}
return TRUE ;
}
DWORD
BaseEnumAltDnsFQHostnames(
OUT LPWSTR lpAltDnsFQHostnames,
IN OUT LPDWORD nSize
)
/*++
Routine Description:
Wrapper for BasepGetNameFromReg to return ERRORS, instead of STATUS
--*/
{
NTSTATUS status = STATUS_SUCCESS;
status = BasepGetNameFromReg(
DNSCACHE_ROOT,
DNS_ALT_HOSTNAME,
lpAltDnsFQHostnames,
nSize);
if (status == STATUS_OBJECT_NAME_NOT_FOUND) {
if ((lpAltDnsFQHostnames!=NULL) && (*nSize>0)) {
lpAltDnsFQHostnames[0]=L'\0';
*nSize=0;
status=STATUS_SUCCESS;
}
else {
*nSize=1;
status=STATUS_BUFFER_OVERFLOW;
}
}
return RtlNtStatusToDosError(status);
}
BOOL
BaseIsNetBiosNameInUse(
LPWSTR lpCompName
)
/*++
Routine Description:
Verify whether lpCompName is being used by any alternate DNS names
(ie whether any existing alternate DNS names map to lpCompName with
DnsHostnameToComputerNameW)
Arguments:
lpCompName - net bios name to verify
Return Value:
FALSE if verifiably is not being used, true otherwise, GetLastError()
--*/
{
NTSTATUS NtStatus = STATUS_SUCCESS;
LPWSTR lpMultiValue = NULL;
ULONG cchMultiValue = 0;
LPWSTR lpAltDnsFQHostname = NULL;
ULONG cchAltDnsHostname = 0;
DWORD dwIndex = 0;
LPWSTR lpAltCompName = NULL;
ULONG cchAltCompName = 0;
DWORD err = ERROR_SUCCESS;
BOOL fInUse = FALSE;
BOOL fIsNetBiosNameInUse = TRUE;
NtStatus = BasepGetNameFromReg(DNSCACHE_ROOT,
DNS_ALT_HOSTNAME,
lpMultiValue,
&cchMultiValue);
err = RtlNtStatusToDosError(NtStatus);
if (err==ERROR_MORE_DATA) {
lpMultiValue = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), cchMultiValue * sizeof(WCHAR));
if (lpMultiValue==NULL) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return TRUE;
}
NtStatus = BasepGetNameFromReg(DNSCACHE_ROOT,
DNS_ALT_HOSTNAME,
lpMultiValue,
&cchMultiValue);
err=RtlNtStatusToDosError(NtStatus);
}
if ((err==ERROR_SUCCESS) && (lpMultiValue==NULL)) {
return FALSE; // not in use if the reg values are null
}
if (err == ERROR_SUCCESS) {
dwIndex = 0;
while (err == ERROR_SUCCESS) {
err = BasepGetMultiValueAddr(lpMultiValue,
dwIndex,
&lpAltDnsFQHostname,
&cchAltDnsHostname);
// get net bios names
if (err == ERROR_SUCCESS) {
if (!DnsHostnameToComputerNameW(lpAltDnsFQHostname,
lpAltCompName,
&cchAltCompName)) {
err = GetLastError();
if (err==ERROR_MORE_DATA) {
// DnsHostNameToComputerNameW bug
cchAltCompName += 1;
// DnsHostNameToComputerNameW bug
lpAltCompName = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), cchAltCompName*sizeof(WCHAR));
if (lpAltCompName==NULL) {
err = ERROR_NOT_ENOUGH_MEMORY;
}
else if (!DnsHostnameToComputerNameW(lpAltDnsFQHostname, lpAltCompName, &cchAltCompName)) {
err = GetLastError();
} else {
err = ERROR_SUCCESS;
}
}
}
if (err==ERROR_SUCCESS) {
if (!_wcsicmp(lpAltCompName, lpCompName)) {
fInUse = TRUE;
}
}
}
dwIndex++;
}
// exits the above while loop when err==ERROR_NOT_FOUND, whether found or not
if (err==ERROR_NOT_FOUND) {
fIsNetBiosNameInUse = fInUse;
err = ERROR_SUCCESS;
}
else {
// error, default to in use
fIsNetBiosNameInUse = TRUE;
}
}
if (lpMultiValue) {
RtlFreeHeap(RtlProcessHeap(), 0, lpMultiValue);
}
if (lpAltCompName) {
RtlFreeHeap(RtlProcessHeap(), 0, lpAltCompName);
}
return fIsNetBiosNameInUse;
}
//
// UNICODE APIs
//
BOOL
WINAPI
GetComputerNameW (
LPWSTR lpBuffer,
LPDWORD nSize
)
/*++
Routine Description:
This returns the active computername. This is the computername when the
system was last booted. If this is changed (via SetComputerName) it does
not take effect until the next system boot.
Arguments:
lpBuffer - Points to the buffer that is to receive the
null-terminated character string containing the computer name.
nSize - Specifies the maximum size (in characters) of the buffer. This
value should be set to at least MAX_COMPUTERNAME_LENGTH + 1 to allow
sufficient room in the buffer for the computer name. The length
of the string is returned in nSize.
Return Value:
TRUE on success, FALSE on failure.
--*/
{
NTSTATUS NtStatus;
UNICODE_STRING KeyName;
UNICODE_STRING Class;
UNICODE_STRING ValueName;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE hKey = NULL;
HANDLE hNewKey = NULL;
ULONG Disposition;
ULONG ValueLength;
BOOL ReturnValue;
DWORD Status;
DWORD errcode;
//
// First check to see if the cluster computername variable is set.
// If so, this overrides the actual computername to fool the application
// into working when its network name and computer name are different.
//
ValueLength = GetEnvironmentVariableW(L"_CLUSTER_NETWORK_NAME_",
lpBuffer,
*nSize);
if (ValueLength != 0) {
//
// The environment variable exists, return it directly but make sure
// we honor return semantics
//
ReturnValue = ( *nSize >= ValueLength ? TRUE : FALSE );
if ( !ReturnValue ) {
SetLastError( ERROR_BUFFER_OVERFLOW );
}
*nSize = ValueLength;
return(ReturnValue);
}
if ( (gpTermsrvGetComputerName) &&
((errcode = gpTermsrvGetComputerName(lpBuffer, nSize)) != ERROR_RETRY) ) {
if (errcode == ERROR_BUFFER_OVERFLOW ) {
ReturnValue = FALSE;
goto Cleanup;
} else {
goto GoodReturn;
}
}
//
// Open the Computer node, both computername keys are relative
// to this node.
//
RtlInitUnicodeString(&KeyName, COMPUTERNAME_ROOT);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
NtStatus = NtOpenKey(&hKey, KEY_READ, &ObjectAttributes);
if (NtStatus == STATUS_OBJECT_NAME_NOT_FOUND) {
//
// This should never happen! This key should have been created
// at setup, and protected by an ACL so that only the ADMIN could
// write to it. Generate an event, and return a NULL computername.
//
// NTRAID#NTBUG9-174986-2000/08/31-DavePr Log event or do alert or something.
//
// Return a NULL computername
//
if (ARGUMENT_PRESENT(lpBuffer))
{
lpBuffer[0] = L'\0';
}
*nSize = 0;
goto GoodReturn;
}
if (!NT_SUCCESS(NtStatus)) {
//
// Some other error, return it to the caller
//
goto ErrorReturn;
}
//
// Try to get the name from the volatile key
//
NtStatus = GetNameFromValue(hKey, VOLATILE_COMPUTERNAME, lpBuffer,
nSize);
//
// The user's buffer wasn't big enough, just return the error.
//
if(NtStatus == STATUS_BUFFER_OVERFLOW) {
SetLastError(ERROR_BUFFER_OVERFLOW);
ReturnValue = FALSE;
goto Cleanup;
}
if (NT_SUCCESS(NtStatus)) {
//
// The volatile copy is already there, just return it
//
goto GoodReturn;
}
//
// The volatile key isn't there, try for the non-volatile one
//
NtStatus = GetNameFromValue(hKey, NON_VOLATILE_COMPUTERNAME, lpBuffer,
nSize);
if (NtStatus == STATUS_OBJECT_NAME_NOT_FOUND) {
//
// This should never happen! This value should have been created
// at setup, and protected by an ACL so that only the ADMIN could
// write to it. Generate an event, and return an error to the
// caller
//
// NTRAID#NTBUG9-174986-2000/08/31-DavePr Log event or do alert or something.
//
// Return a NULL computername
//
lpBuffer[0] = L'\0';
*nSize = 0;
goto GoodReturn;
}
if (!NT_SUCCESS(NtStatus)) {
//
// Some other error, return it to the caller
//
goto ErrorReturn;
}
//
// Now create the volatile key to "lock this in" until the next boot
//
RtlInitUnicodeString(&Class, CLASS_STRING);
//
// Turn KeyName into a UNICODE_STRING
//
RtlInitUnicodeString(&KeyName, VOLATILE_COMPUTERNAME);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
hKey,
NULL
);
//
// Now create the key
//
NtStatus = NtCreateKey(&hNewKey,
KEY_WRITE | KEY_READ,
&ObjectAttributes,
0,
&Class,
REG_OPTION_VOLATILE,
&Disposition);
if (Disposition == REG_OPENED_EXISTING_KEY) {
//
// Someone beat us to this, just get the value they put there
//
NtStatus = GetNameFromValue(hKey, VOLATILE_COMPUTERNAME, lpBuffer,
nSize);
if (NtStatus == STATUS_OBJECT_NAME_NOT_FOUND) {
//
// This should never happen! It just told me it existed
//
NtStatus = STATUS_UNSUCCESSFUL;
goto ErrorReturn;
}
}
//
// Create the value under this key
//
RtlInitUnicodeString(&ValueName, COMPUTERNAME_VALUE_NAME);
ValueLength = (wcslen(lpBuffer) + 1) * sizeof(WCHAR);
NtStatus = NtSetValueKey(hNewKey,
&ValueName,
0,
REG_SZ,
lpBuffer,
ValueLength);
if (!NT_SUCCESS(NtStatus)) {
goto ErrorReturn;
}
goto GoodReturn;
ErrorReturn:
//
// An error was encountered, convert the status and return
//
BaseSetLastNTError(NtStatus);
ReturnValue = FALSE;
goto Cleanup;
GoodReturn:
//
// Everything went ok, update nSize with the length of the buffer and
// return
//
*nSize = wcslen(lpBuffer);
ReturnValue = TRUE;
goto Cleanup;
Cleanup:
if (hKey) {
NtClose(hKey);
}
if (hNewKey) {
NtClose(hNewKey);
}
return(ReturnValue);
}
BOOL
WINAPI
SetComputerNameW (
LPCWSTR lpComputerName
)
/*++
Routine Description:
This sets what the computername will be when the system is next booted. This
does not effect the active computername for the remainder of this boot, nor
what is returned by GetComputerName before the next system boot.
Arguments:
lpComputerName - points to the buffer that is contains the
null-terminated character string containing the computer name.
Return Value:
Returns TRUE on success, FALSE on failure.
--*/
{
NTSTATUS NtStatus;
UNICODE_STRING KeyName;
UNICODE_STRING ValueName;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE hKey = NULL;
ULONG ValueLength;
ULONG ComputerNameLength;
ULONG AnsiComputerNameLength;
//
// Validate that the supplied computername is valid (not too long,
// no incorrect characters, no leading or trailing spaces)
//
ComputerNameLength = wcslen(lpComputerName);
//
// The name length limitation should be based on ANSI. (LanMan compatibility)
//
NtStatus = RtlUnicodeToMultiByteSize(&AnsiComputerNameLength,
(LPWSTR)lpComputerName,
ComputerNameLength * sizeof(WCHAR));
if ((!NT_SUCCESS(NtStatus)) ||
(AnsiComputerNameLength == 0 )||(AnsiComputerNameLength > MAX_COMPUTERNAME_LENGTH)) {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
//
// Check for illegal characters; return an error if one is found
//
if (wcscspn(lpComputerName, ILLEGAL_NAME_CHARS_STR) < ComputerNameLength) {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
//
// Check for leading or trailing spaces
//
if (lpComputerName[0] == L' ' ||
lpComputerName[ComputerNameLength-1] == L' ') {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
//
// Open the ComputerName\ComputerName node
//
RtlInitUnicodeString(&KeyName, NON_VOLATILE_COMPUTERNAME_NODE);
InitializeObjectAttributes(&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
NtStatus = NtOpenKey(&hKey, KEY_READ | KEY_WRITE, &ObjectAttributes);
if (NtStatus == STATUS_OBJECT_NAME_NOT_FOUND) {
//
// This should never happen! This key should have been created
// at setup, and protected by an ACL so that only the ADMIN could
// write to it. Generate an event, and return a NULL computername.
//
// NTRAID#NTBUG9-174986-2000/08/31-DavePr Log event or do alert or something.
// (One alternative for this instance would be to actually create the missing
// entry here -- but we'd have to be sure to get the right ACLs etc, etc.
SetLastError(ERROR_GEN_FAILURE);
return(FALSE);
}
//
// Update the value under this key
//
RtlInitUnicodeString(&ValueName, COMPUTERNAME_VALUE_NAME);
ValueLength = (wcslen(lpComputerName) + 1) * sizeof(WCHAR);
NtStatus = NtSetValueKey(hKey,
&ValueName,
0,
REG_SZ,
(LPWSTR)lpComputerName,
ValueLength);
if (!NT_SUCCESS(NtStatus)) {
BaseSetLastNTError(NtStatus);
NtClose(hKey);
return(FALSE);
}
NtFlushKey(hKey);
NtClose(hKey);
return(TRUE);
}
BOOL
WINAPI
GetComputerNameExW(
IN COMPUTER_NAME_FORMAT NameType,
OUT LPWSTR lpBuffer,
IN OUT LPDWORD nSize
)
/*++
Routine Description:
This returns the active computername in a particular format. This is the
computername when the system was last booted. If this is changed (via
SetComputerName) it does not take effect until the next system boot.
Arguments:
NameType - Possible name formats to return the computer name in:
ComputerNameNetBIOS - netbios name (compatible with GetComputerName)
ComputerNameDnsHostname - DNS host name
ComputerNameDnsDomain - DNS Domain name
ComputerNameDnsFullyQualified - DNS Fully Qualified (hostname.dnsdomain)
lpBuffer - Points to the buffer that is to receive the
null-terminated character string containing the computer name.
nSize - Specifies the maximum size (in characters) of the buffer. This
value should be set to at least MAX_COMPUTERNAME_LENGTH + 1 to allow
sufficient room in the buffer for the computer name. The length
of the string is returned in nSize.
Return Value:
TRUE on success, FALSE on failure.
--*/
{
NTSTATUS Status ;
DWORD ValueLength ;
DWORD HostLength ;
DWORD DomainLength ;
BOOL DontSetReturn = FALSE ;
COMPUTER_NAME_FORMAT HostNameFormat, DomainNameFormat ;
if ( NameType >= ComputerNameMax )
{
BaseSetLastNTError( STATUS_INVALID_PARAMETER );
return FALSE ;
}
if ((nSize==NULL) || ((lpBuffer==NULL) && (*nSize>0))) {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
//
// For general names, allow clusters to override the physical name:
//
if ( (NameType >= ComputerNameNetBIOS) &&
(NameType <= ComputerNameDnsFullyQualified ) )
{
ValueLength = GetEnvironmentVariableW(
ClusterNameVars[ NameType ],
lpBuffer,
*nSize );
if ( ValueLength )
{
BOOL ReturnValue;
//
// ValueLength is the length+NULL of the env. string regardless of
// how much was copied (gregjohn 1/30/01 note: this isn't the behaivor
// of the rest of the function, which returns length+NULL on failure
// and length on success). Indicate how many characters are in the string
// and if the user's buffer wasn't big enough, return FALSE
//
ReturnValue = ( *nSize >= ValueLength ? TRUE : FALSE );
if ( !ReturnValue ) {
SetLastError( ERROR_MORE_DATA );
}
*nSize = ValueLength ;
return ReturnValue;
}
}
if ( lpBuffer && (*nSize > 0) )
{
lpBuffer[0] = L'\0';
}
switch ( NameType )
{
case ComputerNameNetBIOS:
case ComputerNamePhysicalNetBIOS:
Status = BasepGetNameFromReg(
VOLATILE_COMPUTERNAME_NODE,
COMPUTERNAME_VALUE_NAME,
lpBuffer,
nSize );
if ( !NT_SUCCESS( Status ) )
{
if ( Status != STATUS_BUFFER_OVERFLOW )
{
//
// Hmm, the value (or key) is missing. Try the non-volatile
// one.
//
Status = BasepGetNameFromReg(
NON_VOLATILE_COMPUTERNAME_NODE,
COMPUTERNAME_VALUE_NAME,
lpBuffer,
nSize );
}
}
break;
case ComputerNameDnsHostname:
case ComputerNamePhysicalDnsHostname:
Status = BasepGetNameFromReg(
TCPIP_ROOT,
TCPIP_HOSTNAME,
lpBuffer,
nSize );
break;
case ComputerNameDnsDomain:
case ComputerNamePhysicalDnsDomain:
//
// Allow policy to override the domain name from the
// tcpip key.
//
Status = BasepGetNameFromReg(
TCPIP_POLICY_ROOT,
TCPIP_POLICY_DOMAINNAME,
lpBuffer,
nSize );
//
// If no policy read from the tcpip key.
//
if ( !NT_SUCCESS( Status ) )
{
if ( Status != STATUS_BUFFER_OVERFLOW )
{
Status = BasepGetNameFromReg(
TCPIP_ROOT,
TCPIP_DOMAINNAME,
lpBuffer,
nSize );
}
}
break;
case ComputerNameDnsFullyQualified:
case ComputerNamePhysicalDnsFullyQualified:
//
// This is the tricky case. We have to construct the name from
// the two components for the caller.
//
//
// In general, don't set the last status, since we'll end up using
// the other calls to handle that for us.
//
DontSetReturn = TRUE ;
Status = STATUS_UNSUCCESSFUL ;
if ( lpBuffer == NULL )
{
//
// If this is just the computation call, quickly do the
// two components
//
HostLength = DomainLength = 0 ;
GetComputerNameExW( ComputerNameDnsHostname, NULL, &HostLength );
if ( GetLastError() == ERROR_MORE_DATA )
{
GetComputerNameExW( ComputerNameDnsDomain, NULL, &DomainLength );
if ( GetLastError() == ERROR_MORE_DATA )
{
//
// Simply add. Note that since both account for a
// null terminator, the '.' that goes between them is
// covered.
//
*nSize = HostLength + DomainLength ;
Status = STATUS_BUFFER_OVERFLOW ;
DontSetReturn = FALSE ;
}
}
}
else
{
HostLength = *nSize ;
if ( GetComputerNameExW( ComputerNameDnsHostname,
lpBuffer,
&HostLength ) )
{
HostLength += 1; // Add in the zero character (or . depending on perspective)
lpBuffer[ HostLength - 1 ] = L'.';
DomainLength = *nSize - HostLength ;
if (GetComputerNameExW( ComputerNameDnsDomain,
&lpBuffer[ HostLength ],
&DomainLength ) )
{
Status = STATUS_SUCCESS ;
if ( DomainLength == 0 )
{
lpBuffer[ HostLength - 1 ] = L'\0';
HostLength-- ;
}
else if ( ( DomainLength == 1 ) &&
( lpBuffer[ HostLength ] == L'.' ) )
{
//
// Legally, the domain name can be a single
// dot '.', indicating that this host is part
// of the root domain. An odd case, to be sure,
// but needs to be handled. Since we've already
// stuck a dot separator in the result string,
// get rid of this one, and adjust the values
// accordingly.
//
lpBuffer[ HostLength ] = L'\0' ;
DomainLength = 0 ;
}
*nSize = HostLength + DomainLength ;
DontSetReturn = TRUE ;
}
else if ( GetLastError() == ERROR_MORE_DATA )
{
//
// Simply add. Note that since both account for a
// null terminator, the '.' that goes between them is
// covered.
//
*nSize = HostLength + DomainLength ;
Status = STATUS_BUFFER_OVERFLOW ;
DontSetReturn = FALSE ;
}
else
{
//
// Other error from trying to get the DNS Domain name.
// Let the error from the call trickle back.
//
*nSize = 0 ;
Status = STATUS_UNSUCCESSFUL ;
DontSetReturn = TRUE ;
}
}
else if ( GetLastError() == ERROR_MORE_DATA )
{
DomainLength = 0;
GetComputerNameExW( ComputerNameDnsDomain, NULL, &DomainLength );
if ( GetLastError() == ERROR_MORE_DATA )
{
//
// Simply add. Note that since both account for a
// null terminator, the '.' that goes between them is
// covered.
//
*nSize = HostLength + DomainLength ;
Status = STATUS_BUFFER_OVERFLOW ;
DontSetReturn = FALSE ;
}
}
else
{
//
// Other error from trying to get the DNS Hostname.
// Let the error from the call trickle back.
//
*nSize = 0 ;
Status = STATUS_UNSUCCESSFUL ;
DontSetReturn = TRUE ;
}
}
break;
}
if ( !NT_SUCCESS( Status ) )
{
if ( !DontSetReturn )
{
BaseSetLastNTError( Status );
}
return FALSE ;
}
return TRUE ;
}
BOOL
WINAPI
SetComputerNameExW(
IN COMPUTER_NAME_FORMAT NameType,
IN LPCWSTR lpBuffer
)
/*++
Routine Description:
This sets what the computername will be when the system is next booted. This
does not effect the active computername for the remainder of this boot, nor
what is returned by GetComputerName before the next system boot.
Arguments:
NameType - Name to set for the system
lpComputerName - points to the buffer that is contains the
null-terminated character string containing the computer name.
Return Value:
Returns TRUE on success, FALSE on failure.
--*/
{
ULONG Length ;
//
// Validate name:
//
if ( !lpBuffer )
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE ;
}
Length = wcslen( lpBuffer );
if ( Length )
{
if ( ( lpBuffer[0] == L' ') ||
( lpBuffer[ Length - 1 ] == L' ' ) )
{
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE ;
}
}
if (wcscspn(lpBuffer, ILLEGAL_NAME_CHARS_STR) < Length) {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
switch ( NameType ) {
case ComputerNamePhysicalNetBIOS:
return BaseSetNetbiosName( lpBuffer );
case ComputerNamePhysicalDnsHostname:
return (BaseValidateDnsHostname(lpBuffer) && BaseSetDnsName( lpBuffer ));
case ComputerNamePhysicalDnsDomain:
return (BaseValidateDnsDomain(lpBuffer) && BaseSetDnsDomain( lpBuffer ));
default:
SetLastError( ERROR_INVALID_PARAMETER );
return FALSE ;
}
}
//
// ANSI APIs
//
BOOL
WINAPI
GetComputerNameA (
LPSTR lpBuffer,
LPDWORD nSize
)
/*++
Routine Description:
This returns the active computername. This is the computername when the
system was last booted. If this is changed (via SetComputerName) it does
not take effect until the next system boot.
Arguments:
lpBuffer - Points to the buffer that is to receive the
null-terminated character string containing the computer name.
nSize - Specifies the maximum size (in characters) of the buffer. This
value should be set to at least MAX_COMPUTERNAME_LENGTH to allow
sufficient room in the buffer for the computer name. The length of
the string is returned in nSize.
Return Value:
TRUE on success, FALSE on failure.
--*/
{
UNICODE_STRING UnicodeString;
ANSI_STRING AnsiString;
LPWSTR UnicodeBuffer;
ULONG AnsiSize;
ULONG UnicodeSize;
NTSTATUS Status;
//
// Work buffer needs to be twice the size of the user's buffer
//
UnicodeBuffer = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), *nSize * sizeof(WCHAR));
if (!UnicodeBuffer) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return(FALSE);
}
//
// Set up an ANSI_STRING that points to the user's buffer
//
AnsiString.MaximumLength = (USHORT) *nSize;
AnsiString.Length = 0;
AnsiString.Buffer = lpBuffer;
//
// Call the UNICODE version to do the work
//
UnicodeSize = *nSize ;
if (!GetComputerNameW(UnicodeBuffer, &UnicodeSize)) {
RtlFreeHeap(RtlProcessHeap(), 0, UnicodeBuffer);
return(FALSE);
}
//
// Find out the required size of the ANSI buffer and validate it against
// the passed in buffer size
//
RtlInitUnicodeString(&UnicodeString, UnicodeBuffer);
AnsiSize = RtlUnicodeStringToAnsiSize(&UnicodeString);
if (AnsiSize > *nSize) {
RtlFreeHeap(RtlProcessHeap(), 0, UnicodeBuffer);
BaseSetLastNTError( STATUS_BUFFER_OVERFLOW );
*nSize = AnsiSize + 1 ;
return(FALSE);
}
//
// Now convert back to ANSI for the caller
//
Status = RtlUnicodeStringToAnsiString(&AnsiString, &UnicodeString, FALSE);
RtlFreeHeap(RtlProcessHeap(), 0, UnicodeBuffer);
if (! NT_SUCCESS(Status)) {
BaseSetLastNTError(Status);
*nSize = 0;
return FALSE;
}
*nSize = AnsiString.Length;
return(TRUE);
}
BOOL
WINAPI
SetComputerNameA (
LPCSTR lpComputerName
)
/*++
Routine Description:
This sets what the computername will be when the system is next booted. This
does not effect the active computername for the remainder of this boot, nor
what is returned by GetComputerName before the next system boot.
Arguments:
lpComputerName - points to the buffer that is contains the
null-terminated character string containing the computer name.
Return Value:
Returns TRUE on success, FALSE on failure.
--*/
{
NTSTATUS NtStatus;
BOOL ReturnValue;
UNICODE_STRING UnicodeString;
ANSI_STRING AnsiString;
ULONG ComputerNameLength;
//
// Validate that the supplied computername is valid (not too long,
// no incorrect characters, no leading or trailing spaces)
//
ComputerNameLength = strlen(lpComputerName);
if ((ComputerNameLength == 0 )||(ComputerNameLength > MAX_COMPUTERNAME_LENGTH)) {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
RtlInitAnsiString(&AnsiString, lpComputerName);
NtStatus = RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString,
TRUE);
if (!NT_SUCCESS(NtStatus)) {
BaseSetLastNTError(NtStatus);
return(FALSE);
}
ReturnValue = SetComputerNameW((LPCWSTR)UnicodeString.Buffer);
RtlFreeUnicodeString(&UnicodeString);
return(ReturnValue);
}
BOOL
WINAPI
GetComputerNameExA(
IN COMPUTER_NAME_FORMAT NameType,
OUT LPSTR lpBuffer,
IN OUT LPDWORD nSize
)
/*++
Routine Description:
This returns the active computername in a particular format. This is the
computername when the system was last booted. If this is changed (via
SetComputerName) it does not take effect until the next system boot.
Arguments:
NameType - Possible name formats to return the computer name in:
ComputerNameNetBIOS - netbios name (compatible with GetComputerName)
ComputerNameDnsHostname - DNS host name
ComputerNameDnsDomain - DNS Domain name
ComputerNameDnsFullyQualified - DNS Fully Qualified (hostname.dnsdomain)
lpBuffer - Points to the buffer that is to receive the
null-terminated character string containing the computer name.
nSize - Specifies the maximum size (in characters) of the buffer. This
value should be set to at least MAX_COMPUTERNAME_LENGTH + 1 to allow
sufficient room in the buffer for the computer name. The length
of the string is returned in nSize.
Return Value:
TRUE on success, FALSE on failure.
--*/
{
LPWSTR UnicodeBuffer;
//
// Validate Input
//
if ((nSize==NULL) || ((lpBuffer==NULL) && (*nSize>0))) {
SetLastError(ERROR_INVALID_PARAMETER);
return(FALSE);
}
//
// Work buffer needs to be twice the size of the user's buffer
//
UnicodeBuffer = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), *nSize * sizeof(WCHAR));
if (!UnicodeBuffer) {
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return(FALSE);
}
//
// Call the UNICODE version to do the work
//
if ( !GetComputerNameExW(NameType, UnicodeBuffer, nSize) ) {
RtlFreeHeap(RtlProcessHeap(), 0, UnicodeBuffer);
return(FALSE);
}
//
// Now convert back to ANSI for the caller
// Note: Since we passed the above if statement,
// GetComputerNameExW succeeded, and set *nSize to the number of
// characters in the string (like wcslen). We need to convert
// all these characters and the trailing NULL, so inc *nSize for
// the conversion call.
//
WideCharToMultiByte(CP_ACP,
0,
UnicodeBuffer,
*nSize+1,
lpBuffer,
(*nSize+1) * sizeof(CHAR),
NULL,
NULL);
RtlFreeHeap(RtlProcessHeap(), 0, UnicodeBuffer);
return(TRUE);
}
BOOL
WINAPI
SetComputerNameExA(
IN COMPUTER_NAME_FORMAT NameType,
IN LPCSTR lpBuffer
)
/*++
Routine Description:
This sets what the computername will be when the system is next booted. This
does not effect the active computername for the remainder of this boot, nor
what is returned by GetComputerName before the next system boot.
Arguments:
NameType - Name to set for the system
lpComputerName - points to the buffer that is contains the
null-terminated character string containing the computer name.
Return Value:
Returns TRUE on success, FALSE on failure.
--*/
{
NTSTATUS NtStatus;
BOOL ReturnValue;
UNICODE_STRING UnicodeString;
ANSI_STRING AnsiString;
RtlInitAnsiString(&AnsiString, lpBuffer);
NtStatus = RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString,
TRUE);
if (!NT_SUCCESS(NtStatus)) {
BaseSetLastNTError(NtStatus);
return(FALSE);
}
ReturnValue = SetComputerNameExW(NameType, (LPCWSTR)UnicodeString.Buffer );
RtlFreeUnicodeString(&UnicodeString);
return(ReturnValue);
}
DWORD
WINAPI
AddLocalAlternateComputerNameW(
LPCWSTR lpDnsFQHostname,
ULONG ulFlags
)
/*++
Routine Description:
This sets an alternate computer name for the computer to begin to
respond to.
Arguments:
lpDnsFQHostname - The alternate name to add (in ComputerNameDnsFullyQualified Format)
ulFlags - TBD
Return Value:
Returns ERROR
--*/
{
NTSTATUS status = STATUS_SUCCESS;
DWORD err = ERROR_SUCCESS;
LPWSTR lpNetBiosCompName = NULL;
ULONG ulNetBiosCompNameSize = 0;
//
// validate input
//
if ((lpDnsFQHostname==NULL) || (!BaseValidateFlags(ulFlags)) || (!BaseValidateFQDnsName(lpDnsFQHostname))) {
return ERROR_INVALID_PARAMETER;
}
// get write lock?
status = BaseAddMultiNameInReg(
DNSCACHE_ROOT,
DNS_ALT_HOSTNAME,
lpDnsFQHostname);
err = RtlNtStatusToDosError(status);
if (err==ERROR_SUCCESS) {
// get NetBios name (use DNSHostNameToComputerNameW) and add that to reg for OptionalNames
if (!DnsHostnameToComputerNameW(
lpDnsFQHostname,
NULL,
&ulNetBiosCompNameSize)) {
err = GetLastError();
}
if (err==ERROR_MORE_DATA) {
// bug in DNSHostname, returns a size 1 character too small (forgets null)
// update when bug is fixed...
ulNetBiosCompNameSize += 1;
lpNetBiosCompName = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), ulNetBiosCompNameSize * sizeof(WCHAR));
if (lpNetBiosCompName==NULL) {
err = ERROR_NOT_ENOUGH_MEMORY;
}
else {
if (!DnsHostnameToComputerNameW(lpDnsFQHostname,
lpNetBiosCompName,
&ulNetBiosCompNameSize)) {
err = GetLastError();
}
else if (!BaseSetAltNetBiosName(lpNetBiosCompName)) {
err = GetLastError();
} else {
err = ERROR_SUCCESS;
}
RtlFreeHeap(RtlProcessHeap(), 0, lpNetBiosCompName);
}
}
if (err!=ERROR_SUCCESS) {
// remove multi name in reg
// rollback?
}
}
// release write lock?
return err;
}
DWORD
WINAPI
AddLocalAlternateComputerNameA(
LPCSTR lpDnsFQHostname,
ULONG ulFlags
)
{
LPWSTR lpDnsFQHostnameW = NULL;
DWORD err = ERROR_SUCCESS;
if (lpDnsFQHostname==NULL) {
return ERROR_INVALID_PARAMETER;
}
err = BaseMultiByteToWideCharWithAlloc(lpDnsFQHostname, &lpDnsFQHostnameW);
if (err==ERROR_SUCCESS) {
err = AddLocalAlternateComputerNameW(lpDnsFQHostnameW, ulFlags);
}
BaseConvertCharFree((VOID *)lpDnsFQHostnameW);
return err;
}
DWORD
WINAPI
RemoveLocalAlternateComputerNameW(
LPCWSTR lpAltDnsFQHostname,
ULONG ulFlags
)
/*++
Routine Description:
Remove an alternate computer name.
Arguments:
lpAltDnsFQHostname - The alternate name to remove(in ComputerNameDnsFullyQualified Format)
ulFlags - TBD
Return Value:
Returns ERROR
--*/
{
DWORD err = ERROR_SUCCESS;
NTSTATUS NtStatus = STATUS_SUCCESS;
LPWSTR lpAltNetBiosCompName = NULL;
ULONG cchAltNetBiosCompName = 0;
if ((!BaseValidateFlags(ulFlags)) || (lpAltDnsFQHostname==NULL)) {
return ERROR_INVALID_PARAMETER;
}
// aquire a write lock?
NtStatus = BaseRemoveMultiNameFromReg(DNSCACHE_ROOT, DNS_ALT_HOSTNAME, lpAltDnsFQHostname);
err = RtlNtStatusToDosError(NtStatus);
if (err==ERROR_SUCCESS) {
if (!DnsHostnameToComputerNameW(
lpAltDnsFQHostname,
NULL,
&cchAltNetBiosCompName)) {
err = GetLastError();
}
if (err==ERROR_MORE_DATA) {
// bug in DNSHostname, returns a size 1 character too small (forgets null)
cchAltNetBiosCompName += 1;
lpAltNetBiosCompName = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), cchAltNetBiosCompName * sizeof(WCHAR));
if (lpAltNetBiosCompName==NULL) {
err = ERROR_NOT_ENOUGH_MEMORY;
}
else {
if (!DnsHostnameToComputerNameW(lpAltDnsFQHostname,
lpAltNetBiosCompName,
&cchAltNetBiosCompName)) {
err = GetLastError();
} else if (BaseIsNetBiosNameInUse(lpAltNetBiosCompName)) {
err = ERROR_SUCCESS;
// do nothing, this name is still being used by another AltDnsHostname ...
} else if (!BaseRemoveAltNetBiosName(lpAltNetBiosCompName)) {
err = GetLastError();
} else {
err = ERROR_SUCCESS;
}
RtlFreeHeap(RtlProcessHeap(), 0, lpAltNetBiosCompName);
}
}
}
// release write lock?
return err;
}
DWORD
WINAPI
RemoveLocalAlternateComputerNameA(
LPCSTR lpAltDnsFQHostname,
ULONG ulFlags
)
{
LPWSTR lpAltDnsFQHostnameW = NULL;
DWORD err = ERROR_SUCCESS;
if (lpAltDnsFQHostname==NULL) {
return ERROR_INVALID_PARAMETER;
}
err = BaseMultiByteToWideCharWithAlloc(lpAltDnsFQHostname, &lpAltDnsFQHostnameW);
if (err==ERROR_SUCCESS) {
err = RemoveLocalAlternateComputerNameW(lpAltDnsFQHostnameW, ulFlags);
}
BaseConvertCharFree((VOID *)lpAltDnsFQHostnameW);
return err;
}
DWORD
WINAPI
SetLocalPrimaryComputerNameW(
LPCWSTR lpAltDnsFQHostname,
ULONG ulFlags
)
/*++
Routine Description:
Set the computer name to the inputed altCompName
Arguments:
lpAltDnsFQHostname - The name to set the computer to (in ComputerNameDnsFullyQualified Format)
ulFlags - TBD
Return Value:
Returns ERROR
--*/
{
DWORD err = ERROR_SUCCESS;
ULONG cchNetBiosName = 0;
LPWSTR lpNetBiosName = NULL;
ULONG cchCompName = 0;
LPWSTR lpCompName = NULL;
LPWSTR lpHostname = BaseParseDnsName(lpAltDnsFQHostname, DNS_HOSTNAME);
LPWSTR lpDomainName = BaseParseDnsName(lpAltDnsFQHostname, DNS_DOMAINNAME);
if ((lpAltDnsFQHostname==NULL) || (!BaseValidateFlags(ulFlags))) {
return ERROR_INVALID_PARAMETER;
}
// aquire a write lock?
// check to see that the given name is a valid alternate dns hostname
if (!BaseIsAltDnsFQHostname(lpAltDnsFQHostname)) {
if (lpHostname) {
RtlFreeHeap(RtlProcessHeap(), 0, lpHostname);
}
if (lpDomainName) {
RtlFreeHeap(RtlProcessHeap(), 0, lpDomainName);
}
return ERROR_INVALID_PARAMETER;
}
// get the current netbios name and add it to the alternate names
if (!GetComputerNameExW(ComputerNamePhysicalNetBIOS, NULL, &cchNetBiosName)) {
err = GetLastError();
}
if (err==ERROR_MORE_DATA) {
lpNetBiosName = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), cchNetBiosName*sizeof(WCHAR));
if (lpNetBiosName==NULL) {
err = ERROR_NOT_ENOUGH_MEMORY;
}
else if (!GetComputerNameExW(ComputerNamePhysicalNetBIOS, lpNetBiosName, &cchNetBiosName)) {
err = GetLastError();
}
else if (!BaseSetAltNetBiosName(lpNetBiosName)) {
err = GetLastError();
}
else {
err = ERROR_SUCCESS;
}
if (lpNetBiosName) {
RtlFreeHeap(RtlProcessHeap(), 0, lpNetBiosName);
}
}
// get the current non-volatile netbios name and add it to the alternate names
lpNetBiosName = BasepGetNameNonVolatile(ComputerNamePhysicalNetBIOS);
if (lpNetBiosName!=NULL) {
if (!BaseSetAltNetBiosName(lpNetBiosName)) {
err = GetLastError();
}
else {
err = ERROR_SUCCESS;
}
RtlFreeHeap(RtlProcessHeap(), 0, lpNetBiosName);
}
if (err==ERROR_SUCCESS) {
// add the current physical dnsname to the list of alternate hostnames...
if (!GetComputerNameExW(ComputerNamePhysicalDnsFullyQualified, NULL, &cchCompName)) {
err = GetLastError();
}
if (err==ERROR_MORE_DATA) {
lpCompName = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), cchCompName*sizeof(WCHAR));
if (lpCompName==NULL) {
err = ERROR_NOT_ENOUGH_MEMORY;
}
else if (!GetComputerNameExW(ComputerNamePhysicalDnsFullyQualified, lpCompName, &cchCompName)) {
err = GetLastError();
}
else if (!BaseSetAltDnsFQHostname(lpCompName)) {
err = GetLastError();
}
else {
err = ERROR_SUCCESS;
}
if (lpCompName) {
RtlFreeHeap(RtlProcessHeap(), 0, lpCompName);
}
}
}
if (err==ERROR_SUCCESS) {
// add the non-volitile physical dnsname to the list of alternate hostnames...
lpCompName = BasepGetNameNonVolatile(ComputerNamePhysicalDnsFullyQualified);
if (lpNetBiosName!=NULL) {
if (!BaseSetAltDnsFQHostname(lpCompName)) {
err = GetLastError();
}
else {
err = ERROR_SUCCESS;
}
RtlFreeHeap(RtlProcessHeap(), 0, lpCompName);
}
}
// set the new physical dns hostname
if (err==ERROR_SUCCESS) {
if (!SetComputerNameExW(ComputerNamePhysicalDnsHostname, lpHostname)) {
err = GetLastError();
}
}
if (err==ERROR_SUCCESS) {
if (!SetComputerNameExW(ComputerNamePhysicalDnsDomain, lpDomainName)) {
err = GetLastError();
}
}
// remove the alternate name (now primary) from the alternate lists
if (err==ERROR_SUCCESS) {
err = RemoveLocalAlternateComputerNameW(lpAltDnsFQHostname, 0);
}
if (lpHostname) {
RtlFreeHeap(RtlProcessHeap(), 0, lpHostname);
}
if (lpDomainName) {
RtlFreeHeap(RtlProcessHeap(), 0, lpDomainName);
}
// release write lock?
return err;
}
DWORD
WINAPI
SetLocalPrimaryComputerNameA(
LPCSTR lpAltDnsFQHostname,
ULONG ulFlags
)
{
LPWSTR lpAltDnsFQHostnameW = NULL;
DWORD err = ERROR_SUCCESS;
if (lpAltDnsFQHostname==NULL) {
return ERROR_INVALID_PARAMETER;
}
err = BaseMultiByteToWideCharWithAlloc(lpAltDnsFQHostname, &lpAltDnsFQHostnameW);
if (err == ERROR_SUCCESS) {
err = SetLocalPrimaryComputerNameW(lpAltDnsFQHostnameW, ulFlags);
}
BaseConvertCharFree((VOID *)lpAltDnsFQHostnameW);
return err;
}
DWORD
WINAPI
EnumerateLocalComputerNamesW(
COMPUTER_NAME_TYPE NameType,
ULONG ulFlags,
LPWSTR lpDnsFQHostnames,
LPDWORD nSize
)
/*++
Routine Description:
Returns the value of the computer's names requested. The returned values are concatenated together,
with a trailing NULl terminating the output (since each name is a LPWSTR, the end of lpDnsFQHostname
has 2 NULLS, one for the last name, and one to terminate lpDnsFQHostname).
Arguments:
NameType - Which of the computer's names are requested
PrimaryComputerName - Similar to GetComputerEx(ComputerNamePhysicalNetBios, ...
AlternateComputerNames - All known alt names
AllComputerNames - All of the above
ulFlags - TBD
lpBuffer - Buffer to hold returned names concatenated together, and trailed with a NULL
nSize - Size of buffer to hold returned names.
Return Value:
Returns ERROR
--*/
{
DWORD err = ERROR_SUCCESS;
DWORD SizePrimary = 0;
DWORD SizeAlternate = 0;
LPWSTR lpTempCompNames = NULL;
if ((!BaseValidateFlags(ulFlags)) || (NameType>=ComputerNameTypeMax) || (NameType<PrimaryComputerName)) {
return ERROR_INVALID_PARAMETER;
}
// get read lock?
switch(NameType) {
case PrimaryComputerName:
if (nSize==NULL) {
err = ERROR_INVALID_PARAMETER;
}
else {
SizePrimary = *nSize ? *nSize - 1 : *nSize; // if *nSize == 0, pass in 0 else pass in *nSize - 1
if (!GetComputerNameExW(ComputerNamePhysicalDnsFullyQualified, lpDnsFQHostnames, &SizePrimary)) {
err = GetLastError();
}
else {
if (lpDnsFQHostnames!=NULL) {
// this test should be purely for prefix's benefit
// GetComputerNameExW *should* never return successfully if lpDnsFQHostnames
// is NULL.
lpDnsFQHostnames[SizePrimary + 1] = L'\0';
} else {
// should NEVER happen - can't assert or log here, so just error out.
err = ERROR_GEN_FAILURE;
}
}
*nSize = SizePrimary + 1;
}
break;
case AlternateComputerNames:
if ((nSize==NULL) || ((lpDnsFQHostnames==NULL) && (*nSize>0))) {
err = ERROR_INVALID_PARAMETER;
}
else {
err = BaseEnumAltDnsFQHostnames(lpDnsFQHostnames, nSize);
}
break;
case AllComputerNames:
if ((nSize==NULL) || ((lpDnsFQHostnames==NULL) && (*nSize>0))) {
err = ERROR_INVALID_PARAMETER;
}
else {
SizePrimary = *nSize;
lpTempCompNames = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), *nSize * sizeof(WCHAR));
if (lpTempCompNames==NULL) {
err = ERROR_NOT_ENOUGH_MEMORY;
break;
}
// Get primary name
if (!GetComputerNameExW(ComputerNamePhysicalDnsFullyQualified, lpTempCompNames, &SizePrimary)) {
err = GetLastError();
}
// on success, holds the number of characters copied into lpTempCompNames NOT counting NULL
// on failure, holds the space needed to copy in, (num characters PLUS NULL)
if (err==ERROR_SUCCESS) {
SizeAlternate = *nSize - (SizePrimary + 1);
err = BaseEnumAltDnsFQHostnames(lpTempCompNames+SizePrimary+1, &SizeAlternate);
*nSize = SizePrimary + 1 + SizeAlternate;
if (err==ERROR_SUCCESS) {
memcpy(lpDnsFQHostnames, lpTempCompNames, (*nSize+1)*sizeof(WCHAR));
}
}
else if (err==ERROR_MORE_DATA) {
// return total size required
SizeAlternate = 0;
err = BaseEnumAltDnsFQHostnames(NULL, &SizeAlternate);
if (err==ERROR_SUCCESS) {
// no alt names exist, keep ERROR_MORE_DATA to return to client
err = ERROR_MORE_DATA;
}
*nSize = SizePrimary + SizeAlternate;
}
RtlFreeHeap(RtlProcessHeap(), 0, lpTempCompNames);
}
break;
default:
err = ERROR_INVALID_PARAMETER;
break;
}
// release read lock?
return err;
}
DWORD
WINAPI
EnumerateLocalComputerNamesA(
COMPUTER_NAME_TYPE NameType,
ULONG ulFlags,
LPSTR lpDnsFQHostnames,
LPDWORD nSize
)
{
DWORD err = ERROR_SUCCESS;
LPWSTR lpDnsFQHostnamesW = NULL;
//
// Validate Input
//
if ((nSize==NULL) || ((lpDnsFQHostnames==NULL) && (*nSize>0))) {
return ERROR_INVALID_PARAMETER;
}
if (lpDnsFQHostnames!=NULL) {
lpDnsFQHostnamesW = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), *nSize * sizeof(WCHAR));
if (lpDnsFQHostnamesW==NULL) {
err = ERROR_NOT_ENOUGH_MEMORY;
}
}
if (err==ERROR_SUCCESS) {
err = EnumerateLocalComputerNamesW(NameType, ulFlags, lpDnsFQHostnamesW, nSize);
}
if (err==ERROR_SUCCESS) {
if (!WideCharToMultiByte(CP_ACP, 0, lpDnsFQHostnamesW, *nSize+1,
lpDnsFQHostnames, (*nSize+1)* sizeof(CHAR), NULL, NULL)) {
err = GetLastError();
}
}
if (lpDnsFQHostnamesW) {
RtlFreeHeap(RtlProcessHeap(), 0, lpDnsFQHostnamesW);
}
return err;
}
BOOL
WINAPI
DnsHostnameToComputerNameW(
IN LPCWSTR Hostname,
OUT LPWSTR ComputerName,
IN OUT LPDWORD nSize)
/*++
Routine Description:
This routine will convert a DNS Hostname to a Win32 Computer Name.
Arguments:
Hostname - DNS Hostname (any length)
ComputerName - Win32 Computer Name (max length of MAX_COMPUTERNAME_LENGTH)
nSize - On input, size of the buffer pointed to by ComputerName. On output,
size of the Computer Name, in characters.
Return Value:
Returns TRUE on success, FALSE on failure.
--*/
{
WCHAR CompName[ MAX_COMPUTERNAME_LENGTH + 1 ];
DWORD Size = MAX_COMPUTERNAME_LENGTH + 1 ;
UNICODE_STRING CompName_U ;
UNICODE_STRING Hostname_U ;
NTSTATUS Status ;
BOOL Ret ;
CompName[0] = L'\0';
CompName_U.Buffer = CompName ;
CompName_U.Length = 0 ;
CompName_U.MaximumLength = (MAX_COMPUTERNAME_LENGTH + 1) * sizeof( WCHAR );
RtlInitUnicodeString( &Hostname_U, Hostname );
Status = RtlDnsHostNameToComputerName( &CompName_U,
&Hostname_U,
FALSE );
if ( NT_SUCCESS( Status ) )
{
if ( *nSize >= CompName_U.Length / sizeof(WCHAR) + 1 )
{
RtlCopyMemory( ComputerName,
CompName_U.Buffer,
CompName_U.Length );
ComputerName[ CompName_U.Length / sizeof( WCHAR ) ] = L'\0';
Ret = TRUE ;
}
else
{
BaseSetLastNTError( STATUS_BUFFER_OVERFLOW );
Ret = FALSE ;
}
//
// returns the count of characters
//
*nSize = CompName_U.Length / sizeof( WCHAR );
}
else
{
BaseSetLastNTError( Status );
Ret = FALSE ;
}
return Ret ;
}
BOOL
WINAPI
DnsHostnameToComputerNameA(
IN LPCSTR Hostname,
OUT LPSTR ComputerName,
IN OUT LPDWORD nSize)
/*++
Routine Description:
This routine will convert a DNS Hostname to a Win32 Computer Name.
Arguments:
Hostname - DNS Hostname (any length)
ComputerName - Win32 Computer Name (max length of MAX_COMPUTERNAME_LENGTH)
nSize - On input, size of the buffer pointed to by ComputerName. On output,
size of the Computer Name, in characters.
Return Value:
Returns TRUE on success, FALSE on failure.
--*/
{
WCHAR CompName[ MAX_COMPUTERNAME_LENGTH + 1 ];
DWORD Size = MAX_COMPUTERNAME_LENGTH + 1;
BOOL Ret ;
UNICODE_STRING CompName_U ;
UNICODE_STRING Hostname_U ;
NTSTATUS Status ;
ANSI_STRING CompName_A ;
if ( RtlCreateUnicodeStringFromAsciiz( &Hostname_U, Hostname ) )
{
CompName[0] = L'\0';
CompName_U.Buffer = CompName ;
CompName_U.Length = 0 ;
CompName_U.MaximumLength = (MAX_COMPUTERNAME_LENGTH + 1) * sizeof( WCHAR );
Status = RtlDnsHostNameToComputerName( &CompName_U,
&Hostname_U,
FALSE );
if ( NT_SUCCESS( Status ) )
{
CompName_A.Buffer = ComputerName ;
CompName_A.Length = 0 ;
CompName_A.MaximumLength = (USHORT) *nSize ;
Status = RtlUnicodeStringToAnsiString( &CompName_A, &CompName_U, FALSE );
if ( NT_SUCCESS( Status ) )
{
*nSize = CompName_A.Length ;
}
}
} else {
Status = STATUS_NO_MEMORY;
}
if ( !NT_SUCCESS( Status ) )
{
BaseSetLastNTError( Status );
return FALSE ;
}
return TRUE ;
}
#include "dfsfsctl.h"
DWORD
BasepGetComputerNameFromNtPath (
PUNICODE_STRING NtPathName,
HANDLE hFile,
LPWSTR lpBuffer,
LPDWORD nSize
)
/*++
Routine Description:
Look at a path and determine the computer name of the host machine.
In the future, we should remove this code, and add the capbility to query
handles for their computer name.
The name can only be obtained for NetBios paths - if the path is IP or DNS
an error is returned. (If the NetBios name has a "." in it, it will
cause an error because it will be misinterpreted as a DNS path. This case
becomes less and less likely as the NT5 UI doesn't allow such computer names.)
For DFS paths, the leaf server's name is returned, as long as it wasn't
joined to its parent with an IP or DNS path name.
Arguments:
NtPathName - points to a unicode string with the path to query.
lpBuffer - points to buffer receives the computer name
nSize - points to dword with the size of the input buffer, and the length
(in characters, not including the null terminator) of the computer name
on output.
Return Value:
A Win32 error code.
--*/
{
ULONG cbComputer = 0;
DWORD dwError = ERROR_BAD_PATHNAME;
ULONG AvailableLength = 0;
PWCHAR PathCharacter = NULL;
BOOL CheckForDfs = TRUE;
NTSTATUS NtStatus = STATUS_SUCCESS;
IO_STATUS_BLOCK IoStatusBlock;
WCHAR FileNameInfoBuffer[MAX_PATH+sizeof(FILE_NAME_INFORMATION)];
PFILE_NAME_INFORMATION FileNameInfo = (PFILE_NAME_INFORMATION)FileNameInfoBuffer;
WCHAR DfsServerPathName[ MAX_PATH + 1 ];
WCHAR DosDevice[3] = { L"A:" };
WCHAR DosDeviceMapping[ MAX_PATH + 1 ];
UNICODE_STRING UnicodeComputerName;
const UNICODE_STRING NtUncPathNamePrefix = { 16, 18, L"\\??\\UNC\\"};
const ULONG cchNtUncPathNamePrefix = 8;
const UNICODE_STRING NtDrivePathNamePrefix = { 8, 10, L"\\??\\" };
const ULONG cchNtDrivePathNamePrefix = 4;
RtlInitUnicodeString( &UnicodeComputerName, NULL );
// Is this a UNC path?
if( RtlPrefixString( (PSTRING)&NtUncPathNamePrefix, (PSTRING)NtPathName, TRUE )) {
// Make sure there's some more to this path than just the prefix
if( NtPathName->Length <= NtUncPathNamePrefix.Length )
goto Exit;
// It appears to be a valid UNC path. Point to the beginning of the computer
// name, and calculate how much room is left in NtPathName after that.
UnicodeComputerName.Buffer = &NtPathName->Buffer[ NtUncPathNamePrefix.Length/sizeof(WCHAR) ];
AvailableLength = NtPathName->Length - NtUncPathNamePrefix.Length;
}
// If it's not a UNC path, then is it a drive-letter path?
else if( RtlPrefixString( (PSTRING)&NtDrivePathNamePrefix, (PSTRING)NtPathName, TRUE )
&&
NtPathName->Buffer[ cchNtDrivePathNamePrefix + 1 ] == L':' ) {
// It's a drive letter path, but it could still be local or remote
static const WCHAR RedirectorMappingPrefix[] = { L"\\Device\\LanmanRedirector\\;" };
static const WCHAR LocalVolumeMappingPrefix[] = { L"\\Device\\Harddisk" };
static const WCHAR CDRomMappingPrefix[] = { L"\\Device\\CdRom" };
static const WCHAR FloppyMappingPrefix[] = { L"\\Device\\Floppy" };
static const WCHAR DfsMappingPrefix[] = { L"\\Device\\WinDfs\\" };
// Get the correct, upper-cased, drive letter into DosDevice.
DosDevice[0] = NtPathName->Buffer[ cchNtDrivePathNamePrefix ];
if( L'a' <= DosDevice[0] && DosDevice[0] <= L'z' )
DosDevice[0] = L'A' + (DosDevice[0] - L'a');
// Map the drive letter to its symbolic link under \??. E.g., say C:, D: & R:
// are local/DFS/rdr drives, respectively. You would then see something like:
//
// C: => \Device\Volume1
// D: => \Device\WinDfs\G
// R: => \Device\LanmanRedirector\;R:0\scratch\scratch
if( !QueryDosDeviceW( DosDevice, DosDeviceMapping, sizeof(DosDeviceMapping)/sizeof(DosDeviceMapping[0]) )) {
dwError = GetLastError();
goto Exit;
}
// Now that we have the DosDeviceMapping, we can check ... Is this a rdr drive?
if( // Does it begin with "\Device\LanmanRedirector\;" ?
DosDeviceMapping == wcsstr( DosDeviceMapping, RedirectorMappingPrefix )
&&
// Are the next letters the correct drive letter, a colon, and a whack?
( DosDevice[0] == DosDeviceMapping[ sizeof(RedirectorMappingPrefix)/sizeof(WCHAR) - 1 ]
&&
L':' == DosDeviceMapping[ sizeof(RedirectorMappingPrefix)/sizeof(WCHAR) ]
&&
(UnicodeComputerName.Buffer = wcschr(&DosDeviceMapping[ sizeof(RedirectorMappingPrefix)/sizeof(WCHAR) + 1 ], L'\\'))
)) {
// We have a valid rdr drive. Point to the beginning of the computer
// name, and calculate how much room is availble in DosDeviceMapping after that.
UnicodeComputerName.Buffer += 1;
AvailableLength = sizeof(DosDeviceMapping) - sizeof(DosDeviceMapping[0]) * (ULONG)(UnicodeComputerName.Buffer - DosDeviceMapping);
// We know now that it's not a DFS path
CheckForDfs = FALSE;
}
// If it's not a rdr drive, then maybe it's a local volume, floppy, or cdrom
else if( DosDeviceMapping == wcsstr( DosDeviceMapping, LocalVolumeMappingPrefix )
||
DosDeviceMapping == wcsstr( DosDeviceMapping, CDRomMappingPrefix )
||
DosDeviceMapping == wcsstr( DosDeviceMapping, FloppyMappingPrefix ) ) {
// We have a local drive, so just return the local computer name.
CheckForDfs = FALSE;
if( !GetComputerNameW( lpBuffer, nSize))
dwError = GetLastError();
else
dwError = ERROR_SUCCESS;
goto Exit;
}
// Finally, check to see if it's a DFS drive
else if( DosDeviceMapping == wcsstr( DosDeviceMapping, DfsMappingPrefix )) {
// Get the full UNC name of this DFS path. Later, we'll call the DFS
// driver to find out what the actual server name is.
NtStatus = NtQueryInformationFile(
hFile,
&IoStatusBlock,
FileNameInfo,
sizeof(FileNameInfoBuffer),
FileNameInformation
);
if( !NT_SUCCESS(NtStatus) ) {
dwError = RtlNtStatusToDosError(NtStatus);
goto Exit;
}
UnicodeComputerName.Buffer = FileNameInfo->FileName + 1;
AvailableLength = FileNameInfo->FileNameLength;
}
// Otherwise, it's not a rdr, dfs, or local drive, so there's nothing we can do.
else
goto Exit;
} // else if( RtlPrefixString( (PSTRING)&NtDrivePathNamePrefix, (PSTRING)NtPathName, TRUE ) ...
else {
dwError = ERROR_BAD_PATHNAME;
goto Exit;
}
// If we couldn't determine above if whether or not this is a DFS path, let the
// DFS driver decide now.
if( CheckForDfs && INVALID_HANDLE_VALUE != hFile ) {
HANDLE hDFS = INVALID_HANDLE_VALUE;
UNICODE_STRING DfsDriverName;
OBJECT_ATTRIBUTES ObjectAttributes;
WCHAR *DfsPathName = UnicodeComputerName.Buffer - 1; // Back up to the whack
ULONG DfsPathNameLength = AvailableLength + sizeof(WCHAR);
// Open the DFS driver
RtlInitUnicodeString( &DfsDriverName, DFS_DRIVER_NAME );
InitializeObjectAttributes( &ObjectAttributes,
&DfsDriverName,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
NtStatus = NtCreateFile(
&hDFS,
SYNCHRONIZE,
&ObjectAttributes,
&IoStatusBlock,
NULL,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
FILE_OPEN_IF,
FILE_CREATE_TREE_CONNECTION | FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0
);
if( !NT_SUCCESS(NtStatus) ) {
dwError = RtlNtStatusToDosError(NtStatus);
goto Exit;
}
// Query DFS's cache for the server name. The name is guaranteed to
// remain in the cache as long as the file is open.
if( L'\\' != DfsPathName[0] ) {
NtClose(hDFS);
dwError = ERROR_BAD_PATHNAME;
goto Exit;
}
NtStatus = NtFsControlFile(
hDFS,
NULL, // Event,
NULL, // ApcRoutine,
NULL, // ApcContext,
&IoStatusBlock,
FSCTL_DFS_GET_SERVER_NAME,
DfsPathName,
DfsPathNameLength,
DfsServerPathName,
sizeof(DfsServerPathName)
);
NtClose( hDFS );
// STATUS_OBJECT_NAME_NOT_FOUND means that it's not a DFS path
if( !NT_SUCCESS(NtStatus) ) {
if( STATUS_OBJECT_NAME_NOT_FOUND != NtStatus ) {
dwError = RtlNtStatusToDosError(NtStatus);
goto Exit;
}
}
else if( L'\0' != DfsServerPathName[0] ) {
// The previous DFS call returns the server-specific path to the file in UNC form.
// Point UnicodeComputerName to just past the two whacks.
AvailableLength = wcslen(DfsServerPathName) * sizeof(WCHAR);
if( 3*sizeof(WCHAR) > AvailableLength
||
L'\\' != DfsServerPathName[0]
||
L'\\' != DfsServerPathName[1] )
{
dwError = ERROR_BAD_PATHNAME;
goto Exit;
}
UnicodeComputerName.Buffer = DfsServerPathName + 2;
AvailableLength -= 2 * sizeof(WCHAR);
}
}
// If we get here, then the computer name\share is pointed to by UnicodeComputerName.Buffer.
// But the Length is currently zero, so we search for the whack that separates
// the computer name from the share, and set the Length to include just the computer name.
PathCharacter = UnicodeComputerName.Buffer;
while( ( (ULONG) ((PCHAR)PathCharacter - (PCHAR)UnicodeComputerName.Buffer) < AvailableLength)
&&
*PathCharacter != L'\\' ) {
// If we found a '.', we fail because this is probably a DNS or IP name.
if( L'.' == *PathCharacter ) {
dwError = ERROR_BAD_PATHNAME;
goto Exit;
}
PathCharacter++;
}
// Set the computer name length
UnicodeComputerName.Length = UnicodeComputerName.MaximumLength
= (USHORT) ((PCHAR)PathCharacter - (PCHAR)UnicodeComputerName.Buffer);
// Fail if the computer name exceeded the length of the input NtPathName,
// or if the length exceeds that allowed.
if( UnicodeComputerName.Length >= AvailableLength
||
UnicodeComputerName.Length > MAX_COMPUTERNAME_LENGTH*sizeof(WCHAR) ) {
goto Exit;
}
// Copy the computer name into the caller's buffer, as long as there's enough
// room for the name & a terminating '\0'.
if( UnicodeComputerName.Length + sizeof(WCHAR) > *nSize * sizeof(WCHAR) ) {
dwError = ERROR_BUFFER_OVERFLOW;
goto Exit;
}
RtlCopyMemory( lpBuffer, UnicodeComputerName.Buffer, UnicodeComputerName.Length );
*nSize = UnicodeComputerName.Length / sizeof(WCHAR);
lpBuffer[ *nSize ] = L'\0';
dwError = ERROR_SUCCESS;
Exit:
return( dwError );
}