DWORD
EventLogServerAddEvent(
DWORD eventID,
DWORD eventType,
RP_PWSTR pszMessage
)
{
DWORD dwError = 0;
EVENTLOG_DB_EVENT_ENTRY entry;
HEVENTLOG_DB hEventLogDb = NULL;
dwError = EventLogDbCreateContext(&hEventLogDb);
BAIL_ON_VMEVENT_ERROR(dwError);
entry.pwszEventMessage = pszMessage;
entry.pwszEventDesc = NULL;
entry.dwID = eventID;
dwError = EventLogDbAddEvent(hEventLogDb, &entry);
BAIL_ON_VMEVENT_ERROR(dwError);
cleanup:
if (hEventLogDb)
{
EventLogDbReleaseContext(hEventLogDb);
}
return dwError;
error:
goto cleanup;
}
DWORD
EventLogAllocateMemory(
DWORD dwSize,
PVOID * ppMemory
)
{
DWORD dwError = 0;
void* pMemory = NULL;
if (!ppMemory || !dwSize)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMEVENT_ERROR(dwError);
}
pMemory = calloc(1, dwSize);
if (!pMemory)
{
dwError = ENOMEM;
BAIL_ON_VMEVENT_ERROR(dwError);
}
cleanup:
*ppMemory = pMemory;
return dwError;
error:
VMEVENT_SAFE_FREE_MEMORY(pMemory);
pMemory = NULL;
goto cleanup;
}
static
DWORD
InitializeRPCServer(
VOID
)
{
DWORD dwError = 0;
dwError = EventLogStartRpcServer();
BAIL_ON_VMEVENT_ERROR(dwError);
dwError = LwMapErrnoToLwError(
dcethread_create(
&gEventLogServerGlobals.pRPCServerThread,
NULL,
EventLogListenRpcServer,
NULL));
BAIL_ON_VMEVENT_ERROR(dwError);
while (!EventLogCheckRPCServerIsActive())
{
// Wait for RPC Server to come up.
}
error:
return dwError;
}
static
VOID
EventLogShutdownRPCServer(
VOID
)
{
DWORD dwError = 0;
dwError = EventLogStopRpcServer();
BAIL_ON_VMEVENT_ERROR(dwError);
if (gEventLogServerGlobals.pRPCServerThread)
{
dwError = LwMapErrnoToLwError(
dcethread_interrupt(
gEventLogServerGlobals.pRPCServerThread));
BAIL_ON_VMEVENT_ERROR(dwError);
dwError = LwMapErrnoToLwError(
dcethread_join(
gEventLogServerGlobals.pRPCServerThread,
NULL));
BAIL_ON_VMEVENT_ERROR(dwError);
gEventLogServerGlobals.pRPCServerThread = NULL;
}
error:
return;
}
DWORD
EventLogCloneEventContainerFromDbEventEntryArray(
PEVENTLOG_DB_EVENT_ENTRY pDbPackageEntryArray,
DWORD dwDbPackageEntryNums,
PEVENTLOG_CONTAINER *ppPkgContainer
)
{
DWORD dwError = 0;
PEVENTLOG_CONTAINER pContainer = NULL;
dwError = EventLogAllocateMemory(sizeof(*pContainer), (PVOID*)&pContainer);
BAIL_ON_VMEVENT_ERROR(dwError);
pContainer->dwCount = dwDbPackageEntryNums;
if (pContainer->dwCount > 0)
{
DWORD iEntry = 0;
dwError = EventLogAllocateMemory(
pContainer->dwCount *
sizeof(pContainer->pPkgEntries[0]),
(PVOID*)&pContainer->pPkgEntries);
BAIL_ON_VMEVENT_ERROR(dwError);
for (; iEntry < pContainer->dwCount; iEntry++)
{
PEVENTLOG_DB_EVENT_ENTRY pDbPkgEntrySrc =
&pDbPackageEntryArray[iEntry];
PEVENTLOG_ENTRY pPkgEntryDst =
&pContainer->pPkgEntries[iEntry];
dwError = EventLogCloneEventEntryContentsFromDbEventEntry(
pDbPkgEntrySrc,
pPkgEntryDst
);
BAIL_ON_VMEVENT_ERROR(dwError);
}
}
*ppPkgContainer = pContainer;
cleanup:
return dwError;
error:
*ppPkgContainer = NULL;
if (pContainer)
{
EventLogFreeEventContainer(pContainer);
}
goto cleanup;
}
DWORD
EventLogInitialize(
)
{
DWORD dwError = 0;
dwError = InitializeDatabase();
BAIL_ON_VMEVENT_ERROR(dwError);
#ifndef _WIN32
// Construct SD for the EventLog-Service resources (to be access controlled)
dwError = ConstructSDForEventLogServ(
&gEventLogServerGlobals.gSecurityDescriptor
);
BAIL_ON_VMEVENT_ERROR(dwError);
#endif
// dwError = EventLogRPCInit();
// BAIL_ON_VMEVENT_ERROR(dwError);
error:
return dwError;
}
DWORD
EventLogRPCInit(
VOID
)
{
DWORD dwError = 0;
dwError = InitializeRPCServer();
BAIL_ON_VMEVENT_ERROR(dwError);
error:
return dwError;
}
static
DWORD
InitializeDatabase(
VOID
)
{
DWORD dwError = 0;
#ifndef _WIN32
PSTR pszDefaultEventLogDbPath = "/storage/db/vmware-vmafd/vmevent/vmevent.db";
#else
PSTR pszDefaultEventLogDbPath = "C:\\ProgramData\\VMware\\CIS\\data\\vmafdd\\vmevent.db";
#endif
dwError = EventLogDbInitialize(pszDefaultEventLogDbPath);
BAIL_ON_VMEVENT_ERROR(dwError);
error:
return dwError;
}
DWORD
EventLogAllocateStringA(
PCSTR pszString,
PSTR * ppszString
)
{
DWORD dwError = 0;
PSTR pszNewString = NULL;
DWORD dwLen = 0;
if (!pszString || !ppszString)
{
if (ppszString) { *ppszString = NULL; }
return 0;
}
dwLen = EventLogStringLenA(pszString);
// + 1 for \'0'
dwError = EventLogAllocateMemory(dwLen + 1, (PVOID*)&pszNewString);
BAIL_ON_VMEVENT_ERROR(dwError);
#ifndef _WIN32
memcpy(pszNewString, pszString, dwLen);
#else
memcpy_s(pszNewString, (dwLen + 1), pszString, dwLen);
#endif
*ppszString = pszNewString;
cleanup:
return dwError;
error:
VMEVENT_SAFE_FREE_MEMORY(pszNewString);
goto cleanup;
}
static
BOOLEAN
EventLogCheckRPCServerIsActive(
VOID
)
{
volatile DWORD dwError = 0;
BOOLEAN bIsActive = FALSE;
DCETHREAD_TRY
{
bIsActive = rpc_mgmt_is_server_listening(NULL, (unsigned32*)&dwError);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
if (!dwError)
{
dwError = dcethread_exc_getstatus (THIS_CATCH);
}
if (!dwError)
{
dwError = RPC_S_INTERNAL_ERROR;
}
}
DCETHREAD_ENDTRY;
BAIL_ON_VMEVENT_ERROR(dwError);
cleanup:
return bIsActive;
error:
bIsActive = FALSE;
goto cleanup;
}
DWORD
EventLogGetHostName(
PSTR* ppszHostName
)
{
DWORD dwError = ERROR_SUCCESS;
char hostBuf[HOST_NAME_MAX];
DWORD dwBufLen = sizeof(hostBuf) - 1;
PSTR pszHostName = NULL;
if (gethostname(hostBuf, dwBufLen) < 0)
{
dwError = LwErrnoToWin32Error(errno);
}
dwError = EventLogAllocateStringA(hostBuf, &pszHostName);
BAIL_ON_VMEVENT_ERROR(dwError);
*ppszHostName = pszHostName;
error:
return dwError;
}
DWORD
EventLogServerEnumEvents(
DWORD dwHandle,
DWORD dwStartIndex,
DWORD dwNumPackages,
PEVENTLOG_CONTAINER * ppPkgContainer
)
{
DWORD dwError = 0;
PEVENTLOG_CONTAINER pPkgContainer = NULL;
PEVENTLOG_DB_EVENT_ENTRY pDbPackageEntryArray = NULL;
DWORD dwDbPackageEntryNums = 0;
HEVENTLOG_DB hEventLogDb = NULL;
dwError = EventLogDbCreateContext(&hEventLogDb);
BAIL_ON_VMEVENT_ERROR(dwError);
// check the version
if ((dwNumPackages > 0) &&
(dwHandle != EventLogGetApplicationVersion()))
{
dwError = ERROR_INVALID_HANDLE;
BAIL_ON_VMEVENT_ERROR(dwError);
}
dwError = EventLogDbEnumEvents(
hEventLogDb,
dwStartIndex,
dwNumPackages,
&pDbPackageEntryArray,
TRUE,
&dwDbPackageEntryNums);
BAIL_ON_VMEVENT_ERROR(dwError);
// convert db struct into rpc struct ...
dwError = EventLogCloneEventContainerFromDbEventEntryArray(
pDbPackageEntryArray,
dwDbPackageEntryNums,
&pPkgContainer);
BAIL_ON_VMEVENT_ERROR(dwError);
*ppPkgContainer = pPkgContainer;
cleanup:
if (hEventLogDb)
{
EventLogDbReleaseContext(hEventLogDb);
}
if (pDbPackageEntryArray)
{
EventLogDbFreeEventEntryArray(pDbPackageEntryArray, dwDbPackageEntryNums);
}
return dwError;
error:
*ppPkgContainer = NULL;
if (pPkgContainer)
{
EventLogFreeEventContainer(pPkgContainer);
}
goto cleanup;
}
