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.
1423 lines
35 KiB
1423 lines
35 KiB
/*++
|
|
|
|
Copyright (c) 1997 Microsoft Corporation
|
|
|
|
Abstract:
|
|
|
|
This module provides utilities useful for Directory Service interactions
|
|
|
|
Author:
|
|
|
|
Steve Wilson (NT) November 1997
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#define INC_OLE2
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include "client.h"
|
|
|
|
#include "pubprn.hxx"
|
|
#include "varconv.hxx"
|
|
#include "property.hxx"
|
|
#include "dsutil.hxx"
|
|
#include "winsprlp.h"
|
|
#include "dnsapi.h"
|
|
|
|
|
|
#define DN_SPECIAL_CHARS L",=\r\n+<>#;\"\\"
|
|
#define DN_SPECIAL_FILTER_CHARS L"\\*()"
|
|
|
|
|
|
PWSTR
|
|
GetUNCName(
|
|
HANDLE hPrinter
|
|
)
|
|
{
|
|
PPRINTER_INFO_2 pInfo2 = NULL;
|
|
DWORD cbNeeded;
|
|
PWSTR pszUNCName = NULL;
|
|
|
|
|
|
if (!GetPrinter(hPrinter, 2, (PBYTE) pInfo2, 0, &cbNeeded)) {
|
|
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
|
|
goto error;
|
|
}
|
|
|
|
if (!(pInfo2 = (PPRINTER_INFO_2) AllocSplMem(cbNeeded)))
|
|
goto error;
|
|
|
|
if (!GetPrinter(hPrinter, 2, (PBYTE) pInfo2, cbNeeded, &cbNeeded))
|
|
goto error;
|
|
|
|
|
|
// pPrinterName is already in correct UNC format since we
|
|
// opened handle with UNC name: just copy it
|
|
|
|
cbNeeded = wcslen(pInfo2->pPrinterName) + 1;
|
|
cbNeeded *= sizeof(WCHAR);
|
|
|
|
if (!(pszUNCName = (PWSTR) AllocSplMem(cbNeeded)))
|
|
goto error;
|
|
|
|
StringCbCopy(pszUNCName, cbNeeded, pInfo2->pPrinterName);
|
|
|
|
|
|
error:
|
|
|
|
if (pInfo2)
|
|
FreeSplMem(pInfo2);
|
|
|
|
return pszUNCName;
|
|
}
|
|
|
|
HRESULT
|
|
CreateEscapedDN(
|
|
PCWSTR pszIn,
|
|
PWSTR *ppEscapedString
|
|
)
|
|
{
|
|
PWSTR pszOut = NULL;
|
|
PWSTR psz;
|
|
DWORD cch;
|
|
HRESULT hRet = S_OK;
|
|
|
|
//
|
|
// Count special characters
|
|
//
|
|
for (cch = 0, psz = (PWSTR) pszIn ; psz = wcspbrk(psz, DN_SPECIAL_FILTER_CHARS) ; ++cch, ++psz)
|
|
{
|
|
//
|
|
// Empty body
|
|
//
|
|
}
|
|
|
|
//
|
|
// Add in length of input string
|
|
// 2 = (\5c) - '\'
|
|
//
|
|
cch = (wcslen(pszIn) + cch*2 + 1);
|
|
|
|
//
|
|
// Allocate output buffer and replace special chars with \HexEquivalent
|
|
// Ex: replace \ with \5c , ( with \28
|
|
//
|
|
if (pszOut = (PWSTR) AllocSplMem(cch * sizeof(WCHAR)))
|
|
{
|
|
size_t cchRemaining = cch;
|
|
PWSTR pszO;
|
|
|
|
for(psz = (PWSTR) pszIn, pszO = pszOut ; *psz ; ++psz)
|
|
{
|
|
if (wcschr(DN_SPECIAL_FILTER_CHARS, *psz))
|
|
{
|
|
if (FAILED(hRet = StringCchPrintfEx(pszO,
|
|
cchRemaining,
|
|
&pszO,
|
|
&cchRemaining,
|
|
STRSAFE_NULL_ON_FAILURE,
|
|
L"\\%x",
|
|
*psz)))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*pszO++ = *psz;
|
|
|
|
cchRemaining--;
|
|
}
|
|
}
|
|
|
|
*pszO = L'\0';
|
|
}
|
|
else
|
|
{
|
|
hRet = E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (SUCCEEDED(hRet))
|
|
{
|
|
*ppEscapedString = pszOut;
|
|
}
|
|
else
|
|
{
|
|
*ppEscapedString = NULL;
|
|
|
|
FreeSplMem(pszOut);
|
|
}
|
|
|
|
return hRet;
|
|
}
|
|
|
|
DWORD
|
|
PrintQueueExists(
|
|
HWND hwnd,
|
|
HANDLE hPrinter,
|
|
PWSTR pszUNCName,
|
|
DWORD dwAction,
|
|
PWSTR pszTargetDN,
|
|
PWSTR *ppszObjectDN
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD dwRet = ERROR_SUCCESS;
|
|
WCHAR szSearchPattern[MAX_UNC_PRINTER_NAME + 50];
|
|
WCHAR szFullUNCName[MAX_UNC_PRINTER_NAME];
|
|
PWSTR pNames[2];
|
|
WCHAR szName[MAX_PATH + 1];
|
|
PWSTR pszSearchRoot = NULL;
|
|
PWSTR pszUNCNameSearch = NULL;
|
|
IDirectorySearch *pDSSearch = NULL;
|
|
DS_NAME_RESULT *pDNR = NULL;
|
|
DOMAIN_CONTROLLER_INFO *pDCI = NULL;
|
|
HANDLE hDS = NULL;
|
|
ADS_SEARCH_HANDLE hSearchHandle = NULL;
|
|
ADS_SEARCH_COLUMN ADsPath;
|
|
ADS_SEARCH_COLUMN UNCName;
|
|
PWSTR pszAttributes[] = {L"ADsPath", L"UNCName"};
|
|
DWORD nSize;
|
|
BOOL bRet = FALSE;
|
|
BOOL bDeleteDuplicate = FALSE;
|
|
PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pDsRole = NULL;
|
|
|
|
dwRet = DsRoleGetPrimaryDomainInformation(NULL, DsRolePrimaryDomainInfoBasic, (PBYTE *) &pDsRole);
|
|
|
|
if (dwRet != ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
StringCchPrintf(szName, COUNTOF(szName), L"%ws\\", pDsRole->DomainNameFlat);
|
|
|
|
pNames[0] = szName;
|
|
pNames[1] = NULL;
|
|
|
|
dwRet = Bind2DS(&hDS, &pDCI, DS_GC_SERVER_REQUIRED);
|
|
if (dwRet != ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
if (!(DsCrackNames(
|
|
hDS,
|
|
DS_NAME_NO_FLAGS,
|
|
DS_UNKNOWN_NAME,
|
|
DS_FQDN_1779_NAME,
|
|
1,
|
|
&pNames[0],
|
|
&pDNR) == ERROR_SUCCESS)) {
|
|
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
if (pDNR->rItems[0].status != DS_NAME_NO_ERROR) {
|
|
if (pDNR->rItems[0].status == DS_NAME_ERROR_RESOLVING)
|
|
dwRet = ERROR_PATH_NOT_FOUND;
|
|
else
|
|
dwRet = pDNR->rItems[0].status;
|
|
|
|
goto error;
|
|
}
|
|
|
|
// GC:// + pDCName + 1
|
|
nSize = (wcslen(pDNR->rItems[0].pName) + 6)*sizeof(WCHAR);
|
|
|
|
if (!(pszSearchRoot = (PWSTR) AllocSplMem(nSize))) {
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
StringCbPrintf(pszSearchRoot, nSize, L"GC://%ws", pDNR->rItems[0].pName);
|
|
|
|
|
|
hr = ADsGetObject( pszSearchRoot,
|
|
IID_IDirectorySearch,
|
|
(void **)&pDSSearch);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if (FAILED(hr = CreateEscapedDN(pszUNCName, &pszUNCNameSearch))) {
|
|
dwRet = SCODE_CODE(hr);
|
|
goto error;
|
|
}
|
|
|
|
StringCchPrintf(szSearchPattern, COUNTOF(szSearchPattern), L"(&(objectClass=printQueue)(uNCName=%ws))", pszUNCNameSearch);
|
|
|
|
hr = pDSSearch->ExecuteSearch(
|
|
szSearchPattern,
|
|
pszAttributes,
|
|
sizeof(pszAttributes)/sizeof *pszAttributes,
|
|
&hSearchHandle);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
hr = pDSSearch->GetNextRow(hSearchHandle);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
while (hr != S_ADS_NOMORE_ROWS) {
|
|
|
|
hr = pDSSearch->GetColumn(
|
|
hSearchHandle,
|
|
L"ADsPath",
|
|
&ADsPath
|
|
);
|
|
|
|
if (hr == S_OK) {
|
|
|
|
hr = pDSSearch->GetColumn(
|
|
hSearchHandle,
|
|
L"UNCName",
|
|
&UNCName
|
|
);
|
|
|
|
if (hr == S_OK) {
|
|
|
|
switch (dwAction) {
|
|
case PUBLISHPRINTER_QUERY:
|
|
{
|
|
WCHAR szDuplicateFormat[MAX_PATH];
|
|
WCHAR szBoxTitle[MAX_PATH];
|
|
|
|
if (LoadString(hInst, IDS_DUPLICATE_PRINTQUEUE, szDuplicateFormat, COUNTOF(szDuplicateFormat)) &&
|
|
LoadString(hInst, IDS_DUPLICATE_PRINTQUEUE_TITLE, szBoxTitle, COUNTOF(szDuplicateFormat)))
|
|
{
|
|
PWSTR pszCanonicalSource = NULL;
|
|
PWSTR pszCanonicalTarget = NULL;
|
|
PWSTR pszDuplicate = NULL;
|
|
|
|
FQDN2Canonical(ADsPath.pADsValues->DNString, &pszCanonicalSource);
|
|
FQDN2Canonical(pszTargetDN, &pszCanonicalTarget);
|
|
|
|
PWSTR pszOne = ADsPath.pADsValues->DNString;
|
|
PWSTR pszTwo = pszTargetDN;
|
|
|
|
if (pszCanonicalSource && pszCanonicalTarget)
|
|
{
|
|
pszOne = pszCanonicalSource;
|
|
pszTwo = pszCanonicalTarget;
|
|
}
|
|
|
|
nSize = 1 + wcslen(szDuplicateFormat) + wcslen(pszOne) + wcslen(pszTwo);
|
|
|
|
if (pszDuplicate = (PWSTR) AllocSplMem(nSize * sizeof(WCHAR)))
|
|
{
|
|
StringCchPrintf(pszDuplicate, nSize, szDuplicateFormat, pszOne, pszTwo);
|
|
|
|
dwRet = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
dwRet = GetLastError();
|
|
}
|
|
|
|
FreeSplStr(pszCanonicalSource);
|
|
FreeSplStr(pszCanonicalTarget);
|
|
|
|
if (dwRet == ERROR_SUCCESS)
|
|
{
|
|
dwRet = MessageBox(hwnd, pszDuplicate, szBoxTitle, MB_YESNO);
|
|
|
|
bDeleteDuplicate = (dwRet == IDYES);
|
|
dwRet = (dwRet == IDYES) ? ERROR_SUCCESS : ERROR_CANCELLED;
|
|
}
|
|
|
|
FreeSplMem(pszDuplicate);
|
|
}
|
|
else
|
|
{
|
|
dwRet = GetLastError();
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case PUBLISHPRINTER_DELETE_DUPLICATES:
|
|
{
|
|
bDeleteDuplicate = TRUE;
|
|
break;
|
|
}
|
|
|
|
case PUBLISHPRINTER_FAIL_ON_DUPLICATE:
|
|
{
|
|
bDeleteDuplicate = FALSE;
|
|
|
|
if (ppszObjectDN) {
|
|
if (!(*ppszObjectDN = AllocGlobalStr(ADsPath.pADsValues->DNString))) {
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
dwRet = ERROR_FILE_EXISTS;
|
|
break;
|
|
}
|
|
|
|
case PUBLISHPRINTER_IGNORE_DUPLICATES:
|
|
{
|
|
bDeleteDuplicate = FALSE;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
bDeleteDuplicate = FALSE;
|
|
dwRet = ERROR_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bDeleteDuplicate) {
|
|
hr = DeleteDSObject(ADsPath.pADsValues->DNString);
|
|
|
|
if ( hr == ERROR_DS_NO_SUCH_OBJECT ) {
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
|
|
pDSSearch->FreeColumn(&UNCName);
|
|
}
|
|
|
|
pDSSearch->FreeColumn(&ADsPath);
|
|
}
|
|
|
|
if (dwRet != ERROR_SUCCESS || hr != S_OK)
|
|
goto error;
|
|
|
|
hr = pDSSearch->GetNextRow(hSearchHandle);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
|
|
hr = S_OK;
|
|
|
|
|
|
error:
|
|
|
|
if (hr != S_OK)
|
|
dwRet = ERROR_DS_UNAVAILABLE;
|
|
|
|
if (pDsRole)
|
|
DsRoleFreeMemory((PVOID) pDsRole);
|
|
|
|
if (pDNR)
|
|
DsFreeNameResult(pDNR);
|
|
|
|
if (hDS)
|
|
DsUnBind(&hDS);
|
|
|
|
if (pDCI)
|
|
NetApiBufferFree(pDCI);
|
|
|
|
if (hSearchHandle)
|
|
pDSSearch->CloseSearchHandle(hSearchHandle);
|
|
|
|
if (pszUNCNameSearch)
|
|
FreeSplMem(pszUNCNameSearch);
|
|
|
|
if (pDSSearch)
|
|
pDSSearch->Release();
|
|
|
|
if (pszSearchRoot)
|
|
FreeSplMem(pszSearchRoot);
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
MovePrintQueue(
|
|
PCWSTR pszObjectGUID,
|
|
PCWSTR pszNewContainer, // Container path
|
|
PCWSTR pszNewCN // Object CN
|
|
)
|
|
{
|
|
PWSTR pszCurrentContainer = NULL;
|
|
PWSTR pszCurrentCN = NULL;
|
|
HRESULT hr;
|
|
IADsContainer *pADsContainer = NULL;
|
|
IDispatch *pNewObject = NULL;
|
|
|
|
|
|
// Get PublishPoint from GUID
|
|
hr = GetPublishPointFromGUID(pszObjectGUID, &pszCurrentContainer, &pszCurrentCN);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if (pszCurrentContainer) {
|
|
// Get container
|
|
hr = ADsGetObject( pszCurrentContainer, IID_IADsContainer, (void **) &pADsContainer);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
// Move PrintQueue
|
|
if (wcscmp(pszCurrentContainer, pszNewContainer)) {
|
|
hr = pADsContainer->MoveHere((PWSTR) pszNewContainer, (PWSTR) pszNewCN, &pNewObject);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
}
|
|
|
|
error:
|
|
|
|
if (pszCurrentContainer)
|
|
FreeSplMem(pszCurrentContainer);
|
|
|
|
if (pszCurrentCN)
|
|
FreeSplMem(pszCurrentCN);
|
|
|
|
if (pADsContainer)
|
|
pADsContainer->Release();
|
|
|
|
if (pNewObject)
|
|
pNewObject->Release();
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
GetPublishPointFromGUID(
|
|
PCWSTR pszObjectGUID,
|
|
PWSTR *ppszDN,
|
|
PWSTR *ppszCN
|
|
)
|
|
{
|
|
DWORD dwRet, nBytes, nChars;
|
|
PWSTR pNames[2];
|
|
DS_NAME_RESULT *pDNR = NULL;
|
|
DOMAIN_CONTROLLER_INFO *pDCI = NULL;
|
|
HANDLE hDS = NULL;
|
|
PWSTR psz;
|
|
HRESULT hr = S_OK;
|
|
|
|
|
|
dwRet = Bind2DS(&hDS, &pDCI, DS_DIRECTORY_SERVICE_PREFERRED);
|
|
if (dwRet != ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
|
|
// Get Publish Point
|
|
|
|
if (ppszDN) {
|
|
|
|
pNames[0] = (PWSTR) pszObjectGUID;
|
|
pNames[1] = NULL;
|
|
|
|
if (!(DsCrackNames(
|
|
hDS,
|
|
DS_NAME_NO_FLAGS,
|
|
DS_UNKNOWN_NAME,
|
|
DS_FQDN_1779_NAME,
|
|
1,
|
|
&pNames[0],
|
|
&pDNR) == ERROR_SUCCESS)) {
|
|
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
if (pDNR->rItems[0].status != DS_NAME_NO_ERROR) {
|
|
if (pDNR->rItems[0].status == DS_NAME_ERROR_RESOLVING)
|
|
dwRet = ERROR_PATH_NOT_FOUND;
|
|
else
|
|
dwRet = pDNR->rItems[0].status;
|
|
|
|
goto error;
|
|
}
|
|
|
|
|
|
// Separate DN into CN & PublishPoint
|
|
// pDNR has form: CN=CommonName,DN...
|
|
|
|
hr = FQDN2CNDN(pDCI->DomainControllerName + 2, pDNR->rItems[0].pName, ppszCN, ppszDN);
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
|
|
error:
|
|
|
|
if (pDNR)
|
|
DsFreeNameResult(pDNR);
|
|
|
|
if (hDS)
|
|
DsUnBind(&hDS);
|
|
|
|
if (pDCI)
|
|
NetApiBufferFree(pDCI);
|
|
|
|
if (dwRet != ERROR_SUCCESS) {
|
|
hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, dwRet);
|
|
}
|
|
|
|
if (FAILED(hr)) {
|
|
FreeSplMem(*ppszCN);
|
|
FreeSplMem(*ppszDN);
|
|
*ppszCN = *ppszDN = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
DWORD
|
|
Bind2DS(
|
|
HANDLE *phDS,
|
|
DOMAIN_CONTROLLER_INFO **ppDCI,
|
|
ULONG Flags
|
|
)
|
|
{
|
|
DWORD dwRet;
|
|
|
|
dwRet = DsGetDcName(NULL, NULL, NULL, NULL, Flags, ppDCI);
|
|
if (dwRet == ERROR_SUCCESS) {
|
|
|
|
if ((*ppDCI)->Flags & DS_DS_FLAG) {
|
|
|
|
dwRet = DsBind (NULL, (*ppDCI)->DomainName, phDS);
|
|
if (dwRet != ERROR_SUCCESS) {
|
|
|
|
NetApiBufferFree(*ppDCI);
|
|
*ppDCI = NULL;
|
|
|
|
if (!(Flags & DS_FORCE_REDISCOVERY)) {
|
|
dwRet = Bind2DS(phDS, ppDCI, DS_FORCE_REDISCOVERY | Flags);
|
|
}
|
|
}
|
|
} else {
|
|
NetApiBufferFree(*ppDCI);
|
|
*ppDCI = NULL;
|
|
dwRet = ERROR_CANT_ACCESS_DOMAIN_INFO;
|
|
}
|
|
}
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
|
|
|
|
HRESULT
|
|
FQDN2CNDN(
|
|
PWSTR pszDCName,
|
|
PWSTR pszFQDN,
|
|
PWSTR *ppszCN,
|
|
PWSTR *ppszDN
|
|
)
|
|
{
|
|
IADs *pADs = NULL;
|
|
PWSTR pszCN = NULL;
|
|
PWSTR pszDN = NULL;
|
|
PWSTR pszLDAPPath = NULL;
|
|
HRESULT hr;
|
|
|
|
// Get LDAP path to object
|
|
hr = BuildLDAPPath(pszDCName, pszFQDN, &pszLDAPPath);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// Get DN
|
|
hr = ADsGetObject(pszLDAPPath, IID_IADs, (void **) &pADs);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
hr = pADs->get_Parent(&pszDN);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if (!(*ppszDN = AllocSplStr(pszDN))) {
|
|
hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
|
|
// Get CN
|
|
hr = pADs->get_Name(&pszCN);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
if (!(*ppszCN = AllocSplStr(pszCN))) {
|
|
hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
|
|
error:
|
|
|
|
if (pADs)
|
|
pADs->Release();
|
|
|
|
if (pszCN)
|
|
SysFreeString(pszCN);
|
|
|
|
if (pszDN)
|
|
SysFreeString(pszDN);
|
|
|
|
FreeSplStr(pszLDAPPath);
|
|
|
|
if (FAILED(hr)) {
|
|
FreeSplStr(*ppszCN);
|
|
FreeSplStr(*ppszDN);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
BuildLDAPPath(
|
|
PWSTR pszDC,
|
|
PWSTR pszFQDN,
|
|
PWSTR *ppszLDAPPath
|
|
)
|
|
{
|
|
DWORD nBytes;
|
|
HRESULT hr;
|
|
|
|
// LDAP:// + pDCName + / + pName + 1
|
|
nBytes = (wcslen(pszDC) + wcslen(pszFQDN) + 9)*sizeof(WCHAR);
|
|
|
|
if (!(*ppszLDAPPath = (PWSTR) AllocSplMem(nBytes))) {
|
|
hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
hr = StringCbPrintf(*ppszLDAPPath, nBytes, L"LDAP://%ws/%ws", pszDC,pszFQDN);
|
|
|
|
error:
|
|
|
|
return hr;
|
|
}
|
|
|
|
DWORD
|
|
UNC2Printer(
|
|
PCWSTR pszUNC,
|
|
PWSTR *ppszPrinter
|
|
)
|
|
{
|
|
PWSTR psz;
|
|
|
|
if (!pszUNC || pszUNC[0] != L'\\' || pszUNC[1] != L'\\')
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
if(!(psz = wcsrchr(pszUNC + 2, L'\\')))
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
if (!(*ppszPrinter = (PWSTR) AllocSplStr(psz + 1)))
|
|
return GetLastError();
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
DWORD
|
|
UNC2Server(
|
|
PCWSTR pszUNC,
|
|
PWSTR *ppszServer
|
|
)
|
|
{
|
|
PWSTR psz;
|
|
DWORD cb;
|
|
DWORD nChars;
|
|
|
|
if (!pszUNC || pszUNC[0] != L'\\' || pszUNC[1] != L'\\')
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
if(!(psz = wcschr(pszUNC + 2, L'\\')))
|
|
return ERROR_INVALID_PARAMETER;
|
|
|
|
cb = (DWORD) ((ULONG_PTR) psz - (ULONG_PTR) pszUNC + sizeof *psz);
|
|
|
|
if (!(*ppszServer = (PWSTR) AllocSplMem(cb)))
|
|
return GetLastError();
|
|
|
|
|
|
nChars = (DWORD) (psz - pszUNC);
|
|
wcsncpy(*ppszServer, pszUNC, nChars);
|
|
(*ppszServer)[nChars] = L'\0';
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
// Utility routine to report if a printer is color or monochrome
|
|
|
|
BOOL
|
|
ThisIsAColorPrinter(
|
|
LPCTSTR lpstrName
|
|
)
|
|
{
|
|
HANDLE hPrinter = NULL;
|
|
LPTSTR lpstrMe = const_cast <LPTSTR> (lpstrName);
|
|
BOOL bReturn = FALSE;
|
|
LPDEVMODE lpdm = NULL;
|
|
long lcbNeeded;
|
|
|
|
if (!OpenPrinter(lpstrMe, &hPrinter, NULL)) {
|
|
goto error;
|
|
}
|
|
|
|
|
|
// First, use DocumentProperties to find the correct DEVMODE size- we
|
|
// must use the DEVMODE to force color on, in case the user's defaults
|
|
// have turned it off...
|
|
|
|
lcbNeeded = DocumentProperties(NULL, hPrinter, lpstrMe, NULL, NULL, 0);
|
|
if (lcbNeeded <= 0) {
|
|
goto error;
|
|
}
|
|
|
|
lpdm = (LPDEVMODE) AllocSplMem(lcbNeeded);
|
|
if (lpdm) {
|
|
|
|
lpdm->dmSize = sizeof(DEVMODE);
|
|
lpdm->dmFields = DM_COLOR;
|
|
lpdm->dmColor = DMCOLOR_COLOR;
|
|
|
|
if (IDOK == DocumentProperties(NULL, hPrinter, lpstrMe, lpdm, lpdm,
|
|
DM_IN_BUFFER | DM_OUT_BUFFER)) {
|
|
|
|
// Finally, we can create the DC!
|
|
HDC hdcThis = CreateDC(NULL, lpstrName, NULL, lpdm);
|
|
|
|
if (hdcThis) {
|
|
bReturn = 2 < (unsigned) GetDeviceCaps(hdcThis, NUMCOLORS);
|
|
DeleteDC(hdcThis);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
error:
|
|
|
|
FreeSplMem(lpdm);
|
|
|
|
if (hPrinter)
|
|
ClosePrinter(hPrinter);
|
|
|
|
return bReturn;
|
|
}
|
|
|
|
|
|
|
|
|
|
HRESULT
|
|
DeleteDSObject(
|
|
PWSTR pszADsPath
|
|
)
|
|
{
|
|
BSTR bstrCommonName = NULL;
|
|
PWSTR pszParent = NULL;
|
|
PWSTR pszCN = NULL;
|
|
PWSTR pszLDAPPath = NULL;
|
|
IADs *pADs = NULL;
|
|
IADsContainer *pContainer = NULL;
|
|
DWORD cch;
|
|
HRESULT hr;
|
|
DWORD nSize;
|
|
|
|
if(pszADsPath && !_wcsnicmp(pszADsPath , L"GC://" , 5)){
|
|
|
|
//
|
|
// Build LDAP://..... path from GC://.... path
|
|
// 3 comes from len(LDAP) - len(GC) + len(string_terminator)
|
|
//
|
|
nSize = (wcslen(pszADsPath) + 3)* sizeof(WCHAR);
|
|
if (!(pszLDAPPath = (PWSTR) AllocSplMem(nSize))) {
|
|
hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, GetLastError());
|
|
goto error;
|
|
}
|
|
|
|
if (FAILED(hr = StringCbPrintf(pszLDAPPath, nSize, L"LDAP%ws", pszADsPath + 2)))
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
}
|
|
|
|
// Get PrintQueue object
|
|
hr = ADsGetObject(pszLDAPPath, IID_IADs, (void **) &pADs);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
// Get the CommonName & don't forget the "CN="
|
|
hr = get_BSTR_Property(pADs, L"cn", &bstrCommonName);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
cch = (SysStringLen(bstrCommonName) + 4);
|
|
|
|
if (!(pszCN = (PWSTR) AllocSplMem(cch * sizeof(WCHAR)))) {
|
|
hr = dw2hr(GetLastError());
|
|
BAIL_ON_FAILURE(hr);
|
|
}
|
|
|
|
StrNCatBuff(pszCN, cch, L"CN=", bstrCommonName, NULL);
|
|
|
|
|
|
// Get the Parent ADsPath
|
|
hr = pADs->get_Parent(&pszParent);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
|
|
// Get the Parent object
|
|
hr = ADsGetObject( pszParent,
|
|
IID_IADsContainer,
|
|
(void **) &pContainer);
|
|
BAIL_ON_FAILURE(hr);
|
|
|
|
// Delete the printqueue
|
|
hr = pContainer->Delete(SPLDS_PRINTER_CLASS, pszCN);
|
|
|
|
|
|
error:
|
|
|
|
if (pADs)
|
|
pADs->Release();
|
|
|
|
if (pContainer)
|
|
pContainer->Release();
|
|
|
|
if (bstrCommonName)
|
|
SysFreeString(bstrCommonName);
|
|
|
|
if (pszParent)
|
|
SysFreeString(pszParent);
|
|
|
|
if (pszCN)
|
|
FreeSplMem(pszCN);
|
|
|
|
if(pszLDAPPath)
|
|
FreeSplMem(pszLDAPPath);
|
|
|
|
return hr;
|
|
}
|
|
|
|
DWORD
|
|
GetCommonName(
|
|
HANDLE hPrinter,
|
|
PWSTR *ppszCommonName
|
|
)
|
|
{
|
|
DWORD nBytes;
|
|
PWSTR psz;
|
|
PPRINTER_INFO_2 pInfo2 = NULL;
|
|
DWORD cbNeeded;
|
|
DWORD dwRet;
|
|
PWSTR pszServerName, pszPrinterName;
|
|
|
|
|
|
// Get Server & Share names
|
|
if (!GetPrinter(hPrinter, 2, (PBYTE) pInfo2, 0, &cbNeeded)) {
|
|
|
|
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
if (!(pInfo2 = (PPRINTER_INFO_2) AllocSplMem(cbNeeded))) {
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
if (!GetPrinter(hPrinter, 2, (PBYTE) pInfo2, cbNeeded, &cbNeeded)) {
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
pszServerName = pInfo2->pServerName;
|
|
if (!pszServerName) {
|
|
DBGMSG(DBG_ERROR,("GetPrinter returned NULL ServerName"));
|
|
dwRet = ERROR_INVALID_DATA;
|
|
goto error;
|
|
}
|
|
|
|
pszPrinterName = pInfo2->pShareName ? pInfo2->pShareName : pInfo2->pPrinterName;
|
|
|
|
} else {
|
|
// We should never get here. If we do, something is wrong
|
|
// with the server and we have no meaningful error to report,
|
|
// so just claim invalid data.
|
|
DBGMSG(DBG_ERROR,("INVALID GetPrinter return"));
|
|
dwRet = ERROR_INVALID_DATA;
|
|
goto error;
|
|
}
|
|
|
|
// "CN=Server-Printer"
|
|
nBytes = (wcslen(pszPrinterName) + wcslen(pszServerName) + 5)*sizeof(WCHAR);
|
|
if (!(*ppszCommonName = psz = (PWSTR) AllocSplMem(nBytes))) {
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
// CN=
|
|
StringCbCopy(psz, nBytes, L"CN=");
|
|
|
|
// Server
|
|
for(psz += 3, pszServerName += 2 ; *pszServerName ; ++psz, ++pszServerName) {
|
|
*psz = wcschr(DN_SPECIAL_CHARS, *pszServerName) ? TEXT('_') : *pszServerName;
|
|
}
|
|
*psz = L'-';
|
|
|
|
// Printer
|
|
for(++psz; *pszPrinterName ; ++psz, ++pszPrinterName) {
|
|
*psz = wcschr(DN_SPECIAL_CHARS, *pszPrinterName) ? TEXT('_') : *pszPrinterName;
|
|
}
|
|
|
|
// NULL
|
|
*psz = *pszPrinterName;
|
|
|
|
// DS only allows 64 characters in CN attribute, so shorten this if needed
|
|
if (wcslen(pszPrinterName) > 62)
|
|
pszPrinterName[63] = NULL;
|
|
|
|
|
|
error:
|
|
|
|
FreeSplMem(pInfo2);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
PWSTR
|
|
AllocGlobalStr(
|
|
PWSTR pszIn
|
|
)
|
|
{
|
|
DWORD cb;
|
|
PWSTR pszOut = NULL;
|
|
|
|
if (!pszIn)
|
|
return NULL;
|
|
|
|
cb = (wcslen(pszIn) + 1)*sizeof *pszIn;
|
|
|
|
if (pszOut = (PWSTR) GlobalAlloc(GMEM_FIXED, cb))
|
|
{
|
|
StringCbCopy(pszOut, cb, pszIn);
|
|
}
|
|
|
|
return pszOut;
|
|
}
|
|
|
|
VOID
|
|
FreeGlobalStr(
|
|
PWSTR pszIn
|
|
)
|
|
{
|
|
if (pszIn)
|
|
GlobalFree(pszIn);
|
|
}
|
|
|
|
|
|
|
|
|
|
DWORD
|
|
GetADsPathFromGUID(
|
|
PCWSTR pszObjectGUID,
|
|
PWSTR *ppszDN
|
|
)
|
|
{
|
|
DWORD dwRet, nBytes, nChars;
|
|
PWSTR pNames[2];
|
|
DS_NAME_RESULT *pDNR = NULL;
|
|
DOMAIN_CONTROLLER_INFO *pDCI = NULL;
|
|
HANDLE hDS = NULL;
|
|
PWSTR psz;
|
|
|
|
|
|
dwRet = Bind2DS(&hDS, &pDCI, DS_DIRECTORY_SERVICE_PREFERRED);
|
|
if (dwRet != ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
|
|
// Get Publish Point
|
|
|
|
if (ppszDN) {
|
|
|
|
pNames[0] = (PWSTR) pszObjectGUID;
|
|
pNames[1] = NULL;
|
|
|
|
if (!(DsCrackNames(
|
|
hDS,
|
|
DS_NAME_NO_FLAGS,
|
|
DS_UNKNOWN_NAME,
|
|
DS_FQDN_1779_NAME,
|
|
1,
|
|
&pNames[0],
|
|
&pDNR) == ERROR_SUCCESS)) {
|
|
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
if (pDNR->rItems[0].status != DS_NAME_NO_ERROR) {
|
|
if (pDNR->rItems[0].status == DS_NAME_ERROR_RESOLVING)
|
|
dwRet = ERROR_PATH_NOT_FOUND;
|
|
else
|
|
dwRet = pDNR->rItems[0].status;
|
|
|
|
goto error;
|
|
}
|
|
|
|
// LDAP:// + pDCName + / + pName + 1
|
|
nBytes = (wcslen(pDCI->DomainControllerName + 2) +
|
|
wcslen(pDNR->rItems[0].pName) + 9)*sizeof(WCHAR);
|
|
|
|
if (!(*ppszDN = (PWSTR) AllocSplMem(nBytes))) {
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
StringCbPrintf(*ppszDN, nBytes, L"LDAP://%ws/%ws", pDCI->DomainControllerName + 2,pDNR->rItems[0].pName);
|
|
}
|
|
|
|
|
|
error:
|
|
|
|
if (pDNR)
|
|
DsFreeNameResult(pDNR);
|
|
|
|
if (hDS)
|
|
DsUnBind(&hDS);
|
|
|
|
if (pDCI)
|
|
NetApiBufferFree(pDCI);
|
|
|
|
if (dwRet != ERROR_SUCCESS) {
|
|
FreeSplMem(*ppszDN);
|
|
*ppszDN = NULL;
|
|
}
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
|
|
|
|
PWSTR
|
|
GetDNWithServer(
|
|
PCWSTR pszDNIn
|
|
)
|
|
{
|
|
DOMAIN_CONTROLLER_INFO *pDCI = NULL;
|
|
DWORD nBytes;
|
|
PWSTR pszDNOut = NULL;
|
|
DWORD dwRet;
|
|
|
|
// Convert pszDNIn into a DN with the DC name, if it isn't already there
|
|
|
|
// Check for existing DC name or badly formed name
|
|
if (wcsncmp(pszDNIn, L"LDAP://", 7) || wcschr(pszDNIn + 7, L'/'))
|
|
goto error;
|
|
|
|
// Get DC name
|
|
dwRet = DsGetDcName(NULL, NULL, NULL, NULL, 0, &pDCI);
|
|
if (dwRet != ERROR_SUCCESS) {
|
|
goto error;
|
|
}
|
|
|
|
|
|
// Build name
|
|
// LDAP:// + pDCName + / + pName + 1
|
|
nBytes = (wcslen(pDCI->DomainControllerName + 2) +
|
|
wcslen(pszDNIn + 7) + 9)*sizeof(WCHAR);
|
|
|
|
if (!(pszDNOut = (PWSTR) AllocSplMem(nBytes)))
|
|
goto error;
|
|
|
|
StringCbPrintf(pszDNOut, nBytes, L"LDAP://%ws/%ws", pDCI->DomainControllerName + 2, pszDNIn + 7);
|
|
|
|
|
|
error:
|
|
|
|
if (pDCI)
|
|
NetApiBufferFree(pDCI);
|
|
|
|
return pszDNOut;
|
|
}
|
|
|
|
|
|
DWORD
|
|
hr2dw(
|
|
HRESULT hr
|
|
)
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
return ERROR_SUCCESS;
|
|
|
|
if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
|
|
return HRESULT_CODE(hr);
|
|
|
|
if (hr != HRESULT_FROM_WIN32(ERROR_OBJECT_ALREADY_EXISTS))
|
|
return ERROR_DS_UNAVAILABLE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
PWSTR
|
|
DelimString2MultiSz(
|
|
PWSTR pszIn,
|
|
WCHAR wcDelim
|
|
)
|
|
{
|
|
DWORD cb;
|
|
PWSTR pszOut = NULL;
|
|
|
|
// pszIn looks like L"xxx,xxxx,xxx,xxx"
|
|
// the output looks like L"xxx0xxxx0xxx0xxx00"
|
|
// Replace all wcDelim characters with NULLs & add a NULL
|
|
|
|
if (!pszIn || !*pszIn)
|
|
return NULL;
|
|
|
|
cb = (wcslen(pszIn) + 2)*sizeof *pszIn;
|
|
|
|
pszOut = (PWSTR) AllocSplMem(cb);
|
|
|
|
if (pszOut) {
|
|
|
|
DWORD i;
|
|
|
|
for (i = 0 ; pszIn[i] ; ++i) {
|
|
pszOut[i] = (pszIn[i] == wcDelim) ? L'\0' : pszIn[i];
|
|
}
|
|
pszOut[i] = pszOut[i + 1] = L'\0';
|
|
}
|
|
|
|
return pszOut;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
GetPrinterInfo2(
|
|
HANDLE hPrinter,
|
|
PPRINTER_INFO_2 *ppInfo2
|
|
)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DWORD cbNeeded;
|
|
|
|
// Get PRINTER_INFO_2 properties
|
|
if (!GetPrinter(hPrinter, 2, (PBYTE) *ppInfo2, 0, &cbNeeded)) {
|
|
|
|
if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
|
|
hr = dw2hr(GetLastError());
|
|
goto error;
|
|
}
|
|
|
|
if (!(*ppInfo2 = (PPRINTER_INFO_2) AllocSplMem(cbNeeded))) {
|
|
hr = dw2hr(GetLastError());
|
|
goto error;
|
|
}
|
|
|
|
if (!GetPrinter(hPrinter, 2, (PBYTE) *ppInfo2, cbNeeded, &cbNeeded)) {
|
|
hr = dw2hr(GetLastError());
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
error:
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
FQDN2Canonical(
|
|
PWSTR pszIn,
|
|
PWSTR *ppszOut
|
|
)
|
|
{
|
|
DWORD dwRet = ERROR_SUCCESS;
|
|
DS_NAME_RESULT *pDNR = NULL;
|
|
PWSTR pNames[2];
|
|
|
|
*ppszOut = NULL;
|
|
|
|
if (wcslen(pszIn) < 8) {
|
|
dwRet = ERROR_INVALID_PARAMETER;
|
|
goto error;
|
|
}
|
|
|
|
pNames[0] = pszIn + 7; // Input string is LDAP://CN=... Strip off the LDAP:// portion
|
|
pNames[1] = NULL;
|
|
|
|
if (!(DsCrackNames(
|
|
INVALID_HANDLE_VALUE,
|
|
DS_NAME_FLAG_SYNTACTICAL_ONLY,
|
|
DS_FQDN_1779_NAME,
|
|
DS_CANONICAL_NAME,
|
|
1,
|
|
&pNames[0],
|
|
&pDNR) == ERROR_SUCCESS)) {
|
|
|
|
dwRet = GetLastError();
|
|
goto error;
|
|
}
|
|
|
|
if (pDNR->rItems[0].status != DS_NAME_NO_ERROR) {
|
|
if (pDNR->rItems[0].status == DS_NAME_ERROR_RESOLVING)
|
|
dwRet = ERROR_PATH_NOT_FOUND;
|
|
else
|
|
dwRet = pDNR->rItems[0].status;
|
|
|
|
goto error;
|
|
}
|
|
|
|
if (!(*ppszOut = AllocSplStr(pDNR->rItems[0].pName)))
|
|
{
|
|
dwRet = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
error:
|
|
|
|
if (pDNR)
|
|
DsFreeNameResult(pDNR);
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
|
|
BOOL
|
|
DevCapMultiSz(
|
|
PWSTR pszUNCName,
|
|
IADs *pPrintQueue,
|
|
WORD fwCapability,
|
|
DWORD dwElementBytes,
|
|
PWSTR pszAttributeName
|
|
)
|
|
{
|
|
DWORD dwResult, cbBytes;
|
|
PWSTR pszDevCapBuffer = NULL;
|
|
PWSTR pszRegData = NULL;
|
|
HRESULT hr;
|
|
|
|
|
|
_try {
|
|
dwResult = DeviceCapabilities( pszUNCName,
|
|
NULL,
|
|
fwCapability,
|
|
NULL,
|
|
NULL);
|
|
|
|
if (dwResult != GDI_ERROR) {
|
|
pszDevCapBuffer = (PWSTR) AllocSplMem(dwResult*dwElementBytes*sizeof(WCHAR));
|
|
|
|
if (pszDevCapBuffer) {
|
|
dwResult = DeviceCapabilities( pszUNCName,
|
|
NULL,
|
|
fwCapability,
|
|
pszDevCapBuffer,
|
|
NULL);
|
|
|
|
if (dwResult != GDI_ERROR) {
|
|
if (!(pszRegData = DevCapStrings2MultiSz(pszDevCapBuffer, dwResult, dwElementBytes, &cbBytes))) {
|
|
dwResult = GDI_ERROR;
|
|
}
|
|
}
|
|
} else {
|
|
dwResult = GDI_ERROR;
|
|
}
|
|
}
|
|
} _except(1) {
|
|
SetLastError(GetExceptionCode());
|
|
dwResult = GDI_ERROR;
|
|
}
|
|
|
|
if (dwResult != GDI_ERROR) {
|
|
|
|
hr = PublishDsData( pPrintQueue,
|
|
pszAttributeName,
|
|
REG_MULTI_SZ,
|
|
(PBYTE) pszRegData);
|
|
|
|
if (FAILED(hr)) {
|
|
SetLastError(HRESULT_CODE(hr));
|
|
dwResult = GDI_ERROR;
|
|
}
|
|
}
|
|
|
|
FreeSplStr(pszDevCapBuffer);
|
|
FreeSplStr(pszRegData);
|
|
|
|
return dwResult != GDI_ERROR;
|
|
}
|
|
|
|
|
|
PWSTR
|
|
DevCapStrings2MultiSz(
|
|
PWSTR pszDevCapString,
|
|
DWORD nDevCapStrings,
|
|
DWORD dwDevCapStringLength,
|
|
DWORD *pcbBytes
|
|
)
|
|
{
|
|
DWORD i, cbBytes, cbSize;
|
|
PWSTR pszMultiSz = NULL;
|
|
PWSTR pStr;
|
|
|
|
|
|
if (!pszDevCapString || !pcbBytes)
|
|
return NULL;
|
|
|
|
*pcbBytes = 0;
|
|
|
|
//
|
|
// Devcap buffers may not be NULL terminated
|
|
//
|
|
cbBytes = (nDevCapStrings*(dwDevCapStringLength + 1) + 1)*sizeof(WCHAR);
|
|
|
|
|
|
//
|
|
// Allocate and copy
|
|
//
|
|
if (pszMultiSz = (PWSTR) AllocSplMem(cbBytes)) {
|
|
for(i = 0, pStr = pszMultiSz, cbBytes = 0 ; i < nDevCapStrings ; ++i, pStr += cbSize, cbBytes +=cbSize ) {
|
|
wcsncpy(pStr, pszDevCapString + i*dwDevCapStringLength, dwDevCapStringLength);
|
|
cbSize = *pStr ? wcslen(pStr) + 1 : 0;
|
|
}
|
|
*pStr = L'\0';
|
|
*pcbBytes = (cbBytes + 1) * sizeof(WCHAR);
|
|
}
|
|
|
|
return pszMultiSz;
|
|
}
|
|
|
|
|
|
HRESULT
|
|
MachineIsInMyForest(
|
|
PWSTR pszMachineName
|
|
)
|
|
{
|
|
DWORD dwRet;
|
|
HRESULT hr;
|
|
PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pMachineRole = NULL;
|
|
PDSROLE_PRIMARY_DOMAIN_INFO_BASIC pMyRole = NULL;
|
|
|
|
dwRet = DsRoleGetPrimaryDomainInformation( pszMachineName,
|
|
DsRolePrimaryDomainInfoBasic,
|
|
(PBYTE *) &pMachineRole);
|
|
if (dwRet != ERROR_SUCCESS) {
|
|
hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, dwRet);
|
|
goto error;
|
|
}
|
|
|
|
dwRet = DsRoleGetPrimaryDomainInformation( NULL,
|
|
DsRolePrimaryDomainInfoBasic,
|
|
(PBYTE *) &pMyRole);
|
|
if (dwRet != ERROR_SUCCESS) {
|
|
hr = MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, dwRet);
|
|
goto error;
|
|
}
|
|
|
|
dwRet = DnsNameCompare_W(pMachineRole->DomainForestName, pMyRole->DomainForestName);
|
|
hr = MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_WIN32, dwRet);
|
|
|
|
|
|
error:
|
|
|
|
if (pMachineRole)
|
|
DsRoleFreeMemory((PVOID) pMachineRole);
|
|
|
|
if (pMyRole)
|
|
DsRoleFreeMemory((PVOID) pMyRole);
|
|
|
|
return hr;
|
|
}
|