able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/cluster/resdll/netname/nameutil.c

1993 lines
64 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1995-1996 Microsoft Corporation
Module Name:
nameutil.c
Abstract:
Routines for manipulating LM workstation and server names.
Author:
Mike Massa (mikemas) 29-Dec-1995
Revision History:
--*/
#define UNICODE 1
#include "clusres.h"
#include "clusrtl.h"
#include <tdi.h>
#include <lm.h>
#include <stdlib.h>
#include "netname.h"
#include "nameutil.h"
#include <dnsapi.h>
#include <dnslib.h>
//
// Constants
//
#define LOG_CURRENT_MODULE LOG_MODULE_NETNAME
//
// forward declarations
//
VOID
LogDnsFailureToEventLog(
IN HKEY ResourceKey,
IN LPWSTR DnsName,
IN LPWSTR ResourceName,
IN DWORD Status,
IN LPWSTR ConnectoidName
);
//
// Local Utility Routines
//
NET_API_STATUS
CheckForServerName(
IN RESOURCE_HANDLE ResourceHandle,
IN LPWSTR ServerName,
IN POEM_STRING OemServerNameString,
OUT PBOOLEAN IsNameRegistered
)
{
PSERVER_TRANSPORT_INFO_0 psti0 = NULL;
DWORD entriesRead = 0;
DWORD totalEntries = 0;
DWORD resumeHandle = 0;
NET_API_STATUS status;
DWORD i;
*IsNameRegistered = FALSE;
status = NetServerTransportEnum(
NULL,
0,
(LPBYTE *) &psti0,
(DWORD) -1,
&entriesRead,
&totalEntries,
&resumeHandle
);
if (status != NERR_Success) {
(NetNameLogEvent)(
ResourceHandle,
LOG_WARNING,
L"Unable to enumerate server tranports, error %1!u!.\n",
status
);
return(status);
}
for ( i=0; i < entriesRead; i++ ) {
if ( ( psti0[i].svti0_transportaddresslength ==
OemServerNameString->Length
)
&&
( RtlCompareMemory(
psti0[i].svti0_transportaddress,
OemServerNameString->Buffer,
OemServerNameString->Length
) == OemServerNameString->Length
)
)
{
*IsNameRegistered = TRUE;
break;
}
}
if (psti0 != NULL) {
LocalFree(psti0);
}
return(status);
} // CheckForServerName
NET_API_STATUS
pDeleteServerName(
IN RESOURCE_HANDLE ResourceHandle,
IN LPWSTR ServerName,
IN POEM_STRING OemServerNameString
)
{
NET_API_STATUS status;
BOOLEAN isNameRegistered;
DWORD count;
//
// Delete the name
//
status = NetServerComputerNameDel(NULL, ServerName);
if (status != NERR_Success) {
if (status != ERROR_BAD_NET_NAME) {
(NetNameLogEvent)(
ResourceHandle,
LOG_WARNING,
L"Failed to delete server name %1!ws!, status %2!u!.\n",
ServerName,
status
);
}
return(status);
}
//
// Check to make sure the name was really deleted. We'll wait up
// to 2 seconds.
//
for (count = 0; count < 8; count++) {
status = CheckForServerName(
ResourceHandle,
ServerName,
OemServerNameString,
&isNameRegistered
);
if (status != NERR_Success) {
(NetNameLogEvent)(
ResourceHandle,
LOG_WARNING,
L"Unable to verify that server name %1!ws! was deleted, status %2!u!.\n",
ServerName,
status
);
return(NERR_Success);
}
if (isNameRegistered == FALSE) {
(NetNameLogEvent)(
ResourceHandle,
LOG_INFORMATION,
L"Deleted server name %1!ws! from all transports.\n",
ServerName
);
return(NERR_Success);
}
Sleep(250);
}
(NetNameLogEvent)(
ResourceHandle,
LOG_WARNING,
L"Delete of server name %1!ws! succeeded, but name still has not gone away. "
L"Giving up.\n",
ServerName
);
return(ERROR_IO_PENDING);
} // pDeleteServerName
NET_API_STATUS
AddServerName(
IN RESOURCE_HANDLE ResourceHandle,
IN LPWSTR ServerName,
IN BOOL RemapPipeNames,
IN LPWSTR TransportName,
IN BOOLEAN CheckNameFirst,
IN PWCHAR MachinePwd
)
{
SERVER_TRANSPORT_INFO_2 sti2;
SERVER_TRANSPORT_INFO_3 sti3;
UCHAR netBiosName[ NETBIOS_NAME_LEN ];
OEM_STRING netBiosNameString;
UNICODE_STRING unicodeName;
NET_API_STATUS status;
NTSTATUS ntStatus;
//
// Convert the ServerName to an OEM string
//
RtlInitUnicodeString( &unicodeName, ServerName );
netBiosNameString.Buffer = (PCHAR)netBiosName;
netBiosNameString.MaximumLength = sizeof( netBiosName );
ntStatus = RtlUpcaseUnicodeStringToOemString(
&netBiosNameString,
&unicodeName,
FALSE
);
if (ntStatus != STATUS_SUCCESS) {
status = RtlNtStatusToDosError(ntStatus);
(NetNameLogEvent)(
ResourceHandle,
LOG_ERROR,
L"Unable to convert name %1!ws! to an OEM string, status %2!u!\n",
ServerName,
status
);
return(status);
}
if (CheckNameFirst) {
BOOLEAN isNameRegistered;
//
// Check to see if the name is already registered.
//
status = CheckForServerName(
ResourceHandle,
ServerName,
&netBiosNameString,
&isNameRegistered
);
if (status != NERR_Success) {
(NetNameLogEvent)(
ResourceHandle,
LOG_WARNING,
L"Unable to verify that server name %1!ws! does not already exist.\n",
ServerName
);
isNameRegistered = TRUE; // just to be safe
}
if (isNameRegistered) {
(NetNameLogEvent)(
ResourceHandle,
LOG_INFORMATION,
L"Deleting old registration for server name %1!ws!.\n",
ServerName
);
status = pDeleteServerName(
ResourceHandle,
ServerName,
&netBiosNameString
);
if (status != NERR_Success) {
if (status == ERROR_IO_PENDING) {
status = ERROR_GEN_FAILURE;
}
return(status);
}
}
}
//
// Register the name on the specified transport. If we have a password,
// then kerb was enabled. If no password, bring the name online without
// any credentials. This will cause RDR to fall back to NTLM for
// authentication.
//
if ( MachinePwd != NULL ) {
RtlZeroMemory( &sti3, sizeof(sti3) );
sti3.svti3_transportname = TransportName;
sti3.svti3_transportaddress = netBiosName;
sti3.svti3_transportaddresslength = strlen(netBiosName);
if (RemapPipeNames) {
sti3.svti3_flags = SVTI2_REMAP_PIPE_NAMES;
}
wcscpy( (PWCHAR)sti3.svti3_password, MachinePwd );
sti3.svti3_passwordlength = wcslen( MachinePwd ) * sizeof(WCHAR);
status = NetServerTransportAddEx( NULL, 3, (LPBYTE)&sti3 );
}
else {
RtlZeroMemory( &sti2, sizeof(sti2) );
sti2.svti2_transportname = TransportName;
sti2.svti2_transportaddress = netBiosName;
sti2.svti2_transportaddresslength = strlen(netBiosName);
if (RemapPipeNames) {
sti2.svti2_flags = SVTI2_REMAP_PIPE_NAMES;
}
status = NetServerTransportAddEx( NULL, 2, (LPBYTE)&sti2 );
}
if (status != NERR_Success) {
(NetNameLogEvent)(
ResourceHandle,
LOG_ERROR,
L"Unable to add server name %1!ws! to transport %2!ws!, status %3!u!.\n",
ServerName,
TransportName,
status
);
}
else {
(NetNameLogEvent)(
ResourceHandle,
LOG_INFORMATION,
L"Registered server name %1!ws! on transport %2!ws!.\n",
ServerName,
TransportName
);
}
return(status);
} // AddServerName
NET_API_STATUS
DeleteServerName(
IN RESOURCE_HANDLE ResourceHandle,
IN LPWSTR ServerName
)
{
NET_API_STATUS status;
NTSTATUS ntStatus;
UCHAR netBiosName[ NETBIOS_NAME_LEN ];
OEM_STRING netBiosNameString;
UNICODE_STRING unicodeName;
BOOLEAN isNameRegistered;
DWORD count;
//
// Convert the ServerName to an OEM string
//
RtlInitUnicodeString( &unicodeName, ServerName );
netBiosNameString.Buffer = (PCHAR)netBiosName;
netBiosNameString.MaximumLength = sizeof( netBiosName );
ntStatus = RtlUpcaseUnicodeStringToOemString(
&netBiosNameString,
&unicodeName,
FALSE
);
if (ntStatus != STATUS_SUCCESS) {
status = RtlNtStatusToDosError(ntStatus);
(NetNameLogEvent)(
ResourceHandle,
LOG_ERROR,
L"Unable to convert name %1!ws! to an OEM string, status %2!u!\n",
ServerName,
status
);
return(status);
}
//
// Delete the name
//
status = pDeleteServerName(
ResourceHandle,
ServerName,
&netBiosNameString
);
if (status == ERROR_IO_PENDING) {
status = NERR_Success;
}
return(status);
} // DeleteServerName
DWORD
AddWorkstationName(
IN LPWSTR WorkstationName,
IN LPWSTR TransportName,
IN RESOURCE_HANDLE ResourceHandle,
OUT HANDLE * WorkstationNameHandle
)
/*++
Routine Description:
This function adds an alternate workstation ( <0> ) name on a netbios
transport by opening a TDI address object. The name remains registered
as long as the address object is open.
Arguments:
WorkstationName - Alternate computer name to add.
TransportName - Transport to add the computer name on.
Return Value:
Status - The status of the operation.
--*/
{
DWORD status;
PFILE_FULL_EA_INFORMATION eaBuffer;
DWORD eaLength;
OBJECT_ATTRIBUTES objectAttributes;
IO_STATUS_BLOCK ioStatusBlock;
UNICODE_STRING transportString;
DWORD i;
PTA_NETBIOS_ADDRESS taAddress;
UNICODE_STRING unicodeName;
OEM_STRING oemName;
PUCHAR nameBuffer;
*WorkstationNameHandle = NULL;
//
// Allocate an extended attribute to hold the TDI address
//
eaLength = sizeof(FILE_FULL_EA_INFORMATION) - 1 +
TDI_TRANSPORT_ADDRESS_LENGTH + 1 +
sizeof(TA_NETBIOS_ADDRESS);
eaBuffer = LocalAlloc(LMEM_FIXED, eaLength);
if (eaBuffer == NULL) {
(NetNameLogEvent)(
ResourceHandle,
LOG_ERROR,
L"Unable to allocate memory for name registration.\n"
);
return(ERROR_NOT_ENOUGH_MEMORY);
}
eaBuffer->NextEntryOffset = 0;
eaBuffer->Flags = 0;
eaBuffer->EaNameLength = TDI_TRANSPORT_ADDRESS_LENGTH;
eaBuffer->EaValueLength = sizeof(TA_NETBIOS_ADDRESS);
CopyMemory(
eaBuffer->EaName,
TdiTransportAddress,
eaBuffer->EaNameLength+1
);
//
// Build the TDI NetBIOS Address structure
//
taAddress = (PTA_NETBIOS_ADDRESS) (eaBuffer->EaName +
TDI_TRANSPORT_ADDRESS_LENGTH + 1);
taAddress->TAAddressCount = 1;
taAddress->Address[0].AddressLength = sizeof(TDI_ADDRESS_NETBIOS);
taAddress->Address[0].AddressType = TDI_ADDRESS_TYPE_NETBIOS;
taAddress->Address[0].Address[0].NetbiosNameType =
TDI_ADDRESS_NETBIOS_TYPE_UNIQUE;
//
// Canonicalize the name by converting to an upper case OEM string,
// padding with spaces, and ending with a 0x0.
//
nameBuffer = &(taAddress->Address[0].Address[0].NetbiosName[0]);
oemName.Buffer = nameBuffer;
oemName.Length = 0;
oemName.MaximumLength = NETBIOS_NAME_LEN;
RtlInitUnicodeString(&unicodeName, WorkstationName);
status = RtlUpcaseUnicodeStringToOemString(
&oemName,
&unicodeName,
FALSE
);
if (status != STATUS_SUCCESS) {
(NetNameLogEvent)(
ResourceHandle,
LOG_ERROR,
L"Unable to convert name %1!ws! to an OEM string, status %2!u!\n",
WorkstationName,
status
);
LocalFree(eaBuffer);
return(RtlNtStatusToDosError(status));
}
for (i=oemName.Length; i < (NETBIOS_NAME_LEN - 1); i++) {
nameBuffer[i] = 0x20;
}
nameBuffer[NETBIOS_NAME_LEN-1] = 0;
//
// Open an address object handle.
//
RtlInitUnicodeString(&transportString, TransportName);
InitializeObjectAttributes(
&objectAttributes,
&transportString,
OBJ_CASE_INSENSITIVE,
(HANDLE) NULL,
(PSECURITY_DESCRIPTOR) NULL
);
status = NtCreateFile(
WorkstationNameHandle,
SYNCHRONIZE | FILE_READ_DATA | FILE_WRITE_DATA,
&objectAttributes,
&ioStatusBlock,
NULL,
FILE_ATTRIBUTE_NORMAL,
FILE_SHARE_READ | FILE_SHARE_WRITE,
FILE_OPEN_IF,
0,
eaBuffer,
eaLength
);
if (status == STATUS_SUCCESS) {
status = ioStatusBlock.Status;
}
LocalFree(eaBuffer);
status = RtlNtStatusToDosError(status);
if (status != ERROR_SUCCESS) {
(NetNameLogEvent)(
ResourceHandle,
LOG_ERROR,
L"Failed to register workstation name %1!ws! on transport %2!ws!, "
L"error %3!u!.\n",
WorkstationName,
TransportName,
status
);
}
else {
(NetNameLogEvent)(
ResourceHandle,
LOG_INFORMATION,
L"Registered workstation name %1!ws! on transport %2!ws!.\n",
WorkstationName,
TransportName
);
}
return(status);
} // AddWorkstationName
DNS_STATUS
AddDnsNames(
IN PCLUS_WORKER Worker,
IN LPWSTR AlternateComputerName,
IN HKEY ResourceKey,
IN RESOURCE_HANDLE ResourceHandle,
IN PDOMAIN_ADDRESS_MAPPING DomainMapList,
IN DWORD DomainMapCount,
IN BOOL FailOnAnyError,
OUT PULONG NumberOfDnsLists,
OUT PDNS_LISTS * DnsLists,
OUT PULONG NumberOfRegisteredNames
)
/*++
Routine Description:
For the given set of IP addresses and their corresponding DNS domains,
build DNS records that will register the network name in the domain(s)
associated with the IP address. Lists of A and PTR records are built which
are used by RegisterDnsRecords to publish the name/address associations at
the DNS server. If the names can't be registered now,
NetNameUpdateDnsServer will attempt to register them. This is the only
shot at building the lists; if this portion fails, then the resource is
failed.
This routine also checks for whether a DNS zone accepts dynamic
updates. DnsUpdateTest will tell us if the zone is dynamic or not, and if
dynamic and integrated with the DS as a secure zone, whether the caller
has sufficient permission to modify the entry.
For non-dynamic zones, Netbios ends up being the only mechanism by which a
name gets registered and therefore, DNS registration failures are not
fatal unless the RequireDNS property is set to true.
If the zone is dynamic but the caller lacks sufficient permission, we view
that as DNS having precedence over Netbios. In that case, the resource is
failed.
Arguments:
Worker - used to check if we should terminate early
AlternateComputerName - NetBIOS network name to be registered
ResourceKey - used to log events to the system event log
ResourceHandle - for logging to the cluster log
DomainMapList - list of IP address domain names pairs for registration
DomainMapCount - # of entries in DomainMapList
NumberOfDnsLists - pointer to location of final count of entries in DnsLists
DnsLists - array of lists that contain A and PTR listheads
NumberOfRegisteredNames - pointer to location of final count of names that
actually got registered
Return Value:
DNS_STATUS indicating whether it worked or not. If the DNS lists couldn't
be built, always return an error.
--*/
{
LPWSTR fqNameARec = NULL;
LPWSTR fqNamePTRRec = NULL;
DWORD fqNameLength;
DWORD listheadFreeEntries = 0;
DWORD listheadCount = 0;
PDNS_LISTS dnsLists = NULL;
DWORD mapIndex;
DWORD index;
DNS_STATUS dnsStatus;
DNS_STATUS ptrRecStatus;
PDNS_RECORD PTRRecord;
PDNS_RECORD ARecord;
LPWSTR PTRName = NULL;
BOOL ARecTimeout;
BOOL PTRRecTimeout;
//
// run through the list of domain map structs and register the names where
// appopriate
//
for ( mapIndex = 0; mapIndex < DomainMapCount; ++mapIndex ) {
if ( ClusWorkerCheckTerminate( Worker )) {
dnsStatus = ERROR_OPERATION_ABORTED;
goto error_exit;
}
ASSERT( DomainMapList[ mapIndex ].DomainName != NULL );
//
// create the fully qualified DNS name and make a copy for the PTR
// records. DnsRecordListFree operates in a way that makes it
// difficult to use the same buffer multiple times. It is easier to
// allocate separate buffers for everything and let DnsRecordListFree
// clean up.
//
fqNameLength = (wcslen( DomainMapList[ mapIndex ].DomainName ) +
wcslen( AlternateComputerName ) +
2 // one for "." and one for null
)
* sizeof( WCHAR );
fqNameARec = LocalAlloc( LMEM_FIXED, fqNameLength );
fqNamePTRRec = LocalAlloc( LMEM_FIXED, fqNameLength );
if ( fqNameARec == NULL || fqNamePTRRec == NULL ) {
dnsStatus = GetLastError();
(NetNameLogEvent)(ResourceHandle,
LOG_ERROR,
L"Can't allocate memory for DNS name for address %1!ws!, "
L"status %2!u!.\n",
DomainMapList[ mapIndex ].IpAddress,
dnsStatus);
goto error_exit;
}
wcscpy( fqNameARec, AlternateComputerName );
wcscat( fqNameARec, L"." );
wcscat( fqNameARec, DomainMapList[ mapIndex ].DomainName );
_wcslwr( fqNameARec );
wcscpy( fqNamePTRRec, fqNameARec );
//
// see if this domain is updatable.
//
ARecTimeout = FALSE;
dnsStatus = DnsUpdateTest(NULL,
fqNameARec,
0,
DomainMapList[ mapIndex ].DnsServerList);
#if DBG_DNSLIST
{
WCHAR buf[DNS_MAX_NAME_BUFFER_LENGTH + 64];
struct in_addr addr;
addr.s_addr = DomainMapList[ mapIndex ].DnsServerList->AddrArray[0];
_snwprintf(buf, (sizeof( buf ) / sizeof( WCHAR )) - 1,
L"AddDnsNames UPDATETEST: %ws on %.32ws (%hs) returned %u\n",
fqNameARec,
DomainMapList[ mapIndex ].ConnectoidName,
inet_ntoa( addr ),
dnsStatus);
OutputDebugStringW( buf );
}
#endif
if ( dnsStatus == DNS_ERROR_RCODE_NOT_IMPLEMENTED ) {
//
// zone does not accept dynamic updates.
//
(NetNameLogEvent)(ResourceHandle,
LOG_INFORMATION,
L"%1!ws! does not accept dynamic DNS registration updates over "
L"adapter '%2!ws!'.\n",
DomainMapList[ mapIndex ].DomainName,
DomainMapList[ mapIndex ].ConnectoidName);
//
// by freeing the name storage, we'll never to be able to register
// the name. On the other hand, if the zone was changed to be
// dynamic while the name was online, the admin would have to wait
// 20 minutes before we would retry the registration. I suspect
// that cycling the name would be preferred.
//
LocalFree( fqNameARec );
LocalFree( fqNamePTRRec );
fqNameARec = NULL;
fqNamePTRRec = NULL;
if ( FailOnAnyError ) {
goto error_exit;
} else {
continue;
}
} else if ( dnsStatus == DNS_ERROR_RCODE_REFUSED ) {
//
// secure zone and we don't have credentials to change the
// name. fail the resource.
//
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"%1!ws! is a secure zone and has refused the registration of "
L"%2!ws! over adapter '%3!ws!'.\n",
DomainMapList[ mapIndex ].DomainName,
fqNameARec,
DomainMapList[ mapIndex ].ConnectoidName);
LogDnsFailureToEventLog(ResourceKey,
fqNameARec,
AlternateComputerName,
dnsStatus,
DomainMapList[ mapIndex ].ConnectoidName);
if ( FailOnAnyError ) {
goto error_exit;
} else {
continue;
}
} else if ( dnsStatus == ERROR_TIMEOUT ) {
//
// couldn't contact a server so we're not sure if it allows
// updates or not. build the records anyway and we'll deal with it
// during the query period
//
if ( FailOnAnyError ) {
goto error_exit;
} else {
ARecTimeout = TRUE;
}
} else if ( dnsStatus == DNS_ERROR_RCODE_YXDOMAIN ) {
//
// the record we asked about in DnsUpdateTest is not there but it
// can be dynamically registered.
//
} else if ( dnsStatus != ERROR_SUCCESS ) {
//
// bad juju but only fail to bring the name online if DNS is
// required. If any one of the registrations is successful, then
// we consider that goodness.
//
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"Testing %1!ws! for dynamic updates failed over adapter "
L"'%3!ws!', status %2!u!.\n",
fqNameARec,
dnsStatus,
DomainMapList[ mapIndex ].ConnectoidName);
LogDnsFailureToEventLog(ResourceKey,
fqNameARec,
AlternateComputerName,
dnsStatus,
DomainMapList[ mapIndex ].ConnectoidName);
if ( FailOnAnyError ) {
goto error_exit;
} else {
continue;
}
}
//
// allocate memory to hold an array of DNS list data for the A and PTR
// records. Separate lists are maintained for the different record types.
//
if (listheadFreeEntries == 0) {
dnsStatus = GrowBlock((PCHAR *)&dnsLists,
listheadCount,
sizeof( *dnsLists ),
&listheadFreeEntries);
if ( dnsStatus != ERROR_SUCCESS) {
(NetNameLogEvent)(ResourceHandle,
LOG_ERROR,
L"Unable to allocate memory (1).\n");
goto error_exit;
}
}
//
// if the FQDN is already in use in another DNS record and the
// connectoid names for the two FQDNs we're adding are the same, then
// we have to add this new IP address entry to the existing DNS list.
//
for ( index = 0; index < listheadCount; ++index ) {
if ( _wcsicmp( dnsLists[index].A_RRSet.pFirstRR->pName,
fqNameARec
) == 0 )
{
#if DBG_DNSLIST
{
WCHAR buf[DNS_MAX_NAME_BUFFER_LENGTH + 50];
_snwprintf( buf, (sizeof( buf ) / sizeof( WCHAR )) - 1,
L"DNS NAME MATCH w/ index %d: %ws\n",
index, fqNameARec );
OutputDebugStringW(buf);
}
#endif
//
// FQDNs are equal; how about the connectoids?
//
if (_wcsicmp(DomainMapList[ mapIndex ].ConnectoidName,
dnsLists[index].ConnectoidName )
==
0 )
{
break;
}
}
}
#if DBG_DNSLIST
{
WCHAR buf[DNS_MAX_NAME_BUFFER_LENGTH + 80];
_snwprintf(buf, (sizeof( buf ) / sizeof( WCHAR )) - 1,
L"ADDING (%ws, %ws, %.32ws) to dnsList[%d], lhCount = %d, DomMapList index = %d\n",
fqNameARec,
DomainMapList[mapIndex].IpAddress,
DomainMapList[mapIndex].ConnectoidName,
index,
listheadCount,
mapIndex );
OutputDebugStringW(buf);
}
#endif
if ( index == listheadCount ) {
//
// it's not, so init a new pair of listheads and adjust the
// distinct listhead count
//
DNS_RRSET_INIT( dnsLists[ index ].A_RRSet );
DNS_RRSET_INIT( dnsLists[ index ].PTR_RRSet );
++listheadCount;
--listheadFreeEntries;
}
dnsLists[ index ].UpdateTestTimeout = ARecTimeout;
if ( ClusWorkerCheckTerminate( Worker )) {
dnsStatus = ERROR_OPERATION_ABORTED;
goto error_exit;
}
//
// build the PTR records. Per DNS dev, this should be considered a
// warning instead of a failure. We note the failures and bring the
// name online.
//
PTRName = BuildUnicodeReverseName( DomainMapList[ mapIndex ].IpAddress );
if ( PTRName != NULL ) {
PTRRecTimeout = FALSE;
ptrRecStatus = DnsUpdateTest(NULL,
PTRName,
0,
DomainMapList[ mapIndex ].DnsServerList);
#if DBG_DNSLIST
{
WCHAR buf[DNS_MAX_NAME_BUFFER_LENGTH + 64];
struct in_addr addr;
addr.s_addr = DomainMapList[ mapIndex ].DnsServerList->AddrArray[0];
_snwprintf(buf, (sizeof( buf ) / sizeof( WCHAR )) - 1,
L"AddDnsNames UPDATETEST: %ws on %.32ws (%hs) returned %u\n",
PTRName,
DomainMapList[ mapIndex ].ConnectoidName,
inet_ntoa( addr ),
ptrRecStatus);
OutputDebugStringW( buf );
}
#endif
if ( ptrRecStatus == DNS_ERROR_RCODE_NOT_IMPLEMENTED ) {
//
// zone does not accept dynamic updates.
//
(NetNameLogEvent)(ResourceHandle,
LOG_INFORMATION,
L"The zone for %1!ws! does not accept dynamic DNS "
L"registration updates over adapter '%2!ws!'.\n",
PTRName,
DomainMapList[ mapIndex ].ConnectoidName);
LocalFree( PTRName );
LocalFree( fqNamePTRRec );
PTRName = NULL;
fqNamePTRRec = NULL;
} else if ( ptrRecStatus == DNS_ERROR_RCODE_REFUSED ) {
//
// secure zone and we don't have credentials to change the
// name. fail the resource.
//
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"%1!ws! is a secure zone and has refused the registration of "
L"%2!ws! over adapter '%3!ws!'.\n",
DomainMapList[ mapIndex ].DomainName,
PTRName,
DomainMapList[ mapIndex ].ConnectoidName);
} else if ( ptrRecStatus == ERROR_TIMEOUT ) {
//
// couldn't contact a server so we're not sure if it allows
// updates or not. build the records anyway and we'll deal
// with it during the query period
//
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"The server for %1!ws! could not be contacted over adapter '%2!ws!' "
L"to determine whether it accepts DNS registration updates. "
L"Retrying at a later time.\n",
PTRName,
DomainMapList[ mapIndex ].ConnectoidName);
PTRRecTimeout = TRUE;
ptrRecStatus = ERROR_SUCCESS;
} else if ( ptrRecStatus == DNS_ERROR_RCODE_YXDOMAIN ) {
//
// the record we asked about in DnsUpdateTest is not there but
// it can be dynamically registered.
//
ptrRecStatus = ERROR_SUCCESS;
} else if ( ptrRecStatus != ERROR_SUCCESS ) {
//
// bad juju - log the error but don't fail the name since
// these are just lowly PTR records.
//
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"Testing %1!ws! for dynamic updates over adapter '%3!ws!' "
L"failed, status %2!u!.\n",
PTRName,
ptrRecStatus,
DomainMapList[ mapIndex ].ConnectoidName);
}
if ( ptrRecStatus == ERROR_SUCCESS ) {
//
// build the PTR rec
//
PTRRecord = DnsRecordBuild_W(&dnsLists[ index ].PTR_RRSet,
PTRName,
DNS_TYPE_PTR,
TRUE,
0,
1,
&fqNamePTRRec);
if (PTRRecord != NULL) {
//
// BUGBUG - DNS doesn't free the owner and data fields for
// us in DnsRecordListFree. Set these flags until we sort
// out what is happening
//
SET_FREE_OWNER( PTRRecord );
SET_FREE_DATA( PTRRecord );
//
// set the time to live so clients don't beat up the
// server
//
PTRRecord->dwTtl = 20 * 60; // 20 minutes
//
// "consume" the pointers to name strings. If we got this
// far, then these pointers have been captured in the DNS
// record and will be freed when the record is freed by
// DnsRecordListFree.
//
PTRName = NULL;
fqNamePTRRec = NULL;
}
else {
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"Error building PTR record for owner %1!ws!, addr %2!ws!, status %3!u!\n",
fqNameARec,
DomainMapList[ mapIndex ].IpAddress,
ptrRecStatus = GetLastError());
LocalFree( PTRName );
LocalFree( fqNamePTRRec );
PTRName = NULL;
fqNamePTRRec = NULL;
}
} // if ptrRecStatus == ERROR_SUCCESS
} // if PTRName != NULL
else {
ptrRecStatus = GetLastError();
(NetNameLogEvent)(ResourceHandle,
LOG_ERROR,
L"Error building PTR name for owner %1!ws!, addr %2!ws!, status %3!u!\n",
fqNameARec,
DomainMapList[ mapIndex ].IpAddress,
ptrRecStatus);
LocalFree( fqNamePTRRec );
fqNamePTRRec = NULL;
}
//
// build the A rec
//
ARecord = DnsRecordBuild_W(&dnsLists[ index ].A_RRSet,
fqNameARec,
DNS_TYPE_A,
TRUE,
0,
1,
&DomainMapList[ mapIndex ].IpAddress);
if ( ARecord == NULL ) {
(NetNameLogEvent)(ResourceHandle,
LOG_ERROR,
L"Error building A rec for owner %1!ws!, addr %2!ws!, status %3!u!\n",
fqNameARec,
DomainMapList[ mapIndex ].IpAddress,
dnsStatus = GetLastError());
goto error_exit;
}
//
// set the time to live so clients don't beat up the server
//
ARecord->dwTtl = 20 * 60; // 20 minutes
//
// BUGBUG - DNS doesn't free the owner and data fields for us in
// DnsRecordListFree. Set these flags until we sort out what is
// happening
//
SET_FREE_OWNER( ARecord );
SET_FREE_DATA( ARecord );
//
// "consume" this pointer as well
//
fqNameARec = NULL;
//
// capture the DNS server list and connectoid name for this entry
//
dnsLists[ index ].DnsServerList = DomainMapList[ mapIndex ].DnsServerList;
DomainMapList[ mapIndex ].DnsServerList = NULL;
dnsLists[ index ].ConnectoidName = ResUtilDupString( DomainMapList[ mapIndex ].ConnectoidName );
if ( dnsLists[ index ].ConnectoidName == NULL ) {
(NetNameLogEvent)(ResourceHandle,
LOG_ERROR,
L"Unable to allocate memory .\n");
goto error_exit;
}
} // end of for each entry in DomainMapCount
//
// update the DNS server with the records that were just created
//
*NumberOfRegisteredNames = 0;
for( index = 0; index < listheadCount; ++index ) {
if ( ClusWorkerCheckTerminate( Worker )) {
dnsStatus = ERROR_OPERATION_ABORTED;
goto error_exit;
}
//
// if we made it this far, we know that the server is dynamic or we
// timed out trying to figure that out. For the timeout case, we'll
// assume that the servers are dynamic and let NetNameUpdateDnsServer
// discover otherwise.
//
dnsLists[ index ].ForwardZoneIsDynamic = TRUE;
dnsLists[ index ].ReverseZoneIsDynamic = TRUE;
dnsStatus = RegisterDnsRecords(&dnsLists[ index ],
AlternateComputerName,
ResourceKey,
ResourceHandle,
TRUE, /* LogRegistration */
NumberOfRegisteredNames);
if ( dnsStatus != ERROR_SUCCESS && FailOnAnyError ) {
goto error_exit;
}
}
*NumberOfDnsLists = listheadCount;
*DnsLists = dnsLists;
return dnsStatus;
error_exit:
if ( dnsLists != NULL ) {
while ( listheadCount-- ) {
DnsRecordListFree(
dnsLists[listheadCount].PTR_RRSet.pFirstRR,
DnsFreeRecordListDeep );
DnsRecordListFree(
dnsLists[listheadCount].A_RRSet.pFirstRR,
DnsFreeRecordListDeep );
if ( dnsLists[listheadCount].DnsServerList != NULL ) {
LocalFree( dnsLists[listheadCount].DnsServerList );
}
if ( dnsLists[listheadCount].ConnectoidName != NULL ) {
LocalFree( dnsLists[listheadCount].ConnectoidName );
}
}
LocalFree( dnsLists );
}
if ( PTRName != NULL ) {
LocalFree( PTRName );
}
if ( fqNamePTRRec != NULL ) {
LocalFree( fqNamePTRRec );
}
if ( fqNameARec != NULL ) {
LocalFree( fqNameARec );
}
*NumberOfDnsLists = 0;
*NumberOfRegisteredNames = 0;
*DnsLists = NULL;
return dnsStatus;
} // AddDnsNames
VOID
LogDnsFailureToEventLog(
IN HKEY ResourceKey,
IN LPWSTR DnsName,
IN LPWSTR ResourceName,
IN DWORD Status,
IN LPWSTR ConnectoidName
)
/*++
Routine Description:
Log dns name failures to the event log
Arguments:
DnsName - FQ DNS name that failed to be registered
ResourceName - associated resource
Status - status returned by DNSAPI
Return Value:
NONE
--*/
{
LPWSTR msgBuff;
DWORD msgBytes;
msgBytes = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
Status,
0,
(LPWSTR)&msgBuff,
0,
NULL);
if ( msgBytes > 0 ) {
ClusResLogSystemEventByKeyData3(ResourceKey,
LOG_UNUSUAL,
RES_NETNAME_DNS_REGISTRATION_MISSING,
sizeof( Status ),
&Status,
DnsName,
msgBuff,
ConnectoidName);
LocalFree( msgBuff );
}
} // LogDnsFailureToEventLog
//
// Exported Routines
//
LPWSTR
BuildUnicodeReverseName(
IN LPWSTR IpAddress
)
/*++
Routine Description:
Given an Ip address, build a reverse DNS name for publishing as
a PTR record
Arguments:
IpAddress - unicode version of dotted decimal IP address
Return Value:
address of pointer to buffer with reverse name. Null if an error occured
--*/
{
ULONG ipAddress;
PCHAR ansiReverseName;
PCHAR pAnsi;
ULONG ansiNameLength;
PWCHAR unicodeReverseName;
PWCHAR pUni;
CHAR ansiIpAddress[ 64 ];
//
// convert to ansi, have DNS create the name, and then convert back to
// unicode
//
wcstombs( ansiIpAddress, IpAddress, sizeof( ansiIpAddress ));
ipAddress = inet_addr( ansiIpAddress );
ansiReverseName = DnsCreateReverseNameStringForIpAddress(
(IP4_ADDRESS)ipAddress
);
if ( ansiReverseName == NULL ) {
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return NULL;
}
ansiNameLength = strlen( ansiReverseName ) + 1;
unicodeReverseName = LocalAlloc(LMEM_FIXED,
ansiNameLength * sizeof(WCHAR));
if ( unicodeReverseName == NULL ) {
LocalFree( ansiReverseName );
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return NULL;
}
//
// convert to Unicode
//
mbstowcs( unicodeReverseName, ansiReverseName, ansiNameLength );
LocalFree( ansiReverseName );
return unicodeReverseName;
} // BuildUnicodeReverseName
DWORD
RegisterDnsRecords(
IN PDNS_LISTS DnsLists,
IN LPWSTR NetworkName,
IN HKEY ResourceKey,
IN RESOURCE_HANDLE ResourceHandle,
IN BOOL LogRegistration,
OUT PULONG NumberOfRegisteredNames
)
/*++
Routine Description:
Register the A and PTR records specified in DnsLists with the DNS server.
Arguments:
DnsLists - pointer to the list of structs holding the record sets to
be registered
NetworkName - host name portion of name being registered
ResourceKey - used to log events to the event viewer
ResourceHandle - used to log messages in the cluster log
LogRegistration - TRUE if the successful registration should be logged to the cluster log
NumberOfRegisteredNames - pointer that receives count of successful registrations
Return Value:
None
--*/
{
DNS_STATUS ARecStatus;
DNS_STATUS PTRRecStatus;
DNS_STATUS dnsStatus;
PDNS_RECORD dnsRecord;
PDNS_RECORD nextDnsRecord;
ULONG registeredCount = 0;
//
// check the status of DnsUpdateTest on this name. If we've previously
// timed out, then try again.
//
if ( DnsLists->UpdateTestTimeout ) {
DnsLists->UpdateTestTimeout = FALSE;
dnsStatus = DnsUpdateTest(NULL,
DnsLists->A_RRSet.pFirstRR->pName,
0,
DnsLists->DnsServerList);
#if DBG_DNSLIST
{
WCHAR buf[DNS_MAX_NAME_BUFFER_LENGTH + 64];
struct in_addr addr;
addr.s_addr = DnsLists->DnsServerList->AddrArray[0];
_snwprintf(buf, (sizeof( buf ) / sizeof( WCHAR )) - 1,
L"RegisterDnsRecords UPDATETEST: %ws on %.32ws (%hs) returned %u\n",
DnsLists->A_RRSet.pFirstRR->pName,
DnsLists->ConnectoidName,
inet_ntoa( addr ),
dnsStatus);
OutputDebugStringW( buf );
}
#endif
if ( dnsStatus == DNS_ERROR_RCODE_NOT_IMPLEMENTED ) {
//
// zone does not accept dynamic updates. Invalidate this entry
//
(NetNameLogEvent)(ResourceHandle,
LOG_INFORMATION,
L"%1!ws! does not accept dynamic DNS registration updates over "
L"adapter '%2!ws!'.\n",
DnsLists->A_RRSet.pFirstRR->pName,
DnsLists->ConnectoidName);
DnsLists->ForwardZoneIsDynamic = FALSE;
return dnsStatus;
} else if ( dnsStatus == DNS_ERROR_RCODE_REFUSED ) {
//
// secure zone and we don't have credentials to change the
// name. fail the resource.
//
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"The registration of %1!ws! in a secure zone was refused "
L"because the record was already registered but owned by a "
L"different user.\n",
DnsLists->A_RRSet.pFirstRR->pName);
if (!DnsLists->AErrorLogged ||
dnsStatus != DnsLists->LastARecQueryStatus ) {
LogDnsFailureToEventLog(ResourceKey,
DnsLists->A_RRSet.pFirstRR->pName,
NetworkName,
dnsStatus,
DnsLists->ConnectoidName);
DnsLists->AErrorLogged = TRUE;
}
DnsLists->LastARecQueryStatus = dnsStatus;
return dnsStatus;
} else if ( dnsStatus == ERROR_TIMEOUT ) {
//
// couldn't contact a server so we're not sure if it allows
// updates or not.
//
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"The server for %1!ws! could not be contacted over adapter "
L"'%2!ws!' to determine whether it accepts DNS registration "
L"updates. Retrying at a later time.\n",
DnsLists->A_RRSet.pFirstRR->pName,
DnsLists->ConnectoidName);
if (!DnsLists->AErrorLogged ) {
LogDnsFailureToEventLog(ResourceKey,
DnsLists->A_RRSet.pFirstRR->pName,
NetworkName,
dnsStatus,
DnsLists->ConnectoidName);
DnsLists->AErrorLogged = TRUE;
}
DnsLists->UpdateTestTimeout = TRUE;
return dnsStatus;
} else if ( dnsStatus == DNS_ERROR_RCODE_YXDOMAIN ) {
//
// the record we asked about in DnsUpdateTest is not there but it
// can be dynamically registered.
//
} else if ( dnsStatus != ERROR_SUCCESS ) {
//
// bad juju
//
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"Testing %1!ws! for dynamic updates failed over adapter "
L"'%3!ws!', status %2!u!.\n",
DnsLists->A_RRSet.pFirstRR->pName,
dnsStatus,
DnsLists->ConnectoidName);
if (!DnsLists->AErrorLogged ||
dnsStatus != DnsLists->LastARecQueryStatus ) {
LogDnsFailureToEventLog(ResourceKey,
DnsLists->A_RRSet.pFirstRR->pName,
NetworkName,
dnsStatus,
DnsLists->ConnectoidName);
DnsLists->AErrorLogged = TRUE;
}
DnsLists->LastARecQueryStatus = dnsStatus;
return dnsStatus;
}
//
// since we previously timed out but (at this point) are going to
// register the records, adjust the logging flag so we get this time
// recorded.
//
LogRegistration = TRUE;
} // end if the update test had previously timed out
#if DBG
(NetNameLogEvent)(ResourceHandle,
LOG_INFORMATION,
L"Registering %1!ws! over '%2!ws!'\n",
DnsLists->A_RRSet.pFirstRR->pName,
DnsLists->ConnectoidName);
#endif
//
// register the A Recs
//
ARecStatus = DnsReplaceRecordSetW(DnsLists->A_RRSet.pFirstRR,
DNS_UPDATE_SECURITY_USE_DEFAULT,
NULL,
DnsLists->DnsServerList,
NULL);
if ( ARecStatus == DNS_ERROR_RCODE_NO_ERROR ) {
++registeredCount;
DnsLists->AErrorLogged = FALSE;
if ( LogRegistration ) {
PDNS_RECORD dnsRecord;
dnsRecord = DnsLists->A_RRSet.pFirstRR;
while ( dnsRecord != NULL ) {
struct in_addr ipAddress;
ipAddress.s_addr = dnsRecord->Data.A.IpAddress;
(NetNameLogEvent)(ResourceHandle,
LOG_INFORMATION,
L"Registered DNS name %1!ws! with IP Address %2!hs! "
L"over adapter '%3!ws!'.\n",
dnsRecord->pName,
inet_ntoa( ipAddress ),
DnsLists->ConnectoidName);
dnsRecord = dnsRecord->pNext;
}
}
} else {
//
// it failed. log an error to the cluster log and change the worker
// thread polling period. If we haven't logged an event before or the
// error is different from the previous error, log it in the event log
//
if ( ARecStatus == ERROR_TIMEOUT ) {
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"The DNS server couldn't be contacted to update the registration "
L"for %1!ws!. Retrying at a later time.\n",
DnsLists->A_RRSet.pFirstRR->pName);
}
else {
(NetNameLogEvent)(ResourceHandle,
LOG_ERROR,
L"Failed to register DNS A records for owner %1!ws! over "
L"adapter '%3!ws!', status %2!u!\n",
DnsLists->A_RRSet.pFirstRR->pName,
ARecStatus,
DnsLists->ConnectoidName);
}
NetNameWorkerCheckPeriod = NETNAME_WORKER_PROBLEM_CHECK_PERIOD;
if (!DnsLists->AErrorLogged ||
ARecStatus != DnsLists->LastARecQueryStatus ) {
LogDnsFailureToEventLog(ResourceKey,
DnsLists->A_RRSet.pFirstRR->pName,
NetworkName,
ARecStatus,
DnsLists->ConnectoidName);
DnsLists->AErrorLogged = TRUE;
}
}
//
// Record the status of the registration in the list for this
// owner. NetnameLooksAlive will check this value to determine the health
// of this set of registrations. Use interlocked to co-ordinate with
// Is/LooksAlive.
//
InterlockedExchange( &DnsLists->LastARecQueryStatus, ARecStatus );
//
// don't bother with PTR recs if bad juju happened with the A recs. we'll
// try to register them the next time the DNS check thread runs
//
if ( ARecStatus == DNS_ERROR_RCODE_NO_ERROR ) {
//
// dynamic DNS requires that the pName must be the same for a given
// set of records in an RRSET. The pName for a set of PTR records will
// always be different. Maintaining a huge pile of RRSets, one per PTR
// record is ridiculous (or at least I thought so when I orginally
// wrote this; in hind sight, this was a bad decision - charlwi).
//
// AddDnsNames linked all these recs together. Now we have to register
// them one at time by remembering the link, breaking it, registering,
// restoring the link and moving on to the next record.
//
// The ErrorLogged logic is broken since we don't keep the status for
// each (separate) registration. It's an approximation at best.
//
// In addition, it is possible for the server to accept A records
// dynamically but disallow PTR records hence the check to see if we
// have records to register is up front.
//
// Finally, we use ModifyRecordsInSet instead of ReplaceRecordSet due
// to the organization of the PTR RRSET. When two names map to the
// same IP address, we have identical reverse addr strings in more
// than one DNS_LIST entry. If ReplaceRecordSet were used instead, it
// would delete all but one of the reverse address mappings. In hind
// sight, each DNS_LIST entry should have hosted either an A or PTR
// RRSet but not both.
//
dnsRecord = DnsLists->PTR_RRSet.pFirstRR;
while ( dnsRecord != NULL ) {
nextDnsRecord = dnsRecord->pNext;
dnsRecord->pNext = NULL;
PTRRecStatus = DnsModifyRecordsInSet_W(dnsRecord,
NULL,
DNS_UPDATE_SECURITY_USE_DEFAULT,
NULL,
DnsLists->DnsServerList,
NULL);
if ( PTRRecStatus == DNS_ERROR_RCODE_NO_ERROR ) {
DnsLists->PTRErrorLogged = FALSE;
if ( LogRegistration ) {
(NetNameLogEvent)(ResourceHandle,
LOG_INFORMATION,
L"Registered DNS PTR record %1!ws! for host %2!ws! "
L"over adapter '%3!ws!'\n",
dnsRecord->pName,
DnsLists->A_RRSet.pFirstRR->pName,
DnsLists->ConnectoidName);
}
} else {
(NetNameLogEvent)(ResourceHandle,
LOG_ERROR,
L"Failed to register DNS PTR record %1!ws! for host "
L"%2!ws! over adapter '%4!ws!', status %3!u!\n",
dnsRecord->pName,
DnsLists->A_RRSet.pFirstRR->pName,
PTRRecStatus,
DnsLists->ConnectoidName);
if (!DnsLists->PTRErrorLogged ||
PTRRecStatus != DnsLists->LastPTRRecQueryStatus )
{
DnsLists->PTRErrorLogged = TRUE;
}
}
InterlockedExchange(&DnsLists->LastPTRRecQueryStatus,
PTRRecStatus);
dnsRecord->pNext = nextDnsRecord;
dnsRecord = nextDnsRecord;
}
} // end if A rec registration was successful
else {
//
// since we don't end up trying the PTR records because of the A rec
// failure, we'll propagate the A rec error code in the PTR status.
//
InterlockedExchange(&DnsLists->LastPTRRecQueryStatus,
ARecStatus);
}
*NumberOfRegisteredNames = registeredCount;
return ARecStatus;
} // RegisterDnsRecords
VOID
DeleteAlternateComputerName(
IN LPWSTR AlternateComputerName,
IN HANDLE * NameHandleList,
IN DWORD NameHandleCount,
IN RESOURCE_HANDLE ResourceHandle
)
{
NET_API_STATUS status;
if ( NameHandleCount > 0 ) {
status = DeleteServerName(ResourceHandle, AlternateComputerName);
if (status != ERROR_SUCCESS) {
(NetNameLogEvent)(ResourceHandle,
LOG_WARNING,
L"Failed to delete server name %1!ws!, status %2!u!.\n",
AlternateComputerName,
status);
}
}
while ( NameHandleCount-- ) {
CloseHandle(NameHandleList[NameHandleCount]);
NameHandleList[NameHandleCount] = NULL;
(NetNameLogEvent)(ResourceHandle,
LOG_INFORMATION,
L"Deleted workstation name %1!ws! from transport %2!u!.\n",
AlternateComputerName,
NameHandleCount
);
}
} // DeleteAlternateComputerName
DWORD
AddAlternateComputerName(
IN PCLUS_WORKER Worker,
IN PNETNAME_RESOURCE Resource,
IN LPWSTR * TransportList,
IN DWORD TransportCount,
IN PDOMAIN_ADDRESS_MAPPING DomainMapList,
IN DWORD DomainMapCount
)
{
RESOURCE_HANDLE resourceHandle = Resource->ResourceHandle;
LPWSTR alternateComputerName = Resource->Params.NetworkName;
DWORD status = ERROR_SUCCESS;
DWORD setValueStatus;
DWORD i;
DWORD handleCount = 0;
LONG numberOfDnsNamesRegistered = 0;
PWCHAR machinePwd = NULL;
//
// clear all the status values so we don't show left over crud if we fail
// early on.
//
setValueStatus = ResUtilSetDwordValue(Resource->ParametersKey,
PARAM_NAME__STATUS_NETBIOS,
0,
NULL);
ASSERT( setValueStatus == ERROR_SUCCESS );
setValueStatus = ResUtilSetDwordValue(Resource->ParametersKey,
PARAM_NAME__STATUS_DNS,
0,
NULL);
ASSERT( setValueStatus == ERROR_SUCCESS );
setValueStatus = ResUtilSetDwordValue(Resource->ParametersKey,
PARAM_NAME__STATUS_KERBEROS,
0,
NULL);
ASSERT( setValueStatus == ERROR_SUCCESS );
//
// register DNS name(s) with server
//
status = AddDnsNames(Worker,
alternateComputerName,
Resource->ResKey,
resourceHandle,
DomainMapList,
DomainMapCount,
Resource->Params.RequireDNS, // FailOnAnyError
&Resource->NumberOfDnsLists,
&Resource->DnsLists,
&numberOfDnsNamesRegistered);
setValueStatus = ResUtilSetDwordValue(Resource->ParametersKey,
PARAM_NAME__STATUS_DNS,
status,
NULL);
ASSERT( setValueStatus == ERROR_SUCCESS );
if ( status == ERROR_OPERATION_ABORTED ||
( status != ERROR_SUCCESS && Resource->Params.RequireDNS ))
{
if ( status != ERROR_OPERATION_ABORTED && Resource->Params.RequireDNS ) {
LPWSTR msgBuff;
DWORD msgBytes;
msgBytes = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM,
NULL,
status,
0,
(LPWSTR)&msgBuff,
0,
NULL);
if ( msgBytes > 0 ) {
ClusResLogSystemEventByKey1(Resource->ResKey,
LOG_CRITICAL,
RES_NETNAME_DNS_REGISTRATION_FAILED,
msgBuff);
LocalFree( msgBuff );
} else {
ClusResLogSystemEventByKeyData(Resource->ResKey,
LOG_CRITICAL,
RES_NETNAME_DNS_REGISTRATION_FAILED_STATUS,
sizeof( status ),
&status);
}
}
return status;
}
#ifdef COMPOBJ_SUPPORT
if ( Resource->Params.RequireKerberos ) {
//
// create the backing computer account in the DS for kerb. authentication
//
status = NetNameAddComputerObject( Worker, Resource, &machinePwd );
Resource->KerberosStatus = status;
Resource->DoKerberosCheck = ( status == ERROR_SUCCESS );
setValueStatus = ResUtilSetDwordValue(Resource->ParametersKey,
PARAM_NAME__STATUS_KERBEROS,
status,
NULL);
ASSERT( setValueStatus == ERROR_SUCCESS );
if ( status != ERROR_SUCCESS ) {
return status;
}
} else {
//
// we need some cluster wide mechanism (a property?) to indicate that
// we need to delete the CO before online completes.
//
if ( Resource->ObjectGUID != NULL ) {
status = NetNameDeleteComputerObject( Resource );
//
// ISSUE: check for comm error and post warning that we're
// bringing the name online but that authentication may fail due
// to a residual CO we can't detect.
//
if ( status == ERROR_NO_SUCH_DOMAIN ) {
}
else if ( status != ERROR_SUCCESS && status != NERR_UserNotFound ) {
(NetNameLogEvent)(Resource->ResourceHandle,
LOG_ERROR,
L"Kerberos is disabled for this resource but a computer account "
L"exists in the directory service and it can't be deleted by the cluster "
L"service. The computer account must be deleted before the resource "
L"can be brought online. error %1!u!\n",
status);
return status;
}
}
Resource->DoKerberosCheck = FALSE;
}
#else
Resource->DoKerberosCheck = FALSE;
#endif
//
// bring NetBT names online
//
status = ERROR_SUCCESS;
for (i=0; i<TransportCount; i++) {
if ( ClusWorkerCheckTerminate( Worker )) {
status = ERROR_OPERATION_ABORTED;
goto cleanup;
}
status = AddServerName(resourceHandle,
alternateComputerName,
Resource->Params.NetworkRemap,
TransportList[i],
(BOOLEAN) ((i == 0) ? TRUE : FALSE), // CheckNameFirst
machinePwd);
if ( status == NERR_ServerNotStarted ) {
status = ERROR_SUCCESS;
}
if ( status != ERROR_SUCCESS ) {
goto cleanup;
}
if ( ClusWorkerCheckTerminate( Worker )) {
status = ERROR_OPERATION_ABORTED;
goto cleanup;
}
status = AddWorkstationName(
alternateComputerName,
TransportList[i],
resourceHandle,
&(Resource->NameHandleList[i])
);
if (status != ERROR_SUCCESS) {
goto cleanup;
}
handleCount++;
}
//
// if didn't register any NetBt or DNS names, then fail the netname.
//
if ( TransportCount == 0 && numberOfDnsNamesRegistered == 0 ) {
ClusResLogSystemEvent1(LOG_CRITICAL,
RES_NETNAME_NOT_REGISTERED,
alternateComputerName);
status = ERROR_RESOURCE_FAILED;
}
cleanup:
if ( machinePwd != NULL ) {
PWCHAR p = machinePwd;
while ( *p != UNICODE_NULL ) {
*p++ = UNICODE_NULL;
}
HeapFree( GetProcessHeap(), 0, machinePwd );
}
setValueStatus = ResUtilSetDwordValue(Resource->ParametersKey,
PARAM_NAME__STATUS_NETBIOS,
status,
NULL);
ASSERT( setValueStatus == ERROR_SUCCESS );
return status;
} // AddAlternateComputerName
Reference in a new issue Copy permalink