285 lines
5.9 KiB
C++
285 lines
5.9 KiB
C++
// Copyright (C) 1999 Microsoft Corporation
|
|
//
|
|
// Implementation of IConfigureYourServer::ValidateName
|
|
//
|
|
// 09 Jun 2000 sburns
|
|
|
|
|
|
|
|
#include "headers.hxx"
|
|
#include "resource.h"
|
|
#include "ConfigureYourServer.hpp"
|
|
#include "util.hpp"
|
|
|
|
|
|
|
|
// see admin\dcpromo\exe\headers.hxx
|
|
static const int DNS_DOMAIN_NAME_MAX_LIMIT_DUE_TO_POLICY = 64;
|
|
static const int DNS_DOMAIN_NAME_MAX_LIMIT_DUE_TO_POLICY_UTF8 = 155;
|
|
|
|
// possible result values from ICYS::ValidateName
|
|
|
|
static const int VALIDATE_INPUT_ILLEGAL = 0;
|
|
static const int VALIDATE_NAME_TOO_LONG = 1;
|
|
static const int VALIDATE_NAME_NUMERIC = 2;
|
|
static const int VALIDATE_BAD_CHARS_IN_NAME = 3;
|
|
static const int VALIDATE_NAME_MALFORMED = 4;
|
|
static const int VALIDATE_NAME_IN_USE = 5;
|
|
static const int VALIDATE_NAME_AVAILABLE = 6;
|
|
|
|
|
|
|
|
int
|
|
IsNameInUse(const String& domainName)
|
|
{
|
|
LOG_FUNCTION2(IsNameInUse, domainName);
|
|
|
|
int result = VALIDATE_NAME_AVAILABLE;
|
|
|
|
do
|
|
{
|
|
// see if we can find a domain controller for that name
|
|
|
|
DOMAIN_CONTROLLER_INFO* info = 0;
|
|
HRESULT hr =
|
|
MyDsGetDcName(
|
|
0,
|
|
domainName,
|
|
|
|
// force discovery to ensure that we don't pick up a cached
|
|
// entry for a domain that may no longer exist
|
|
|
|
DS_FORCE_REDISCOVERY | DS_DIRECTORY_SERVICE_PREFERRED,
|
|
info);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// we found a domain with this name, so the name is in use.
|
|
|
|
result = VALIDATE_NAME_IN_USE;
|
|
::NetApiBufferFree(info);
|
|
|
|
break;
|
|
}
|
|
|
|
// see if the name is in use for anything other than a domain (a
|
|
// machine name, for example)
|
|
|
|
hr = MyNetValidateName(domainName, NetSetupNonExistentDomain);
|
|
if (hr == Win32ToHresult(ERROR_DUP_NAME))
|
|
{
|
|
result = VALIDATE_NAME_IN_USE;
|
|
break;
|
|
}
|
|
}
|
|
while (0);
|
|
|
|
LOG(String::format(L"result = %1!d!", result));
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
ValidateDomainDnsName(
|
|
const String& domainDnsName,
|
|
int& result)
|
|
{
|
|
LOG_FUNCTION2(ValidateDomainDnsName, domainDnsName);
|
|
|
|
result = VALIDATE_INPUT_ILLEGAL;
|
|
HRESULT hr = S_OK;
|
|
|
|
do
|
|
{
|
|
String dnsName(domainDnsName);
|
|
dnsName.strip(String::BOTH);
|
|
|
|
if (dnsName.empty())
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
|
|
// Check syntax first.
|
|
|
|
switch (
|
|
Dns::ValidateDnsNameSyntax(
|
|
dnsName,
|
|
DNS_DOMAIN_NAME_MAX_LIMIT_DUE_TO_POLICY,
|
|
DNS_DOMAIN_NAME_MAX_LIMIT_DUE_TO_POLICY_UTF8) )
|
|
{
|
|
case Dns::NON_RFC:
|
|
case Dns::VALID:
|
|
{
|
|
result = IsNameInUse(dnsName);
|
|
break;
|
|
}
|
|
case Dns::TOO_LONG:
|
|
{
|
|
result = VALIDATE_NAME_TOO_LONG;
|
|
break;
|
|
}
|
|
case Dns::NUMERIC:
|
|
{
|
|
result = VALIDATE_NAME_NUMERIC;
|
|
break;
|
|
}
|
|
case Dns::BAD_CHARS:
|
|
{
|
|
result = VALIDATE_BAD_CHARS_IN_NAME;
|
|
break;
|
|
}
|
|
case Dns::INVALID:
|
|
{
|
|
// malformed
|
|
|
|
result = VALIDATE_NAME_MALFORMED;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
// we should have accounted for all the cases.
|
|
|
|
ASSERT(false);
|
|
|
|
// do nothing: same as illegal input.
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
while (0);
|
|
|
|
LOG(String::format(L"result = %1!d!", result));
|
|
LOG_HRESULT(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
ValidateDomainNetBiosName(
|
|
const String& domainNetBiosName,
|
|
int& result)
|
|
{
|
|
LOG_FUNCTION2(ValidateDomainNetBiosName, domainNetBiosName);
|
|
|
|
result = VALIDATE_INPUT_ILLEGAL;
|
|
HRESULT hr = S_OK;
|
|
|
|
do
|
|
{
|
|
String name(domainNetBiosName);
|
|
name.strip(String::BOTH);
|
|
|
|
if (name.empty())
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
|
|
// no '.'s allowed
|
|
|
|
if (name.find(L".") != String::npos)
|
|
{
|
|
result = VALIDATE_BAD_CHARS_IN_NAME;
|
|
break;
|
|
}
|
|
|
|
if (name.is_numeric())
|
|
{
|
|
result = VALIDATE_NAME_NUMERIC;
|
|
break;
|
|
}
|
|
|
|
HRESULT hr2 = S_OK;
|
|
String s = Dns::HostnameToNetbiosName(name, &hr2);
|
|
if (FAILED(hr2))
|
|
{
|
|
result = VALIDATE_BAD_CHARS_IN_NAME;
|
|
break;
|
|
}
|
|
|
|
if (s.length() < name.length())
|
|
{
|
|
// the name was truncated.
|
|
|
|
result = VALIDATE_NAME_TOO_LONG;
|
|
break;
|
|
}
|
|
|
|
result = IsNameInUse(s);
|
|
}
|
|
while (0);
|
|
|
|
LOG(String::format(L"result = %1!d!", result));
|
|
LOG_HRESULT(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
HRESULT __stdcall
|
|
ConfigureYourServer::ValidateName(
|
|
BSTR bstrType,
|
|
BSTR bstrName,
|
|
int* result)
|
|
{
|
|
LOG_FUNCTION2(
|
|
ConfigureYourServer::ValidateName,
|
|
bstrName ? bstrName : L"(null)");
|
|
ASSERT(bstrType);
|
|
ASSERT(bstrName);
|
|
ASSERT(result);
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
// this is a lengthy operation
|
|
|
|
HCURSOR hcurOld = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
|
|
do
|
|
{
|
|
if (!result)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
|
|
*result = VALIDATE_INPUT_ILLEGAL;
|
|
|
|
if (!bstrType || !bstrName)
|
|
{
|
|
hr = E_INVALIDARG;
|
|
break;
|
|
}
|
|
|
|
if (!StrCmpIW(bstrType, L"DNS"))
|
|
{
|
|
hr = ValidateDomainDnsName(bstrName, *result);
|
|
}
|
|
else if (!StrCmpIW(bstrType, L"NetBios"))
|
|
{
|
|
hr = ValidateDomainNetBiosName(bstrName, *result);
|
|
}
|
|
else
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
}
|
|
while (0);
|
|
|
|
SetCursor(hcurOld);
|
|
|
|
LOG(result ? String::format(L"result = %1!d!", *result) : L"");
|
|
LOG_HRESULT(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|