/*++
Copyright (c) 1996 Microsoft Corporation
© 1998 Seagate Software, Inc. All rights reserved.
Module Name:
HsmConn.cpp
Abstract:
This is the main implementation of the HsmConn dll. This dll provides
functions for accessing Directory Services and for connecting to
our services.
Author:
Rohde Wakefield [rohde] 21-Oct-1996
Revision History:
--*/
#include "stdafx.h"
#include <dsgetdc.h>
#include <lmcons.h>
#include <lmapibuf.h>
// Required by SECURITY.H
#define SECURITY_WIN32
#include <security.h>
// HsmConnPoint objects are used only here
#include "hsmservr.h"
//
// Tracing information
//
#define WSB_TRACE_IS WSB_TRACE_BIT_HSMCONN
//
// _Module instantiation for ATL
//
CComModule _Module;
/////////////////////////////////////////////////////////////////////////////
#define REG_PATH OLESTR("SOFTWARE\\Microsoft\\RemoteStorage")
#define REG_USE_DS OLESTR("UseDirectoryServices")
// Local data
static OLECHAR CNEqual[] = L"CN=";
static OLECHAR ComputersNodeName[] = L"Computers";
static OLECHAR DCsNodeName[] = L"Domain Controllers";
static OLECHAR ContainerType[] = L"Container";
static OLECHAR DisplaySpecifierName[] = L"displaySpecifier";
static OLECHAR GuidAttrName[] = L"remoteStorageGUID";
static OLECHAR RsDisplaySpecifierName[] = L"remoteStorageServicePoint-Display";
static OLECHAR RsNodeName[] = L"RemoteStorage";
static OLECHAR RsNodeType[] = L"remoteStorageServicePoint";
static OLECHAR ServiceBindAttrName[] = L"serviceBindingInformation";
static OLECHAR ServiceBindValue[] = L"Rsadmin.msc /ds ";
static ADS_ATTR_INFO aaInfo[2]; // For use in IDirectoryObject
static ADSVALUE adsValue[2]; // For use in IDirectoryObject
static OLECHAR DomainName[MAX_COMPUTERNAME_LENGTH];
static BOOL DSIsWritable = FALSE; // Default to "NO"
static BOOL UseDirectoryServices = FALSE; // Default to "NO"
#if defined(HSMCONN_DEBUG)
// We use this and OutputDebugString when we can't use our normal
// tracing.
OLECHAR dbg_string[200];
#endif
extern "C"
{
// Local functions
static void GetDSState(void);
static HRESULT HsmConnectToServer(HSMCONN_TYPE type,
const OLECHAR * Server, REFIID riid, void ** ppv);
static const OLECHAR *HsmConnTypeAsString(HSMCONN_TYPE type);
static GUID HsmConnTypeToGuid(IN HSMCONN_TYPE type);
static HRESULT HsmGetComputerNode(const OLECHAR * compName,
IADsContainer **pContainer);
static HRESULT HsmGetDsChild(IADsContainer * pContainer, const OLECHAR * Name,
REFIID riid, void **ppv);
BOOL WINAPI
DllMain (
IN HINSTANCE hInst,
IN ULONG ulReason,
LPVOID /*lpReserved*/
)
/*++
Routine Description:
This routine is called whenever a new process and thread attaches
to this DLL. Its purpose is to initialize the _Module object,
necessary for ATL.
Arguments:
hInst - HINSTANCE of this dll.
ulReason - Context of the attaching/detaching
Return Value:
non-zero - success
0 - prevent action
--*/
{
switch ( ulReason ) {
case DLL_PROCESS_ATTACH:
//
// Initialize the ATL module, and prevent
// any of the additional threads from sending
// notifications through
//
_Module.Init ( 0, hInst );
DisableThreadLibraryCalls ( hInst );
GetDSState();
break;
case DLL_PROCESS_DETACH:
//
// Tell ATL module to terminate
//
_Module.Term ( );
break;
}
return ( TRUE );
}
static HRESULT
HsmConnectToServer (
IN HSMCONN_TYPE type,
IN const OLECHAR * Server,
IN REFIID riid,
OUT void ** ppv
)
/*++
Routine Description:
Given a generic server (connected via HsmConnPoint class)
connect to it and return back the requested interface 'riid'.
Arguments:
type - Type of server to connect
Server - Name of machine on which server is running.
riid - The interface type to return.
ppv - Returned interface pointer of the Server.
Return Value:
S_OK - Connection made, Success.
E_NOINTERFACE - Requested interface not supported by Server.
E_POINTER - ppv is not a valid pointer.
E_OUTOFMEMORY - Low memory condition prevented connection.
HSM_E_NOT_READY - Engine is not running or not initialized yet
FSA_E_NOT_READY - Fsa is not running or not initialized yet
--*/
{
WsbTraceIn ( L"HsmConnectToServer",
L"type = '%ls' , Server = '%ls', riid = '%ls', ppv = 0x%p",
HsmConnTypeAsString ( type ), Server, WsbStringCopy ( WsbGuidAsString ( riid ) ), ppv );
HRESULT hr = S_OK;
try {
//
// Ensure parameters are valid
//
WsbAssert ( 0 != Server, E_POINTER );
WsbAssert ( 0 != ppv, E_POINTER );
//
// We will specify the provided HSM as the machine to contact,
// so Construct a COSERVERINFO with Server.
//
REFCLSID rclsid = CLSID_HsmConnPoint;
COSERVERINFO csi;
memset ( &csi, 0, sizeof ( csi ) );
csi.pwszName = (OLECHAR *) Server; // must cast to remove constness
//
// Build a MULTI_QI structure to obtain desired interface (necessary for
// CoCreateInstanceEx). In our case, we need only one interface.
//
MULTI_QI mqi[1];
memset ( mqi, 0, sizeof ( mqi ) );
mqi[0].pIID = &IID_IHsmConnPoint;
//
// The HsmConnPoint object ic created in the scope of the main HSM service and
// provides access for HSM server objects
//
WsbAffirmHr( CoCreateInstanceEx ( rclsid, 0, CLSCTX_SERVER, &csi, 1, mqi ) );
//
// Put returned interfaces in smart pointers so we
// don't leak a reference in case off throw
//
CComPtr<IHsmConnPoint> pConn;
if( SUCCEEDED( mqi[0].hr ) ) {
pConn = (IHsmConnPoint *)(mqi[0].pItf);
(mqi[0].pItf)->Release( );
hr = mqi[0].hr;
#if 0 // This is now done at the COM process-wide security layer
/* NOTE: In case that a per-connection security will be require,
the method CheckAccess should be implemented in CHsmConnPoint */
//
// Check the security first
//
WsbAffirmHr( mqi[1].hr );
WsbAffirmHr( pServer->CheckAccess( WSB_ACCESS_TYPE_ADMINISTRATOR ) );
#endif
// get the server object itself
switch (type) {
case HSMCONN_TYPE_HSM: {
WsbAffirmHr( pConn->GetEngineServer((IHsmServer **)ppv) );
break;
}
case HSMCONN_TYPE_FSA:
case HSMCONN_TYPE_RESOURCE: {
WsbAffirmHr( pConn->GetFsaServer((IFsaServer **)ppv) );
break;
}
default: {
WsbThrow ( E_INVALIDARG );
break;
}
}
} else {
// Make sure interface pointer is safe (NULL) when failing
*ppv = 0;
}
} WsbCatchAndDo ( hr,
// Make sure interface pointer is safe (NULL) when failing
*ppv = 0;
) // WsbCatchAndDo
WsbTraceOut ( L"HsmConnectToServer",
L"HRESULT = %ls, *ppv = %ls",
WsbHrAsString ( hr ), WsbPtrToPtrAsString ( ppv ) );
return ( hr );
}
HRESULT
HsmGetComputerNameFromADsPath(
IN const OLECHAR * szADsPath,
OUT OLECHAR ** pszComputerName
)
/*++
Routine Description:
Extract the computer name from the ADs path of the RemoteStorage node.
The assumption here is that the full ADs path will contain this substring:
"CN=RemoteStorage,CN=computername,CN=Computers"
where computername is what we want to return.
Arguments:
szADsPath - The ADs path.
pszComputerName - The returned computer name.
Return Value:
S_OK - Computer name returned OK.
--*/
{
HRESULT hr = S_FALSE;
WCHAR* pContainerNode;
WCHAR* pRSNode;
WsbTraceIn(OLESTR("HsmGetComputerNameFromADsPath"),
OLESTR("AdsPath = <%ls>"), szADsPath);
// Find the RemoteStorage node name and the computers node name
// in the ADs path. If the machine is a DC, then we have to
// check for a "Domain Controllers" level instead.
*pszComputerName = NULL;
pRSNode = wcsstr(szADsPath, RsNodeName);
pContainerNode = wcsstr(szADsPath, ComputersNodeName);
if(!pContainerNode) {
pContainerNode = wcsstr(szADsPath, DCsNodeName);
}
if (pRSNode && pContainerNode && pRSNode < pContainerNode) {
WCHAR* pWc;
// Find the "CN=" before the computer name
pWc = wcsstr(pRSNode, CNEqual);
if (pWc && pWc < pContainerNode) {
WCHAR* pComma;
// Skip the "CN="
pWc += wcslen(CNEqual);
// Find the "," after the computer name
pComma = wcschr(pWc, OLECHAR(','));
// Extract the computer name
if (pWc < pContainerNode && pComma && pComma < pContainerNode) {
int len;
len = (int)(pComma - pWc);
// Remove '$' from end of name???
if (0 < len && OLECHAR('$') == pWc[len - 1]) {
len--;
}
*pszComputerName = static_cast<OLECHAR *>(WsbAlloc(
(len + 1) * sizeof(WCHAR)));
if (*pszComputerName) {
wcsncpy(*pszComputerName, pWc, len);
(*pszComputerName)[len] = 0;
hr = S_OK;
}
}
}
}
WsbTraceOut (OLESTR("HsmGetComputerNameFromADsPath"),
OLESTR("HRESULT = %ls, Computername = <%ls>"),
WsbHrAsString(hr), (*pszComputerName ? *pszComputerName : OLESTR("")));
return(hr);
}
static HRESULT HsmGetComputerNode(
const OLECHAR * Name,
IADsContainer **ppContainer
)
/*++
Routine Description:
Return the computer node for the given computer name in the current Domain
Arguments:
Name - Computer name.
ppContainer - Returned interface pointer of the node.
Return Value:
S_OK - Success.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn ( L"HsmGetComputerNode", L"Name = <%ls>", Name);
try {
WsbAssert(UseDirectoryServices, E_NOTIMPL);
WCHAR ComputerDn[MAX_PATH];
CWsbStringPtr temp;
ULONG ulen;
// Construct the SamCompatible (whatever that means) name
temp = DomainName;
temp.Append("\\");
temp.Append(Name);
temp.Append("$");
WsbTrace(L"HsmGetComputerNode: Domain\\computer = <%ls>\n",
static_cast<OLECHAR*>(temp));
// Translate that name to a fully qualified one
ulen = MAX_PATH;
ComputerDn[0] = WCHAR('\0');
if (TranslateName(temp, NameSamCompatible,
NameFullyQualifiedDN, ComputerDn, &ulen)) {
WsbTrace(L"HsmGetComputerNode: ComputerDn = <%ls>\n", ComputerDn);
// Get the computer node
temp = "LDAP://";
temp.Append(ComputerDn);
WsbTrace(L"HsmGetComputerNode: calling ADsGetObject with <%ls>\n",
static_cast<OLECHAR*>(temp));
WsbAffirmHr(ADsGetObject(temp, IID_IADsContainer,
(void**)ppContainer));
} else {
DWORD err = GetLastError();
WsbTrace(L"HsmGetComputerNode: TranslateName failed; ComputerDn = <%ls>, err = %ld\n",
ComputerDn, err);
if (err) {
WsbThrow(HRESULT_FROM_WIN32(err));
} else {
WsbThrow(E_UNEXPECTED);
}
}
WsbTrace(OLESTR("HsmGetComputerNode: got computer node\n"));
} WsbCatch( hr )
WsbTraceOut ( L"HsmGetComputerNode", L"HRESULT = %ls, *ppContainer = '%ls'",
WsbHrAsString ( hr ), WsbPtrToPtrAsString ( (void**)ppContainer ) );
return ( hr );
}
static HRESULT
HsmGetDsChild (
IN IADsContainer * pContainer,
IN const OLECHAR * Name,
IN REFIID riid,
OUT void ** ppv
)
/*++
Routine Description:
This routine returns back the requested child node.
Arguments:
pContainer - The parent container.
Name - The childs name (i.e. value of Name attribute or CN=Name)
riid - Desired interface to return.
ppv - Returned interface.
Return Value:
S_OK - Connection made, Success.
E_POINTER - Invalid pointer passed in as parameter.
E_* - Error
--*/
{
WsbTraceIn ( L"HsmGetDsChild",
L"pContainer = '0x%p', Name = '%ls', riid = '%ls', ppv = '0x%p'",
pContainer, Name, WsbGuidAsString ( riid ), ppv );
HRESULT hr = S_OK;
try {
CWsbStringPtr lName;
CComPtr<IDispatch> pDispatch;
// Validate params
WsbAssert ( 0 != pContainer, E_POINTER );
WsbAssert ( 0 != Name, E_POINTER );
WsbAssert ( 0 != ppv, E_POINTER );
WsbAssert(UseDirectoryServices, E_NOTIMPL);
// Check to see if the child exists
lName = Name;
hr = pContainer->GetObject(NULL, lName, &pDispatch);
if (FAILED(hr)) {
hr = S_OK;
lName.Prepend(CNEqual);
WsbAffirmHr(pContainer->GetObject(NULL, lName, &pDispatch));
}
// Convert to the correct interface
WsbAffirmHr(pDispatch->QueryInterface(riid, ppv));
} WsbCatch( hr )
WsbTraceOut ( L"HsmGetDsChild", L"HRESULT = %ls, *ppv = '%ls'",
WsbHrAsString ( hr ), WsbPtrToPtrAsString ( ppv ) );
return ( hr );
}
static const OLECHAR *
HsmConnTypeAsString (
IN HSMCONN_TYPE type
)
/*++
Routine Description:
Gives back a static string representing the connection type.
Note return type is strictly ANSI. This is intentional to make
macro work possible.
Arguments:
type - the type to return a string for.
Return Value:
NULL - invalid type passed in.
Otherwise, a valid char *.
--*/
{
#define STRINGIZE(_str) (OLESTR( #_str ))
#define RETURN_STRINGIZED_CASE(_case) \
case _case: \
return ( STRINGIZE( _case ) );
//
// Do the Switch
//
switch ( type ) {
RETURN_STRINGIZED_CASE( HSMCONN_TYPE_HSM );
RETURN_STRINGIZED_CASE( HSMCONN_TYPE_FSA );
RETURN_STRINGIZED_CASE( HSMCONN_TYPE_FILTER );
RETURN_STRINGIZED_CASE( HSMCONN_TYPE_RESOURCE );
default:
return ( OLESTR("Invalid Value") );
}
}
static GUID
HsmConnTypeToGuid(IN HSMCONN_TYPE type)
{
GUID serverGuid = GUID_NULL;
switch ( type ) {
case HSMCONN_TYPE_HSM:
serverGuid = CLSID_HsmServer;
break;
case HSMCONN_TYPE_FSA:
case HSMCONN_TYPE_RESOURCE:
serverGuid = CLSID_CFsaServerNTFS;
break;
}
return(serverGuid);
}
HRESULT
HsmConnectFromName (
IN HSMCONN_TYPE type,
IN const OLECHAR * Name,
IN REFIID riid,
OUT void ** ppv
)
/*++
Routine Description:
When given an name, connect and return the object representing the
Server, providing the specified interface.
Arguments:
type - The type of service / object we are connecting too.
Name - UNICODE string describing the Server to connect to.
riid - The interface type to return.
ppv - Returned interface pointer of the Server.
Return Value:
S_OK - Connection made, Success.
E_NOINTERFACE - Requested interface not supported by Server.
E_POINTER - ppv or Name is not a valid pointer.
E_OUTOFMEMORY - Low memory condition prevented connection.
E_INVALIDARG - The given name does not corespond to a known Server.
--*/
{
WsbTraceIn ( L"HsmConnectFromName",
L"type = '%ls', Name = '%ls', riid = '%ls', ppv = 0x%p",
HsmConnTypeAsString ( type ), Name, WsbGuidAsString ( riid ), ppv );
WsbTrace(OLESTR("HsmConnectFromName: UseDirectoryServices = %ls\n"),
WsbBoolAsString(UseDirectoryServices));
HRESULT hr = S_OK;
try {
BOOLEAN done = FALSE;
//
// Ensure parameters are valid
//
WsbAssert ( 0 != Name, E_POINTER );
WsbAssert ( 0 != ppv, E_POINTER );
if (!done) { // Try without Directory Services
CWsbStringPtr ComputerName = Name;
int i;
// Get the computer/server name
i = wcscspn(Name, OLESTR("\\"));
ComputerName[i] = 0;
if (HSMCONN_TYPE_RESOURCE == type) {
CWsbStringPtr Path;
OLECHAR * rscName;
CComPtr<IFsaResource> pFsaResource;
CComPtr<IFsaServer> pFsaServer;
WsbAffirmHr(HsmConnectToServer(type, ComputerName,
IID_IFsaServer, (void**)&pFsaServer));
// Determine if we have a logical name or a sticky name format.
// The logical name is a format like ("server\NTFS\d") and a sticky name
// format is like ("server\NTFS\Volume{GUID}\").
// Find the start of the last section and determine if there is only a single
// character after it or not.
rscName = wcsstr ( Name, L"NTFS\\" );
WsbAssert ( 0 != rscName, E_INVALIDARG );
// Now point just past the "NTFS\" part of the string. So we are pointing at
// either a single character, indicating the drive, or the "Volume{GUID}\".
rscName += 5;
Path = rscName;
if (wcslen (rscName) == 1) {
// Logical name ("server\NTFS\d") so convert to path and find resource
WsbAffirmHr(Path.Append(":\\"));
WsbAffirmHr(pFsaServer->FindResourceByPath(Path, &pFsaResource));
}
else {
// Sticky name ("server\NTFS\Volume{GUID}\") so find resource for it.
WsbAffirmHr(pFsaServer->FindResourceByStickyName(Path, &pFsaResource));
}
WsbAffirmHr(pFsaResource->QueryInterface(riid, ppv));
} else {
WsbAffirmHr(HsmConnectToServer(type, ComputerName, riid, ppv));
}
}
} WsbCatch ( hr )
WsbTraceOut ( L"HsmConnectFromName",
L"HRESULT = %ls, *ppv = %ls",
WsbHrAsString ( hr ), WsbPtrToPtrAsString ( ppv ) );
return ( hr );
}
HRESULT
HsmConnectFromId (
IN HSMCONN_TYPE type,
IN REFGUID rguid,
IN REFIID riid,
OUT void ** ppv
)
/*++
Routine Description:
Connects to the specified service or object. See HSMCONN_TYPE for
the types of services and objects.
Arguments:
type - The type of service / object we are connecting too.
rguid - The unique ID of the service / object to connect too.
riid - The interface type to return.
ppv - Returned interface pointer of the HSM Server.
Return Value:
S_OK - Connection made, Success.
E_NOINTERFACE - Requested interface not supported by HSM Server.
E_POINTER - ppv or Hsm is not a valid pointer.
E_OUTOFMEMORY - Low memory condition prevented connection.
E_INVALIDARG - The given ID and type do not correspond to a known
service or object.
--*/
{
WsbTraceIn ( L"HsmConnectFromId",
L"type = '%ls', rguid = '%ls', riid = '%ls', ppv = 0x%p",
HsmConnTypeAsString ( type ), WsbStringCopy ( WsbGuidAsString ( rguid ) ),
WsbStringCopy ( WsbGuidAsString ( riid ) ), ppv );
WsbTrace(OLESTR("HsmConnectFromId: UseDirectoryServices = %ls\n"),
WsbBoolAsString(UseDirectoryServices));
HRESULT hr = S_OK;
try {
BOOLEAN DSUsed = FALSE;
CWsbVariant guidVariant;
CComPtr < IADs > pObject;
CWsbStringPtr serverName;
CWsbVariant serverVariant;
//
// Ensure parameters are valid
//
WsbAssert ( 0 != ppv, E_POINTER );
switch ( type ) {
case HSMCONN_TYPE_HSM:
case HSMCONN_TYPE_FSA:
case HSMCONN_TYPE_FILTER:
if (DSUsed) {
} else {
WsbAffirmHr( WsbGetComputerName( serverName ) );
}
//
// Connect to the server
//
WsbAffirmHr ( HsmConnectToServer ( type, serverName, riid, ppv ) );
break;
case HSMCONN_TYPE_RESOURCE:
{
CComPtr< IFsaServer > pFsaServer;
GUID serverGuid;
serverGuid = HsmConnTypeToGuid(type);
WsbAffirmHr ( HsmConnectFromId ( HSMCONN_TYPE_FSA, serverGuid, IID_IFsaServer, (void**)&pFsaServer ) );
CComPtr< IFsaResource > pFsaResource;
WsbAffirmHr ( pFsaServer->FindResourceById ( rguid, &pFsaResource ) );
WsbAffirmHr ( pFsaResource->QueryInterface ( riid, ppv ) );
}
break;
default:
WsbThrow ( E_INVALIDARG );
}
} WsbCatch ( hr )
WsbTraceOut ( L"HsmConnectFromId",
L"HRESULT = %ls, *ppv = %ls",
WsbHrAsString ( hr ), WsbPtrToPtrAsString ( ppv ) );
return ( hr );
}
HRESULT
HsmPublish (
IN HSMCONN_TYPE type,
IN const OLECHAR * Name,
IN REFGUID rguidObjectId,
IN const OLECHAR * Server,
IN REFGUID rguid
)
/*++
Routine Description:
Publish (i.e. store) information about the service/object in
Directory Services.
Arguments:
type - The type of service/object.
Name - Name (possibly preceded by a subpath) of the Service/Object.
rguidObjectId - The ID that the object is known by.
Server - The server (computer name) on which the service actually exists.
For resources, this will be NULL since it is implicit in the
FSA specified by rguid.
rguid - For resources, the ID of the FSA. For services, the CLSID of
the service's class factory ie. CLSID_HsmServer.
Return Value:
S_OK - Connection made, Success.
E_POINTER - Name or Server is not a valid pointer.
E_OUTOFMEMORY - Low memory condition prevented connection.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn ( L"HsmPublish",
L"type = '%ls', Name = '%ls', rguidObjectId = '%ls', Server = '%ls', rguid = '%ls'",
HsmConnTypeAsString ( type ), Name,
WsbStringCopy ( WsbGuidAsString ( rguidObjectId ) ), Server,
WsbStringCopy ( WsbGuidAsString ( rguid ) ) );
WsbTrace(OLESTR("HsmPublish: UseDirectoryServices = %ls\n"),
WsbBoolAsString(UseDirectoryServices));
try {
//
// Ensure parameters are valid
//
WsbAssert ( 0 != Name, E_POINTER );
WsbAssert ( ( HSMCONN_TYPE_RESOURCE == type ) || ( 0 != Server ), E_POINTER );
// Perhaps we should output a log event if the DS is not writable
// We now only publish the Engine service. Perhaps in the future we
// will publish additional information
if (HSMCONN_TYPE_HSM == type && UseDirectoryServices && DSIsWritable) {
CWsbStringPtr pathToName;
try {
DWORD aSet;
CWsbStringPtr guidString(rguidObjectId);
HRESULT hrGetNode;
CComPtr<IADsContainer> pComputer;
CComPtr<IDispatch> pDispatch;
CComPtr<IDirectoryObject> pDirObj;
CComPtr<IADs> pNode;
// Save the node name for the event log message
pathToName = Name;
pathToName.Append("\\");
pathToName.Append(RsNodeName);
// Get the computer node
WsbAffirmHr(HsmGetComputerNode(Name, &pComputer));
// See if we're already published
hrGetNode = HsmGetDsChild(pComputer, RsNodeName,
IID_IADs, (void**)&pNode);
// If not, add our node
if (HRESULT_FROM_WIN32(ERROR_DS_NO_SUCH_OBJECT) == hrGetNode) {
CWsbBstrPtr relPath(RsNodeName);
relPath.Prepend(CNEqual);
WsbAffirmHr(pComputer->Create(RsNodeType, relPath, &pDispatch));
WsbAffirmHr(pDispatch->QueryInterface(IID_IADs,
(void**)&pNode));
// Force info out of cache
WsbAffirmHr(pNode->SetInfo());
} else {
WsbAffirmHr(hrGetNode);
}
// Set the GUID & ServiceBinding values
adsValue[0].dwType = ADSTYPE_CASE_IGNORE_STRING;
adsValue[0].CaseIgnoreString = (WCHAR*)guidString;
aaInfo[0].pszAttrName = GuidAttrName;
aaInfo[0].dwControlCode = ADS_ATTR_UPDATE;
aaInfo[0].dwADsType = ADSTYPE_CASE_IGNORE_STRING;
aaInfo[0].pADsValues = &adsValue[0];
aaInfo[0].dwNumValues = 1;
adsValue[1].dwType = ADSTYPE_CASE_IGNORE_STRING;
adsValue[1].CaseIgnoreString = ServiceBindValue;
aaInfo[1].pszAttrName = ServiceBindAttrName;
aaInfo[1].dwControlCode = ADS_ATTR_UPDATE;
aaInfo[1].dwADsType = ADSTYPE_CASE_IGNORE_STRING;
aaInfo[1].pADsValues = &adsValue[1];
aaInfo[1].dwNumValues = 1;
WsbAffirmHr(pNode->QueryInterface(IID_IDirectoryObject,
(void**)&pDirObj));
WsbAffirmHr(pDirObj->SetObjectAttributes(aaInfo, 2, &aSet));
WsbTrace(L"HsmPublish: after SetObjectAttributes, aSet = %ld\n",
aSet);
WsbLogEvent(WSB_MESSAGE_PUBLISH_IN_DS, 0, NULL,
static_cast<OLECHAR*>(pathToName), NULL);
} WsbCatchAndDo(hr,
WsbLogEvent(WSB_MESSAGE_PUBLISH_FAILED, 0, NULL,
static_cast<OLECHAR*>(pathToName), NULL);
hr = S_OK; // Don't stop service just for this
)
}
} WsbCatch ( hr )
WsbTraceOut ( L"HsmPublish", L"HRESULT = %ls", WsbHrAsString ( hr ) );
return ( hr );
}
// GetDSState - determine if we're using Directory Services or not
static void GetDSState(void)
{
BOOL CheckForDS = TRUE;
DOMAIN_CONTROLLER_INFO * dc_info;
DWORD size;
OLECHAR vstr[32];
DWORD status;
UseDirectoryServices = FALSE;
// Should we attempt to use directory services in this module?
// (Setting the registry value to "0" allows us to avoid Directory
// Services completely
if (S_OK == WsbGetRegistryValueString(NULL, REG_PATH, REG_USE_DS,
vstr, 32, &size)) {
OLECHAR *stop;
ULONG value;
value = wcstoul(vstr, &stop, 10 );
if (0 == value) {
CheckForDS = FALSE;
}
}
// Get the account domain name
WsbGetAccountDomainName(DomainName, MAX_COMPUTERNAME_LENGTH );
#if defined(HSMCONN_DEBUG)
swprintf(dbg_string, L"Account domain name = <%ls>\n", DomainName);
OutputDebugString(dbg_string);
#endif
// Check if Directory Services is available
if (CheckForDS) {
status = DsGetDcName(NULL, NULL, NULL, NULL,
DS_DIRECTORY_SERVICE_REQUIRED | DS_IS_FLAT_NAME |
DS_RETURN_FLAT_NAME, &dc_info);
#if defined(HSMCONN_DEBUG)
swprintf(dbg_string, L"DsGetDcName status = %d\n", status);
OutputDebugString(dbg_string);
#endif
if (NO_ERROR == status) {
#if defined(HSMCONN_DEBUG)
swprintf(dbg_string, L"dc_info->DomainName = <%ls>\n", dc_info->DomainName);
OutputDebugString(dbg_string);
#endif
if (dc_info->Flags & DS_DS_FLAG) {
wcscpy(DomainName, dc_info->DomainName);
UseDirectoryServices = TRUE;
if (dc_info->Flags & DS_WRITABLE_FLAG) {
DSIsWritable = TRUE;
}
}
NetApiBufferFree(dc_info);
}
}
#if defined(HSMCONN_DEBUG)
swprintf(dbg_string, L"dHsmConn - GetDSState: UseDirectoryServices = %ls\n",
WsbBoolAsString(UseDirectoryServices));
OutputDebugString(dbg_string);
#endif
}
} // extern "C"