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.
2288 lines
60 KiB
2288 lines
60 KiB
//+--------------------------------------------------------------------------
|
|
//
|
|
// Copyright (c) 1997-1999 Microsoft Corporation
|
|
//
|
|
// File: tlsjob.cpp
|
|
//
|
|
// Contents: Various license server job.
|
|
//
|
|
// History:
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
#include "pch.cpp"
|
|
#include "tlsjob.h"
|
|
#include "jobmgr.h"
|
|
#include "wkstore.h"
|
|
#include "srvlist.h"
|
|
#include "kp.h"
|
|
#include "clilic.h"
|
|
#include "keypack.h"
|
|
#include "init.h"
|
|
#include <winsta.h>
|
|
#include <globals.h>
|
|
#define STRSAFE_NO_DEPRECATE
|
|
#include "strsafe.h"
|
|
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
//
|
|
//
|
|
//
|
|
//
|
|
/////////////////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
// Various interface into global work manager
|
|
//////////////////////////////////////////////////////////////
|
|
CWorkManager g_WorkManager;
|
|
CPersistentWorkStorage g_WorkStorage;
|
|
|
|
#define MAX_ERROR_MSG_SIZE 1024
|
|
|
|
|
|
|
|
|
|
|
|
DWORD
|
|
TLSWorkManagerInit()
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
Initialize work manager.
|
|
|
|
Parameter:
|
|
|
|
None.
|
|
|
|
returns:
|
|
|
|
ERROR_SUCCESS or error code.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus;
|
|
WorkItemTable* pWkStorageTable = NULL;
|
|
|
|
//
|
|
// Initialize Work Storage table
|
|
//
|
|
pWkStorageTable = GetWorkItemStorageTable();
|
|
if(pWkStorageTable == NULL)
|
|
{
|
|
dwStatus = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Init Persistent work storage table
|
|
//
|
|
if(g_WorkStorage.AttachTable(pWkStorageTable) == FALSE)
|
|
{
|
|
dwStatus = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Initialize Work Manager
|
|
//
|
|
dwStatus = g_WorkManager.Startup(&g_WorkStorage);
|
|
|
|
cleanup:
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//-----------------------------------------------------------
|
|
|
|
void
|
|
TLSWorkManagerShutdown()
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
Shutdown work manager.
|
|
|
|
Parameter:
|
|
|
|
None:
|
|
|
|
Return:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
g_WorkManager.Shutdown();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------
|
|
|
|
DWORD
|
|
TLSWorkManagerSchedule(
|
|
IN DWORD dwTime,
|
|
IN CWorkObject* pJob
|
|
)
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
Schedule a job to work manager.
|
|
|
|
Parameter:
|
|
|
|
dwTime : Suggested time for work manager to process this job.
|
|
pJob : Job to be processed/scheduled.
|
|
|
|
Returns:
|
|
|
|
ERROR_SUCCESS or error code.
|
|
|
|
--*/
|
|
{
|
|
return g_WorkManager.ScheduleJob(dwTime, pJob);
|
|
}
|
|
|
|
//-----------------------------------------------------------
|
|
|
|
BOOL
|
|
TLSWorkManagerSetJobDefaults(
|
|
CWorkObject* pJob
|
|
)
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
Set job's interval and retry time.
|
|
|
|
Parameter:
|
|
|
|
pJob : Job to be set.
|
|
|
|
Returns:
|
|
|
|
TRUE/FALSE.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwInterval, dwRetries, dwRestart;
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
if(pJob != NULL)
|
|
{
|
|
GetJobObjectDefaults(&dwInterval, &dwRetries, &dwRestart);
|
|
pJob->SetJobInterval(dwInterval);
|
|
pJob->SetJobRetryTimes(dwRetries);
|
|
pJob->SetJobRestartTime(dwRestart);
|
|
}
|
|
else
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
return dwStatus == ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------
|
|
BOOL
|
|
CopyBinaryData(
|
|
IN OUT PBYTE* ppbDestData,
|
|
IN OUT DWORD* pcbDestData,
|
|
IN PBYTE pbSrcData,
|
|
IN DWORD cbSrcData
|
|
)
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
Internal routine to copy a binary data from one buffer
|
|
to another.
|
|
|
|
Parameters:
|
|
|
|
ppbDestData: Pointer to pointer...
|
|
pcbDestData:
|
|
pbSrcData:
|
|
cbSrcData:
|
|
|
|
Return:
|
|
|
|
TRUE if successful, FALSE otherwise.
|
|
|
|
++*/
|
|
{
|
|
PBYTE pbTarget = NULL;
|
|
|
|
if( ppbDestData == NULL || pcbDestData == NULL ||
|
|
pbSrcData == NULL || cbSrcData == 0 )
|
|
{
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
pbTarget = *ppbDestData;
|
|
|
|
//
|
|
// would be nice to get the actual size of memory allocated
|
|
//
|
|
if( *ppbDestData == NULL || LocalSize(*ppbDestData) < cbSrcData )
|
|
{
|
|
if(*ppbDestData == NULL)
|
|
{
|
|
pbTarget = (PBYTE)AllocateMemory(cbSrcData);
|
|
}
|
|
else
|
|
{
|
|
pbTarget = (PBYTE)ReallocateMemory(*ppbDestData, cbSrcData);
|
|
}
|
|
}
|
|
|
|
if(pbTarget != NULL)
|
|
{
|
|
memcpy(
|
|
pbTarget,
|
|
pbSrcData,
|
|
cbSrcData
|
|
);
|
|
|
|
*pcbDestData = cbSrcData;
|
|
*ppbDestData = pbTarget;
|
|
}
|
|
|
|
return pbTarget != NULL;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CAnnounceLsServer
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
BOOL
|
|
CAnnounceLserver::VerifyWorkObjectData(
|
|
IN BOOL bCallByIsValid, // invoke by IsValid() function.
|
|
IN PANNOUNCESERVERWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Verify Announce License Server work object Data.
|
|
|
|
--*/
|
|
{
|
|
BOOL bSuccess = FALSE;
|
|
DWORD dwLen;
|
|
|
|
if(pbData == NULL || cbData == 0 || cbData != pbData->dwStructSize)
|
|
{
|
|
TLSASSERT(FALSE);
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// NULL terminate string...
|
|
//
|
|
pbData->m_szServerId[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
pbData->m_szServerName[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
|
|
dwLen = _tcslen(pbData->m_szServerId);
|
|
if(dwLen != 0 && dwLen < LSERVER_MAX_STRING_SIZE + 1)
|
|
{
|
|
dwLen = _tcslen(pbData->m_szServerName);
|
|
if(dwLen != 0 && dwLen < LSERVER_MAX_STRING_SIZE + 1)
|
|
{
|
|
bSuccess = TRUE;
|
|
}
|
|
}
|
|
|
|
if(bSuccess == FALSE)
|
|
{
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceLserver::CopyWorkObjectData(
|
|
OUT PANNOUNCESERVERWO* ppbDest,
|
|
OUT PDWORD pcbDest,
|
|
IN PANNOUNCESERVERWO pbSrc,
|
|
IN DWORD cbSrc
|
|
)
|
|
/*++
|
|
|
|
Copy Announce license server work object's data
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
if(ppbDest == NULL || pcbDest == NULL)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
TLSASSERT(FALSE);
|
|
goto cleanup;
|
|
}
|
|
|
|
if(CopyBinaryData(
|
|
(PBYTE *)ppbDest,
|
|
pcbDest,
|
|
(PBYTE) pbSrc,
|
|
cbSrc
|
|
) == FALSE)
|
|
{
|
|
dwStatus = GetLastError();
|
|
}
|
|
|
|
cleanup:
|
|
|
|
return dwStatus == ERROR_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceLserver::CleanupWorkObjectData(
|
|
IN OUT PANNOUNCESERVERWO* ppbData,
|
|
IN OUT PDWORD pcbData
|
|
)
|
|
/*++
|
|
|
|
Cleanup Announce license server's work object data.
|
|
|
|
--*/
|
|
{
|
|
if(ppbData != NULL && pcbData != NULL)
|
|
{
|
|
FreeMemory(*ppbData);
|
|
*ppbData = NULL;
|
|
*pcbData = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceLserver::IsJobCompleted(
|
|
IN PANNOUNCESERVERWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Determine if Announce License Server Job has completed.
|
|
|
|
--*/
|
|
{
|
|
return (pbData == NULL) ? TRUE : (pbData->dwRetryTimes > GetJobRetryTimes());
|
|
}
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
ServerEnumCallBack(
|
|
TLS_HANDLE hHandle,
|
|
LPCTSTR pszServerName,
|
|
HANDLE dwUserData
|
|
)
|
|
/*++
|
|
|
|
See TLSAPI on license server enumeration.
|
|
|
|
++*/
|
|
{
|
|
CAnnounceLserver* pWkObject = (CAnnounceLserver *)dwUserData;
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
DWORD dwErrCode;
|
|
|
|
TCHAR szRemoteServerId[LSERVER_MAX_STRING_SIZE+2];
|
|
TCHAR szRemoteServerName[LSERVER_MAX_STRING_SIZE+2];
|
|
|
|
if(pWkObject == NULL)
|
|
{
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
TLSASSERT(dwUserData != NULL);
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL bCancel;
|
|
|
|
if(pWkObject->IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Enumeration call ServerEnumCallBack() twice, once before actual connection
|
|
// and once after it successfully connect to remote server
|
|
//
|
|
if( lstrcmpi(pszServerName, pWkObject->GetWorkData()->m_szServerName) != 0 && hHandle != NULL)
|
|
{
|
|
//
|
|
// throw exception if fail to allocate memory
|
|
//
|
|
TLServerInfo ServerInfo;
|
|
TLServerInfo ExistingServerInfo;
|
|
TLS_HANDLE hTrustHandle;
|
|
|
|
hTrustHandle = TLSConnectAndEstablishTrust(
|
|
NULL,
|
|
hHandle
|
|
);
|
|
if(hTrustHandle != NULL)
|
|
{
|
|
dwStatus = TLSRetrieveServerInfo(
|
|
hTrustHandle,
|
|
&ServerInfo
|
|
);
|
|
|
|
if( dwStatus == ERROR_SUCCESS &&
|
|
lstrcmpi(ServerInfo.GetServerId(), pWkObject->GetWorkData()->m_szServerId) != 0 )
|
|
// lstrcmpi(ServerInfo.GetServerName(), pWkObject->GetWorkData()->m_szServerName) != 0
|
|
{
|
|
// check to see if this server is already exists
|
|
dwStatus = TLSLookupRegisteredServer(
|
|
ServerInfo.GetServerId(),
|
|
ServerInfo.GetServerDomain(),
|
|
ServerInfo.GetServerName(),
|
|
&ExistingServerInfo
|
|
);
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
ServerInfo = ExistingServerInfo;
|
|
}
|
|
else
|
|
{
|
|
// register every server.
|
|
dwStatus = TLSRegisterServerWithServerInfo(&ServerInfo);
|
|
if(dwStatus == TLS_E_DUPLICATE_RECORD)
|
|
{
|
|
dwStatus = ERROR_SUCCESS;
|
|
}
|
|
}
|
|
|
|
// let enforce talk to non-enforce, replication will be block later
|
|
if( ServerInfo.IsAnnounced() == FALSE && dwStatus == ERROR_SUCCESS )
|
|
{
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s - Announce to %s\n"),
|
|
pWkObject->GetJobDescription(),
|
|
ServerInfo.GetServerName()
|
|
);
|
|
|
|
dwStatus = TLSAnnounceServerToRemoteServer(
|
|
TLSANNOUNCE_TYPE_STARTUP,
|
|
ServerInfo.GetServerId(),
|
|
ServerInfo.GetServerDomain(),
|
|
ServerInfo.GetServerName(),
|
|
pWkObject->GetWorkData()->m_szServerId,
|
|
pWkObject->GetWorkData()->m_szScope,
|
|
pWkObject->GetWorkData()->m_szServerName,
|
|
&(pWkObject->GetWorkData()->m_ftLastShutdownTime)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return (dwStatus == ERROR_SUCCESS) ? pWkObject->IsWorkManagerShuttingDown() : TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
DWORD
|
|
CAnnounceLserver::ExecuteJob(
|
|
IN PANNOUNCESERVERWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Execute a announce license server job.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s ...\n"),
|
|
GetJobDescription()
|
|
);
|
|
|
|
if(IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
return TLS_I_WORKMANAGER_SHUTDOWN;
|
|
}
|
|
|
|
//
|
|
// Enumerate all license server
|
|
//
|
|
dwStatus = EnumerateTlsServer(
|
|
ServerEnumCallBack,
|
|
this,
|
|
TLSERVER_ENUM_TIMEOUT,
|
|
FALSE
|
|
);
|
|
|
|
//
|
|
// Discovery run twice so that if more than one server
|
|
// start up at the same time, second loop will catch it.
|
|
//
|
|
pbData->dwRetryTimes++;
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s ended...\n"),
|
|
GetJobDescription()
|
|
);
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
LPCTSTR
|
|
CAnnounceLserver::GetJobDescription()
|
|
/*++
|
|
|
|
Get announce license server job description, this is used
|
|
only at debug tracing.
|
|
|
|
--*/
|
|
{
|
|
memset(m_szJobDescription, 0, sizeof(m_szJobDescription));
|
|
|
|
_tcsncpy(
|
|
m_szJobDescription,
|
|
ANNOUNCESERVER_DESCRIPTION,
|
|
sizeof(m_szJobDescription)/sizeof(m_szJobDescription[0]) - 1
|
|
);
|
|
|
|
return m_szJobDescription;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CAnnounceTOEServer
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
BOOL
|
|
CAnnounceToEServer::VerifyWorkObjectData(
|
|
IN BOOL bCallByIsValid, // invoke by IsValid() function.
|
|
IN PANNOUNCETOESERVERWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Verify Announce license server to enterprise server work object
|
|
data.
|
|
|
|
--*/
|
|
{
|
|
BOOL bSuccess = FALSE;
|
|
DWORD dwLen;
|
|
|
|
if(pbData == NULL || cbData != pbData->dwStructSize)
|
|
{
|
|
TLSASSERT(FALSE);
|
|
SetLastError(ERROR_INVALID_PARAMETER);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// NULL terminate string...
|
|
//
|
|
pbData->m_szServerId[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
pbData->m_szServerName[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
|
|
dwLen = _tcslen(pbData->m_szServerId);
|
|
if(dwLen != 0 && dwLen < LSERVER_MAX_STRING_SIZE + 1)
|
|
{
|
|
dwLen = _tcslen(pbData->m_szServerName);
|
|
if(dwLen != 0 && dwLen < LSERVER_MAX_STRING_SIZE + 1)
|
|
{
|
|
bSuccess = TRUE;
|
|
}
|
|
}
|
|
|
|
if(bSuccess == FALSE)
|
|
{
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceToEServer::CopyWorkObjectData(
|
|
OUT PANNOUNCETOESERVERWO* ppbDest,
|
|
OUT PDWORD pcbDest,
|
|
IN PANNOUNCETOESERVERWO pbSrc,
|
|
IN DWORD cbSrc
|
|
)
|
|
/*++
|
|
|
|
Copy announce license server to enterprise server work
|
|
object data.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
if(ppbDest == NULL || pcbDest == NULL)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
TLSASSERT(FALSE);
|
|
goto cleanup;
|
|
}
|
|
|
|
if(CopyBinaryData(
|
|
(PBYTE *)ppbDest,
|
|
pcbDest,
|
|
(PBYTE) pbSrc,
|
|
cbSrc
|
|
) == FALSE)
|
|
{
|
|
dwStatus = GetLastError();
|
|
}
|
|
|
|
cleanup:
|
|
|
|
return dwStatus == ERROR_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceToEServer::CleanupWorkObjectData(
|
|
IN OUT PANNOUNCETOESERVERWO* ppbData,
|
|
IN OUT PDWORD pcbData
|
|
)
|
|
/*++
|
|
|
|
Cleanup announce license server to enterprise server work
|
|
object data.
|
|
|
|
--*/
|
|
{
|
|
if(ppbData != NULL && pcbData != NULL)
|
|
{
|
|
FreeMemory(*ppbData);
|
|
*ppbData = NULL;
|
|
*pcbData = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceToEServer::IsJobCompleted(
|
|
IN PANNOUNCETOESERVERWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Detemine if announce license server to enterprise server
|
|
is completed.
|
|
|
|
--*/
|
|
{
|
|
return (pbData == NULL) ? TRUE : GetWorkData()->bCompleted;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
DWORD
|
|
CAnnounceToEServer::ExecuteJob(
|
|
IN PANNOUNCETOESERVERWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Execute an announce license server to enterprise server work object.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
LPWSTR* pszEServerList = NULL;
|
|
DWORD dwCount = 0;
|
|
DWORD dwErrCode;
|
|
BOOL bSkipServer;
|
|
TCHAR szRemoteServerId[LSERVER_MAX_STRING_SIZE+2];
|
|
TCHAR szRemoteServerName[LSERVER_MAX_STRING_SIZE+2];
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s ...\n"),
|
|
GetJobDescription()
|
|
);
|
|
|
|
|
|
TLSASSERT(pbData != NULL && cbData != 0);
|
|
|
|
dwStatus = GetAllEnterpriseServers(
|
|
&pszEServerList,
|
|
&dwCount
|
|
);
|
|
|
|
if(dwStatus == ERROR_SUCCESS && dwCount > 0 && pszEServerList != NULL)
|
|
{
|
|
|
|
for(DWORD index = 0;
|
|
index < dwCount && IsWorkManagerShuttingDown() == FALSE;
|
|
index++)
|
|
{
|
|
bSkipServer = TRUE;
|
|
|
|
if(pszEServerList[index] == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// check if we already have this server in our list
|
|
//
|
|
TLServerInfo ServerInfo;
|
|
dwStatus = TLSLookupRegisteredServer(
|
|
NULL,
|
|
NULL,
|
|
pszEServerList[index],
|
|
&ServerInfo
|
|
);
|
|
|
|
if(dwStatus != ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// Get the actual server name.
|
|
//
|
|
TLS_HANDLE hTrustHandle = NULL;
|
|
|
|
hTrustHandle = TLSConnectAndEstablishTrust(
|
|
pszEServerList[index],
|
|
NULL
|
|
);
|
|
if(hTrustHandle != NULL)
|
|
{
|
|
if(IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
// handle leak but we are shutting down
|
|
break;
|
|
}
|
|
|
|
dwStatus = TLSRetrieveServerInfo(
|
|
hTrustHandle,
|
|
&ServerInfo
|
|
);
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
if( lstrcmpi(ServerInfo.GetServerName(), pbData->m_szServerName) != 0 )
|
|
{
|
|
|
|
if(IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
// handle leak but we are shutting down
|
|
break;
|
|
}
|
|
|
|
dwStatus = TLSRegisterServerWithServerInfo(&ServerInfo);
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
// at this point, if we gets duplicate record, that mean
|
|
// server is registered via announce and we already
|
|
// sync. local license pack so skip it.
|
|
bSkipServer = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( hTrustHandle != NULL)
|
|
{
|
|
TLSDisconnectFromServer(hTrustHandle);
|
|
}
|
|
|
|
dwStatus = ERROR_SUCCESS;
|
|
if(bSkipServer == TRUE)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
else if(GetLicenseServerRole() & TLSERVER_ENTERPRISE_SERVER)
|
|
{
|
|
// for enterprise server, other server will announce itself,
|
|
// for domain server, we need to announce once a while
|
|
// so that after enterprise restart, it still have our
|
|
// server
|
|
if(dwStatus == ERROR_SUCCESS && ServerInfo.GetServerVersion() != 0)
|
|
{
|
|
//
|
|
// we already 'push' sync. with this server
|
|
//
|
|
continue;
|
|
}
|
|
}
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s - Announce to %s\n"),
|
|
GetJobDescription(),
|
|
pszEServerList[index]
|
|
);
|
|
|
|
if(IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
// handle leak but we are shutting down
|
|
break;
|
|
}
|
|
|
|
dwStatus = TLSAnnounceServerToRemoteServer(
|
|
TLSANNOUNCE_TYPE_STARTUP,
|
|
ServerInfo.GetServerId(),
|
|
ServerInfo.GetServerDomain(),
|
|
ServerInfo.GetServerName(),
|
|
GetWorkData()->m_szServerId,
|
|
GetWorkData()->m_szScope,
|
|
GetWorkData()->m_szServerName,
|
|
&(GetWorkData()->m_ftLastShutdownTime)
|
|
);
|
|
}
|
|
|
|
//
|
|
// Free memory
|
|
//
|
|
if(pszEServerList != NULL)
|
|
{
|
|
for( index = 0; index < dwCount; index ++)
|
|
{
|
|
if(pszEServerList[index] != NULL)
|
|
{
|
|
LocalFree(pszEServerList[index]);
|
|
}
|
|
}
|
|
|
|
LocalFree(pszEServerList);
|
|
}
|
|
}
|
|
//
|
|
// Continue running in case user install a NT5 PDC
|
|
//
|
|
if(IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
GetWorkData()->bCompleted = TRUE;
|
|
}
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
LPCTSTR
|
|
CAnnounceToEServer::GetJobDescription()
|
|
/*++
|
|
|
|
Get announce license server to enterprise server
|
|
job description, used only at debug tracing.
|
|
|
|
--*/
|
|
{
|
|
memset(m_szJobDescription, 0, sizeof(m_szJobDescription));
|
|
|
|
_tcsncpy(
|
|
m_szJobDescription,
|
|
ANNOUNCETOESERVER_DESCRIPTION,
|
|
sizeof(m_szJobDescription)/sizeof(m_szJobDescription[0]) - 1
|
|
);
|
|
|
|
return m_szJobDescription;
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CReturnLicense
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
CWorkObject* WINAPI
|
|
InitializeCReturnWorkObject(
|
|
IN CWorkManager* pWkMgr,
|
|
IN PBYTE pbWorkData,
|
|
IN DWORD cbWorkData
|
|
)
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
Create/initialize a Return License work object.
|
|
|
|
Parameters:
|
|
|
|
pWkMgr : Pointer work manager.
|
|
pbWorkData : Object's work data used to initialize return license.
|
|
cbWorkData : size of work data.
|
|
|
|
Return:
|
|
|
|
A pointer to CWorkObject or NULL if error.
|
|
|
|
--*/
|
|
{
|
|
CReturnLicense* pRetLicense = NULL;
|
|
DWORD dwStatus;
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_WORKMGR,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("InitializeCReturnWorkObject() - initializing return license...\n")
|
|
);
|
|
|
|
pRetLicense = new CReturnLicense(
|
|
TRUE,
|
|
(PRETURNLICENSEWO)pbWorkData,
|
|
cbWorkData
|
|
);
|
|
|
|
//
|
|
// TODO - fix this, bad design
|
|
//
|
|
pRetLicense->SetProcessingWorkManager(pWkMgr);
|
|
TLSASSERT(pRetLicense->IsValid() == TRUE);
|
|
|
|
return pRetLicense;
|
|
}
|
|
|
|
//--------------------------------------------------------
|
|
BOOL
|
|
CReturnLicense::VerifyWorkObjectData(
|
|
IN BOOL bCallByIsValid,
|
|
IN PRETURNLICENSEWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Verify a return license work object data.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
DWORD dwLen;
|
|
DWORD dwNumLicensedProduct;
|
|
|
|
if(pbData == NULL || cbData == 0 || pbData->cbEncryptedHwid == 0)
|
|
{
|
|
TLSASSERT(FALSE);
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
if( pbData->dwStructVersion < CURRENT_RETURNLICENSEWO_STRUCT_VER ||
|
|
pbData->dwStructSize != cbData )
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
TLSASSERT(FALSE);
|
|
}
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// NULL Terminate Target Server ID
|
|
//
|
|
pbData->szTargetServerId[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
dwLen = _tcslen(pbData->szTargetServerId);
|
|
|
|
if(dwLen == 0 || dwLen >= LSERVER_MAX_STRING_SIZE+1)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
pbData->szTargetServerName[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
dwLen = _tcslen(pbData->szTargetServerName);
|
|
|
|
if(dwLen == 0 || dwLen >= LSERVER_MAX_STRING_SIZE+1)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
pbData->szOrgProductID[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
dwLen = _tcslen(pbData->szOrgProductID);
|
|
if(dwLen == 0 || dwLen >= LSERVER_MAX_STRING_SIZE+1)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
pbData->szCompanyName[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
dwLen = _tcslen(pbData->szCompanyName);
|
|
if(dwLen == 0 || dwLen >= LSERVER_MAX_STRING_SIZE+1)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
pbData->szProductId[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
dwLen = _tcslen(pbData->szProductId);
|
|
if(dwLen == 0 || dwLen >= LSERVER_MAX_STRING_SIZE+1)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
pbData->szUserName[MAXCOMPUTERNAMELENGTH+1] = _TEXT('\0');
|
|
dwLen = _tcslen(pbData->szUserName);
|
|
if(dwLen == 0 || dwLen >= MAXCOMPUTERNAMELENGTH+1)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
pbData->szMachineName[MAXUSERNAMELENGTH+1] = _TEXT('\0');
|
|
dwLen = _tcslen(pbData->szMachineName);
|
|
if(dwLen == 0 || dwLen >= MAXUSERNAMELENGTH+1)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
return dwStatus == ERROR_SUCCESS;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CReturnLicense::CopyWorkObjectData(
|
|
IN OUT PRETURNLICENSEWO* ppbDest,
|
|
IN OUT PDWORD pcbDest,
|
|
IN PRETURNLICENSEWO pbSrc,
|
|
IN DWORD cbSrc
|
|
)
|
|
/*++
|
|
|
|
Copy return license work object data.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
if(ppbDest == NULL || pcbDest == NULL)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
TLSASSERT(FALSE);
|
|
goto cleanup;
|
|
}
|
|
|
|
if(CopyBinaryData(
|
|
(PBYTE *)ppbDest,
|
|
pcbDest,
|
|
(PBYTE) pbSrc,
|
|
cbSrc
|
|
) == FALSE)
|
|
{
|
|
dwStatus = GetLastError();
|
|
}
|
|
|
|
cleanup:
|
|
return dwStatus == ERROR_SUCCESS;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CReturnLicense::CleanupWorkObjectData(
|
|
IN OUT PRETURNLICENSEWO* ppbData,
|
|
IN OUT PDWORD pcbData
|
|
)
|
|
/*++
|
|
|
|
Cleanup return license work object data.
|
|
|
|
--*/
|
|
{
|
|
if(ppbData != NULL && pcbData != NULL)
|
|
{
|
|
FreeMemory(*ppbData);
|
|
*ppbData = NULL;
|
|
*pcbData = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
CReturnLicense::IsJobCompleted(
|
|
IN PRETURNLICENSEWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Determine if return license job is completed.
|
|
|
|
--*/
|
|
{
|
|
return (pbData != NULL) ? (pbData->dwNumRetry >= m_dwRetryTimes) : TRUE;
|
|
}
|
|
|
|
RPC_STATUS
|
|
TryGetLastError(PCONTEXT_HANDLE hBinding,
|
|
LPTSTR *pszBuffer,
|
|
DWORD *pdwErrCode)
|
|
{
|
|
RPC_STATUS status;
|
|
|
|
status = TLSGetLastErrorFixed(hBinding,pszBuffer,pdwErrCode);
|
|
|
|
if(status != RPC_S_OK)
|
|
{
|
|
LPTSTR lpszError = NULL;
|
|
status = ERROR_NOACCESS;
|
|
size_t cbError;
|
|
try
|
|
{
|
|
if ( !MyVirtualAlloc( (LSERVER_MAX_STRING_SIZE+1) * sizeof( TCHAR ),
|
|
(PVOID*) &lpszError ) )
|
|
{
|
|
return RPC_S_OUT_OF_MEMORY;
|
|
}
|
|
|
|
DWORD uSize = LSERVER_MAX_STRING_SIZE +1 ;
|
|
|
|
memset(lpszError, 0, ( LSERVER_MAX_STRING_SIZE +1 ) * sizeof( TCHAR ));
|
|
|
|
|
|
status = TLSGetLastError(hBinding,uSize,lpszError,pdwErrCode);
|
|
|
|
if((status == RPC_S_OK) && (pdwErrCode != NULL) && (*pdwErrCode == ERROR_SUCCESS))
|
|
{
|
|
if (SUCCEEDED(StringCbLength(lpszError,uSize,&cbError)))
|
|
{
|
|
*pszBuffer = (LPTSTR)MIDL_user_allocate(cbError+sizeof(TCHAR));
|
|
|
|
if (NULL != *pszBuffer)
|
|
{
|
|
_tcscpy(*pszBuffer,lpszError);
|
|
}
|
|
else
|
|
{
|
|
status = RPC_S_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
status = RPC_S_INVALID_ARG;
|
|
}
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
status = ERROR_NOACCESS;
|
|
}
|
|
|
|
if(lpszError)
|
|
MyVirtualFree(lpszError);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------
|
|
|
|
DWORD
|
|
CReturnLicense::ExecuteJob(
|
|
IN PRETURNLICENSEWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Execute a return license work object.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
TLServerInfo ServerInfo;
|
|
TCHAR szServer[LSERVER_MAX_STRING_SIZE+2];
|
|
TLSLicenseToBeReturn ToBeReturn;
|
|
TLS_HANDLE hHandle = NULL;
|
|
DWORD dwErrCode = ERROR_SUCCESS;
|
|
|
|
// log an error
|
|
TCHAR *szErrMsg = NULL;
|
|
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s ...\n"),
|
|
GetJobDescription()
|
|
);
|
|
|
|
//-------------------------------------------------------
|
|
if(VerifyWorkObjectData(TRUE, pbData, cbData) == FALSE)
|
|
{
|
|
TLSASSERT(FALSE);
|
|
//
|
|
// this is invalid data, quitely abort operation
|
|
//
|
|
pbData->dwNumRetry = m_dwRetryTimes;
|
|
SetLastError(dwStatus = ERROR_INVALID_DATA);
|
|
goto cleanup;
|
|
}
|
|
|
|
if(IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
SetLastError(dwStatus = TLS_I_WORKMANAGER_SHUTDOWN);
|
|
goto cleanup;
|
|
}
|
|
|
|
dwStatus = TLSResolveServerIdToServer(
|
|
pbData->szTargetServerId,
|
|
sizeof(szServer),
|
|
szServer
|
|
);
|
|
|
|
if(dwStatus != ERROR_SUCCESS)
|
|
{
|
|
// Server not register with this server, try using
|
|
// whatever name we have
|
|
lstrcpy(szServer, pbData->szTargetServerName);
|
|
dwStatus = ERROR_SUCCESS;
|
|
}
|
|
|
|
ToBeReturn.dwQuantity = pbData->dwQuantity;
|
|
ToBeReturn.dwKeyPackId = pbData->dwKeyPackId;
|
|
ToBeReturn.dwLicenseId = pbData->dwLicenseId;
|
|
|
|
ToBeReturn.cbEncryptedHwid = pbData->cbEncryptedHwid;
|
|
ToBeReturn.pbEncryptedHwid = pbData->pbEncryptedHwid;
|
|
|
|
ToBeReturn.dwProductVersion = pbData->dwProductVersion;
|
|
|
|
ToBeReturn.pszOrgProductId = pbData->szOrgProductID;
|
|
ToBeReturn.pszCompanyName = pbData->szCompanyName;
|
|
ToBeReturn.pszProductId = pbData->szProductId;
|
|
ToBeReturn.pszUserName = pbData->szUserName;
|
|
ToBeReturn.pszMachineName = pbData->szMachineName;
|
|
ToBeReturn.dwPlatformID = pbData->dwPlatformId;
|
|
|
|
if(IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
SetLastError(dwStatus = TLS_I_WORKMANAGER_SHUTDOWN);
|
|
goto cleanup;
|
|
}
|
|
|
|
hHandle = TLSConnectAndEstablishTrust(szServer, NULL);
|
|
if(hHandle == NULL)
|
|
{
|
|
dwStatus = GetLastError();
|
|
// TLSLogEvent(
|
|
// EVENTLOG_WARNING_TYPE,
|
|
// TLS_W_RETURNLICENSE,
|
|
// TLS_I_CONTACTSERVER,
|
|
// szServer
|
|
// );
|
|
}
|
|
else
|
|
{
|
|
if(IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
SetLastError(dwStatus = TLS_I_WORKMANAGER_SHUTDOWN);
|
|
goto cleanup;
|
|
}
|
|
|
|
// make a RPC call to return client license
|
|
dwStatus = TLSReturnLicensedProduct(
|
|
hHandle,
|
|
&ToBeReturn,
|
|
&dwErrCode
|
|
);
|
|
|
|
if(dwStatus != ERROR_SUCCESS)
|
|
{
|
|
// retry again
|
|
// TLSLogEvent(
|
|
// EVENTLOG_WARNING_TYPE,
|
|
// TLS_W_RETURNLICENSE,
|
|
// TLS_I_CONTACTSERVER,
|
|
// szServer
|
|
// );
|
|
}
|
|
else if(dwErrCode >= LSERVER_ERROR_BASE)
|
|
{
|
|
if(dwErrCode != LSERVER_E_DATANOTFOUND && dwErrCode != LSERVER_E_INVALID_DATA)
|
|
{
|
|
DWORD status;
|
|
DWORD errCode;
|
|
|
|
status = TryGetLastError(
|
|
hHandle,
|
|
&szErrMsg,
|
|
&errCode
|
|
);
|
|
|
|
if(status == ERROR_SUCCESS)
|
|
{
|
|
TLSLogEvent(
|
|
EVENTLOG_WARNING_TYPE,
|
|
TLS_W_RETURNLICENSE,
|
|
TLS_E_RETURNLICENSE,
|
|
ToBeReturn.pszMachineName,
|
|
ToBeReturn.pszUserName,
|
|
szErrMsg,
|
|
szServer
|
|
);
|
|
|
|
MIDL_user_free(szErrMsg);
|
|
}
|
|
else
|
|
{
|
|
// server might be done at this instance,
|
|
// log an error with error code
|
|
TLSLogEvent(
|
|
EVENTLOG_WARNING_TYPE,
|
|
TLS_W_RETURNLICENSE,
|
|
TLS_E_RETURNLICENSECODE,
|
|
ToBeReturn.pszMachineName,
|
|
ToBeReturn.pszUserName,
|
|
dwErrCode,
|
|
szServer
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if(dwStatus == ERROR_SUCCESS && dwErrCode == ERROR_SUCCESS)
|
|
{
|
|
// successfully return license.
|
|
pbData->dwNumRetry = m_dwRetryTimes;
|
|
}
|
|
else if(dwErrCode == LSERVER_E_INVALID_DATA || dwErrCode == LSERVER_E_DATANOTFOUND)
|
|
{
|
|
// server might be re-installed so all database entry is gone
|
|
// delete this return license job
|
|
pbData->dwNumRetry = m_dwRetryTimes;
|
|
}
|
|
else
|
|
{
|
|
pbData->dwNumRetry++;
|
|
|
|
if(pbData->dwNumRetry >= m_dwRetryTimes)
|
|
{
|
|
TLSLogEvent(
|
|
EVENTLOG_WARNING_TYPE,
|
|
TLS_W_RETURNLICENSE,
|
|
TLS_E_RETURNLICENSETOOMANY,
|
|
ToBeReturn.pszMachineName,
|
|
ToBeReturn.pszUserName,
|
|
pbData->dwNumRetry
|
|
);
|
|
}
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if(hHandle != NULL)
|
|
{
|
|
TLSDisconnectFromServer(hHandle);
|
|
hHandle = NULL;
|
|
}
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
|
|
LPCTSTR
|
|
CReturnLicense::GetJobDescription()
|
|
/*++
|
|
|
|
Get job description, use only at debug tracing.
|
|
|
|
--*/
|
|
{
|
|
PRETURNLICENSEWO pbData = GetWorkData();
|
|
|
|
memset(m_szJobDescription, 0, sizeof(m_szJobDescription));
|
|
|
|
if(pbData)
|
|
{
|
|
_sntprintf(
|
|
m_szJobDescription,
|
|
sizeof(m_szJobDescription)/sizeof(m_szJobDescription[0]) - 1,
|
|
RETURNLICENSE_DESCRIPTION,
|
|
pbData->dwNumRetry,
|
|
pbData->dwKeyPackId,
|
|
pbData->dwLicenseId,
|
|
pbData->szTargetServerName
|
|
);
|
|
}
|
|
|
|
return m_szJobDescription;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CSsyncLicensePack
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL
|
|
CSsyncLicensePack::VerifyWorkObjectData(
|
|
IN BOOL bCallByIsValid, // invoke by IsValid() function.
|
|
IN PSSYNCLICENSEPACK pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Verify a sync. license pack work object data.
|
|
|
|
--*/
|
|
{
|
|
BOOL bSuccess = TRUE;
|
|
DWORD dwLen;
|
|
|
|
if( pbData == NULL || cbData == 0 || cbData != pbData->dwStructSize ||
|
|
(pbData->dwSyncType != SSYNC_ALL_LKP && pbData->dwSyncType != SSYNC_ONE_LKP) )
|
|
{
|
|
TLSASSERT(FALSE);
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
bSuccess = FALSE;
|
|
}
|
|
else if(bCallByIsValid == FALSE)
|
|
{
|
|
for(DWORD index =0;
|
|
index < pbData->dwNumServer && bSuccess == TRUE;
|
|
index++)
|
|
{
|
|
//
|
|
// NULL terminate string...
|
|
//
|
|
pbData->m_szTargetServer[index][MAX_COMPUTERNAME_LENGTH+1] = _TEXT('\0');
|
|
|
|
dwLen = _tcslen(pbData->m_szTargetServer[index]);
|
|
if(dwLen == 0 || dwLen >= MAX_COMPUTERNAME_LENGTH + 1)
|
|
{
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
bSuccess = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
BOOL
|
|
CSsyncLicensePack::CopyWorkObjectData(
|
|
OUT PSSYNCLICENSEPACK* ppbDest,
|
|
OUT PDWORD pcbDest,
|
|
IN PSSYNCLICENSEPACK pbSrc,
|
|
IN DWORD cbSrc
|
|
)
|
|
/*++
|
|
|
|
Copy a sync. license pack work object data.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
if(ppbDest == NULL || pcbDest == NULL)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
TLSASSERT(FALSE);
|
|
goto cleanup;
|
|
}
|
|
|
|
if(CopyBinaryData(
|
|
(PBYTE *)ppbDest,
|
|
pcbDest,
|
|
(PBYTE) pbSrc,
|
|
cbSrc
|
|
) == FALSE)
|
|
{
|
|
dwStatus = GetLastError();
|
|
}
|
|
|
|
cleanup:
|
|
|
|
return dwStatus == ERROR_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
CSsyncLicensePack::CleanupWorkObjectData(
|
|
IN OUT PSSYNCLICENSEPACK* ppbData,
|
|
IN OUT PDWORD pcbData
|
|
)
|
|
/*++
|
|
|
|
Cleanup a sync. license pack work object data.
|
|
|
|
--*/
|
|
{
|
|
if(ppbData != NULL && pcbData != NULL)
|
|
{
|
|
FreeMemory(*ppbData);
|
|
*ppbData = NULL;
|
|
*pcbData = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
CSsyncLicensePack::IsJobCompleted(
|
|
IN PSSYNCLICENSEPACK pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Detemine if Job is completed.
|
|
|
|
--*/
|
|
{
|
|
return (pbData == NULL) ? TRUE : pbData->bCompleted;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
void
|
|
_AnnounceLicensePackToServers(
|
|
IN CWorkObject* ptr,
|
|
IN PTLSLICENSEPACK pLicensePack,
|
|
IN PDWORD pdwCount,
|
|
IN TCHAR pszServerList[][MAX_COMPUTERNAME_LENGTH+2],
|
|
IN BOOL* pbSsyncStatus
|
|
)
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
Sync. a license pack to list of remote server.
|
|
|
|
Parameter:
|
|
|
|
ptr : pointer to work object that started this call.
|
|
pLicensePack : Pointer to license keypack to sync. with
|
|
list of remote server.
|
|
pdwCount : On input, number of license server to push sync,
|
|
on output, number of license server successfully sync.
|
|
pszServerList : Pointer to list of remote server.
|
|
pbSsyncStatus : Pointer to an array to receive push sync status.
|
|
|
|
Returns:
|
|
|
|
None, all error are ignored.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
TLSReplRecord record;
|
|
DWORD dwNumServer = *pdwCount;
|
|
DWORD dwIndex;
|
|
TLS_HANDLE hHandle;
|
|
RPC_STATUS rpcStatus;
|
|
BOOL fActAsEarlierVersion = FALSE;
|
|
WORD wMinorVersion, wMajorVersion;
|
|
TCHAR pszProductId[LSERVER_MAX_STRING_SIZE + 1];
|
|
|
|
*pdwCount = 0;
|
|
|
|
//
|
|
// Setup replication record
|
|
//
|
|
record.dwReplCode = REPLICATIONCODE_SYNC;
|
|
record.dwUnionType = UNION_TYPE_LICENSEPACK;
|
|
record.w.ReplLicPack = *pLicensePack;
|
|
|
|
//
|
|
// Announce to all server in the list
|
|
//
|
|
for( dwIndex = 0;
|
|
dwIndex < dwNumServer && ptr->IsWorkManagerShuttingDown() == FALSE;
|
|
dwIndex++ )
|
|
{
|
|
if(pbSsyncStatus[dwIndex] == FALSE)
|
|
{
|
|
hHandle = TLSConnectAndEstablishTrust(
|
|
pszServerList[dwIndex],
|
|
NULL
|
|
);
|
|
|
|
if(hHandle != NULL)
|
|
{
|
|
DWORD dwSupportFlags = 0;
|
|
|
|
dwStatus = TLSGetSupportFlags(
|
|
hHandle,
|
|
&dwSupportFlags
|
|
);
|
|
|
|
// License Keypack is not replicated if License server version < license Keypack version
|
|
|
|
if (((dwStatus == RPC_S_OK) && !(dwSupportFlags & SUPPORT_WHISTLER_CAL))
|
|
|| (dwStatus != RPC_S_OK))
|
|
{
|
|
// This LS doesn't support Whistler CALs
|
|
|
|
if (CompareTLSVersions(MAKELONG(pLicensePack->wMinorVersion,pLicensePack->wMajorVersion),MAKELONG(1,5)) >= 0)
|
|
{
|
|
POLICY_TS_MACHINE groupPolicy;
|
|
|
|
RegGetMachinePolicy(&groupPolicy);
|
|
|
|
//
|
|
// This is a Whistler or later CAL
|
|
//
|
|
if (groupPolicy.fPolicyPreventLicenseUpgrade
|
|
&& groupPolicy.fPreventLicenseUpgrade)
|
|
{
|
|
//
|
|
// We'll never want to issue a CAL to this LS
|
|
//
|
|
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if( _tcsnicmp(pLicensePack->szProductId,
|
|
TERMSERV_PRODUCTID_SKU,
|
|
_tcslen(TERMSERV_PRODUCTID_SKU)) == 0 )
|
|
{
|
|
//
|
|
// Per Seat
|
|
//
|
|
fActAsEarlierVersion = TRUE;
|
|
|
|
wMinorVersion = pLicensePack->wMinorVersion;
|
|
wMajorVersion = pLicensePack->wMajorVersion;
|
|
_tcscpy(pszProductId,pLicensePack->szProductId);
|
|
|
|
pLicensePack->wMajorVersion = 5;
|
|
pLicensePack->wMinorVersion = 0;
|
|
_tcscpy(pLicensePack->szProductId,_T("A02-5.00-S"));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// never replicate if it isn't per-seat
|
|
//
|
|
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
rpcStatus = TLSAnnounceLicensePack(
|
|
hHandle,
|
|
&record,
|
|
&dwStatus
|
|
);
|
|
if (fActAsEarlierVersion)
|
|
{
|
|
// Put it back to the original values
|
|
|
|
pLicensePack->wMajorVersion = wMajorVersion;
|
|
pLicensePack->wMinorVersion = wMinorVersion;
|
|
_tcscpy(pLicensePack->szProductId,pszProductId);
|
|
}
|
|
|
|
|
|
if(rpcStatus != RPC_S_OK)
|
|
{
|
|
// this server might be down, mark it so that
|
|
// we don't retry again
|
|
pbSsyncStatus[dwIndex] = TRUE;
|
|
}
|
|
else if(dwStatus == LSERVER_E_SERVER_BUSY)
|
|
{
|
|
// retry only when server return busy status
|
|
pbSsyncStatus[dwIndex] = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// any error, just don't bother trying again
|
|
pbSsyncStatus[dwIndex] = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// server is not available, don't ssync again
|
|
pbSsyncStatus[dwIndex] = TRUE;
|
|
}
|
|
|
|
if(hHandle != NULL)
|
|
{
|
|
TLSDisconnectFromServer(hHandle);
|
|
hHandle = NULL;
|
|
}
|
|
}
|
|
|
|
if(pbSsyncStatus[dwIndex] == TRUE)
|
|
{
|
|
(*pdwCount)++;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
DWORD
|
|
_SsyncOneLocalLicensePack(
|
|
IN CSsyncLicensePack* ptr,
|
|
IN PSSYNCLICENSEPACK pSsyncLkp
|
|
)
|
|
/*++
|
|
|
|
Abstract:
|
|
|
|
Sync. one license pack to one remote server.
|
|
|
|
Parameter:
|
|
|
|
Ptr : Pointer to CSsyncLicensePack work object.
|
|
pSsyncLkp : Pinter to PSSYNCLICENSEPACK.
|
|
|
|
Returns:
|
|
|
|
ERROR_SUCCESS or error code.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
PTLSDbWorkSpace pDbWkSpace = NULL;
|
|
TLSLICENSEPACK LicensePackSearch;
|
|
TLSLICENSEPACK LicensePack;
|
|
DWORD dwSuccessCount = 0;
|
|
|
|
//
|
|
// Allocate DB Work Space.
|
|
//
|
|
pDbWkSpace = AllocateWorkSpace(SSYNC_DBWORKSPACE_TIMEOUT);
|
|
if(pDbWkSpace == NULL)
|
|
{
|
|
SetLastError(dwStatus = TLS_I_SSYNCLKP_SERVER_BUSY);
|
|
TLSLogInfoEvent(TLS_I_SSYNCLKP_SERVER_BUSY);
|
|
goto cleanup;
|
|
}
|
|
|
|
LicensePackSearch.dwKeyPackId = pSsyncLkp->dwKeyPackId;
|
|
|
|
//
|
|
// retrieve license pack
|
|
//
|
|
dwStatus = TLSDBKeyPackFind(
|
|
pDbWkSpace,
|
|
TRUE,
|
|
LICENSEDPACK_PROCESS_DWINTERNAL,
|
|
&LicensePackSearch,
|
|
&LicensePack
|
|
);
|
|
|
|
if(dwStatus != ERROR_SUCCESS)
|
|
{
|
|
if(dwStatus != TLS_E_RECORD_NOTFOUND)
|
|
{
|
|
TLSLogEvent(
|
|
EVENTLOG_INFORMATION_TYPE,
|
|
TLS_W_SSYNCLKP,
|
|
dwStatus
|
|
);
|
|
}
|
|
|
|
goto cleanup;
|
|
}
|
|
|
|
if(IsLicensePackRepl(&LicensePack) == FALSE)
|
|
{
|
|
goto cleanup;
|
|
}
|
|
|
|
if(ptr->IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
SetLastError(dwStatus = TLS_I_SERVICE_STOP);
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Make sure local Server ID and Server Name is correct
|
|
//
|
|
SAFESTRCPY(LicensePack.szInstallId, pSsyncLkp->m_szServerId);
|
|
SAFESTRCPY(LicensePack.szTlsServerName, pSsyncLkp->m_szServerName);
|
|
|
|
dwSuccessCount = pSsyncLkp->dwNumServer;
|
|
_AnnounceLicensePackToServers(
|
|
ptr,
|
|
&LicensePack,
|
|
&dwSuccessCount,
|
|
pSsyncLkp->m_szTargetServer,
|
|
pSsyncLkp->m_bSsync
|
|
);
|
|
|
|
if(dwSuccessCount != pSsyncLkp->dwNumServer)
|
|
{
|
|
TLSLogInfoEvent(TLS_I_SSYNCLKP_FAILED);
|
|
}
|
|
|
|
cleanup:
|
|
|
|
if(pDbWkSpace != NULL)
|
|
{
|
|
ReleaseWorkSpace(&pDbWkSpace);
|
|
}
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
DWORD
|
|
_SsyncAllLocalLicensePack(
|
|
IN CSsyncLicensePack* ptr,
|
|
IN PSSYNCLICENSEPACK pSsyncLkp
|
|
)
|
|
/*++
|
|
|
|
Sync. all local license pack to a remote server.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
PTLSDbWorkSpace pDbWkSpace = NULL;
|
|
TLSLICENSEPACK LicensePackSearch;
|
|
TLSLICENSEPACK LicensePack;
|
|
DWORD dwSuccessCount = 0;
|
|
BOOL SyncStatus[SSYNCLKP_MAX_TARGET];
|
|
|
|
//
|
|
// Allocate DB Work Space.
|
|
//
|
|
pDbWkSpace = AllocateWorkSpace(SSYNC_DBWORKSPACE_TIMEOUT);
|
|
if(pDbWkSpace == NULL)
|
|
{
|
|
SetLastError(dwStatus = TLS_I_SSYNCLKP_SERVER_BUSY);
|
|
TLSLogInfoEvent(TLS_I_SSYNCLKP_SERVER_BUSY);
|
|
goto cleanup;
|
|
}
|
|
|
|
dwStatus = TLSDBKeyPackEnumBegin(
|
|
pDbWkSpace,
|
|
FALSE,
|
|
0,
|
|
NULL
|
|
);
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
while((dwStatus = TLSDBKeyPackEnumNext(pDbWkSpace, &LicensePack)) == ERROR_SUCCESS)
|
|
{
|
|
// unreliable, system time between two machine might not work,
|
|
// force sync and let remote server update its data.
|
|
if(CompareFileTime(
|
|
&LicensePack.ftLastModifyTime,
|
|
&ptr->GetWorkData()->m_ftStartSyncTime
|
|
) < 0)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if(ptr->IsWorkManagerShuttingDown() == TRUE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if(IsLicensePackRepl(&LicensePack) == FALSE)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Make sure local Server ID and Server Name is correct
|
|
//
|
|
SAFESTRCPY(LicensePack.szInstallId, pSsyncLkp->m_szServerId);
|
|
SAFESTRCPY(LicensePack.szTlsServerName, pSsyncLkp->m_szServerName);
|
|
memset(SyncStatus, 0, sizeof(SyncStatus));
|
|
|
|
dwSuccessCount = pSsyncLkp->dwNumServer;
|
|
_AnnounceLicensePackToServers(
|
|
ptr,
|
|
&LicensePack,
|
|
&dwSuccessCount,
|
|
pSsyncLkp->m_szTargetServer,
|
|
SyncStatus
|
|
);
|
|
}
|
|
|
|
TLSDBKeyPackEnumEnd(pDbWkSpace);
|
|
}
|
|
|
|
//
|
|
// ignore all error
|
|
//
|
|
dwStatus = ERROR_SUCCESS;
|
|
cleanup:
|
|
|
|
if(pDbWkSpace != NULL)
|
|
{
|
|
ReleaseWorkSpace(&pDbWkSpace);
|
|
}
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD
|
|
CSsyncLicensePack::ExecuteJob(
|
|
IN PSSYNCLICENSEPACK pSsyncLkp,
|
|
IN DWORD cbSsyncLkp
|
|
)
|
|
/*++
|
|
|
|
Execute a CSsyncLicensePack work object.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s ...\n"),
|
|
GetJobDescription()
|
|
);
|
|
|
|
TLSASSERT(pSsyncLkp != NULL && cbSsyncLkp != 0);
|
|
if(VerifyWorkObjectData(FALSE, pSsyncLkp, cbSsyncLkp) == FALSE)
|
|
{
|
|
TLSASSERT(FALSE);
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
pSsyncLkp->bCompleted = TRUE;
|
|
return ERROR_INVALID_DATA;
|
|
}
|
|
|
|
if(pSsyncLkp->dwSyncType == SSYNC_ONE_LKP)
|
|
{
|
|
dwStatus = _SsyncOneLocalLicensePack(this, pSsyncLkp);
|
|
}
|
|
else
|
|
{
|
|
dwStatus = _SsyncAllLocalLicensePack(this, pSsyncLkp);
|
|
}
|
|
|
|
if(dwStatus == TLS_I_SSYNCLKP_SERVER_BUSY || dwStatus == TLS_I_SSYNCLKP_FAILED)
|
|
{
|
|
// retry operation
|
|
pSsyncLkp->bCompleted = FALSE;
|
|
}
|
|
else
|
|
{
|
|
pSsyncLkp->bCompleted = TRUE;
|
|
}
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s ended...\n"),
|
|
GetJobDescription()
|
|
);
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------
|
|
LPCTSTR
|
|
CSsyncLicensePack::GetJobDescription()
|
|
/*++
|
|
|
|
Get CSsyncLicensePack job description, use only
|
|
by debug tracing.
|
|
|
|
--*/
|
|
{
|
|
PSSYNCLICENSEPACK pbData = GetWorkData();
|
|
memset(m_szJobDescription, 0, sizeof(m_szJobDescription));
|
|
|
|
if(pbData != NULL)
|
|
{
|
|
_sntprintf(
|
|
m_szJobDescription,
|
|
sizeof(m_szJobDescription)/sizeof(m_szJobDescription[0]) - 1,
|
|
SSYNCLICENSEKEYPACK_DESCRIPTION,
|
|
(pbData->dwSyncType == SSYNC_ALL_LKP) ? _TEXT("ALL") : _TEXT("One"),
|
|
pbData->m_szTargetServer
|
|
);
|
|
}
|
|
|
|
return m_szJobDescription;
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CAnnounceResponse
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
BOOL
|
|
CAnnounceResponse::VerifyWorkObjectData(
|
|
IN BOOL bCallByIsValid, // invoke by IsValid() function.
|
|
IN PANNOUNCERESPONSEWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Verify CAnnounceResponse work object data.
|
|
|
|
--*/
|
|
{
|
|
BOOL bSuccess = TRUE;
|
|
DWORD dwLen;
|
|
|
|
if(pbData == NULL || cbData == 0 || cbData != pbData->dwStructSize)
|
|
{
|
|
bSuccess = FALSE;
|
|
}
|
|
|
|
if(bSuccess == TRUE)
|
|
{
|
|
pbData->m_szTargetServerId[LSERVER_MAX_STRING_SIZE+1] = _TEXT('\0');
|
|
dwLen = _tcslen(pbData->m_szTargetServerId);
|
|
if(dwLen == 0 || dwLen >= LSERVER_MAX_STRING_SIZE + 1)
|
|
{
|
|
bSuccess = FALSE;
|
|
}
|
|
}
|
|
|
|
if(bSuccess == FALSE)
|
|
{
|
|
TLSASSERT(FALSE);
|
|
SetLastError(ERROR_INVALID_DATA);
|
|
}
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceResponse::CopyWorkObjectData(
|
|
OUT PANNOUNCERESPONSEWO* ppbDest,
|
|
OUT PDWORD pcbDest,
|
|
IN PANNOUNCERESPONSEWO pbSrc,
|
|
IN DWORD cbSrc
|
|
)
|
|
/*++
|
|
|
|
Copy CAnnounceResponse work object data.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
|
|
if(ppbDest == NULL || pcbDest == NULL)
|
|
{
|
|
SetLastError(dwStatus = ERROR_INVALID_PARAMETER);
|
|
TLSASSERT(FALSE);
|
|
goto cleanup;
|
|
}
|
|
|
|
if(CopyBinaryData(
|
|
(PBYTE *)ppbDest,
|
|
pcbDest,
|
|
(PBYTE) pbSrc,
|
|
cbSrc
|
|
) == FALSE)
|
|
{
|
|
dwStatus = GetLastError();
|
|
}
|
|
|
|
cleanup:
|
|
|
|
return dwStatus == ERROR_SUCCESS;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceResponse::CleanupWorkObjectData(
|
|
IN OUT PANNOUNCERESPONSEWO* ppbData,
|
|
IN OUT PDWORD pcbData
|
|
)
|
|
/*++
|
|
|
|
cleanup CAnnounceResponse work object data.
|
|
|
|
--*/
|
|
{
|
|
if(ppbData != NULL && pcbData != NULL)
|
|
{
|
|
FreeMemory(*ppbData);
|
|
*ppbData = NULL;
|
|
*pcbData = 0;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
BOOL
|
|
CAnnounceResponse::IsJobCompleted(
|
|
IN PANNOUNCERESPONSEWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Detemine if job completed.
|
|
|
|
--*/
|
|
{
|
|
return (pbData == NULL) ? TRUE : pbData->bCompleted;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
DWORD
|
|
CAnnounceResponse::ExecuteJob(
|
|
IN PANNOUNCERESPONSEWO pbData,
|
|
IN DWORD cbData
|
|
)
|
|
/*++
|
|
|
|
Execute a CAnnounceResponse work object.
|
|
|
|
--*/
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
TLS_HANDLE hHandle = NULL;
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s ...\n"),
|
|
GetJobDescription()
|
|
);
|
|
|
|
TLServerInfo ServerInfo;
|
|
|
|
dwStatus = TLSLookupRegisteredServer(
|
|
pbData->m_szTargetServerId,
|
|
NULL,
|
|
NULL,
|
|
&ServerInfo
|
|
);
|
|
|
|
if(dwStatus == ERROR_SUCCESS)
|
|
{
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_DETAILSIMPLE,
|
|
_TEXT("Announcing server to %s...\n"),
|
|
ServerInfo.GetServerName()
|
|
);
|
|
|
|
if(IsWorkManagerShuttingDown() == FALSE)
|
|
{
|
|
dwStatus = TLSAnnounceServerToRemoteServer(
|
|
TLSANNOUNCE_TYPE_RESPONSE,
|
|
ServerInfo.GetServerId(),
|
|
ServerInfo.GetServerDomain(),
|
|
ServerInfo.GetServerName(),
|
|
pbData->m_szLocalServerId,
|
|
pbData->m_szLocalScope,
|
|
pbData->m_szLocalServerName,
|
|
&(pbData->m_ftLastShutdownTime)
|
|
);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TLSASSERT(FALSE);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Discovery run once
|
|
//
|
|
pbData->bCompleted = TRUE;
|
|
|
|
DBGPrintf(
|
|
DBG_INFORMATION,
|
|
DBG_FACILITY_JOB,
|
|
DBGLEVEL_FUNCTION_TRACE,
|
|
_TEXT("%s ended...\n"),
|
|
GetJobDescription()
|
|
);
|
|
|
|
return dwStatus;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------------------
|
|
LPCTSTR
|
|
CAnnounceResponse::GetJobDescription()
|
|
/*++
|
|
|
|
Retrieve CAnnounceResponse job description.
|
|
|
|
--*/
|
|
{
|
|
memset(m_szJobDescription, 0, sizeof(m_szJobDescription));
|
|
PANNOUNCERESPONSEWO pbData = GetWorkData();
|
|
|
|
if(pbData != NULL)
|
|
{
|
|
_sntprintf(
|
|
m_szJobDescription,
|
|
sizeof(m_szJobDescription)/sizeof(m_szJobDescription[0]) - 1,
|
|
ANNOUNCERESPONSE_DESCRIPTION,
|
|
pbData->m_szTargetServerId
|
|
);
|
|
}
|
|
|
|
return m_szJobDescription;
|
|
}
|