archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
3 Commits
1 Branch
0 Tags
4.9 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/net/layer2svc/zeroconf/server/rpcsrv.c

849 lines
23 KiB
Raw Blame History

#include <precomp.h>
#include "wzcsvc.h"
#include "tracing.h"
#include "utils.h"
#include "intflist.h"
#include "rpcsrv.h"
#include "database.h"
extern HASH sessionHash;
//-------------------------------------------------
// Globals used for the RPC interface
BOOL g_bRpcStarted = FALSE;
PSECURITY_DESCRIPTOR g_pSecurityDescr = NULL;
GENERIC_MAPPING g_Mapping = {
WZC_READ,
WZC_WRITE,
WZC_EXECUTE,
WZC_ALL_ACCESS};
//-------------------------------------------------
// Initialize the security settings for the RPC API
DWORD
WZCSvcInitRPCSecurity()
{
DWORD dwErr = ERROR_SUCCESS;
NTSTATUS ntStatus;
ACE_DATA AceData[6] = {
{ACCESS_ALLOWED_ACE_TYPE, 0, 0, WZC_ACCESS_SET|WZC_ACCESS_QUERY, &LocalSystemSid},
{ACCESS_ALLOWED_ACE_TYPE, 0, 0, WZC_ACCESS_SET|WZC_ACCESS_QUERY, &AliasAdminsSid},
{ACCESS_ALLOWED_ACE_TYPE, 0, 0, WZC_ACCESS_SET|WZC_ACCESS_QUERY, &AliasAccountOpsSid},
{ACCESS_ALLOWED_ACE_TYPE, 0, 0, WZC_ACCESS_SET|WZC_ACCESS_QUERY, &AliasSystemOpsSid},
{ACCESS_ALLOWED_ACE_TYPE, 0, 0, WZC_ACCESS_SET|WZC_ACCESS_QUERY, &AliasUsersSid},
// for now (WinXP Client RTM) the decision was made to let everybody party, but based on
// the acl below. Later, the security schema won't change by default, but support will be
// added allowing admins to tighten up the access to the service RPC APIs.
{ACCESS_ALLOWED_ACE_TYPE, 0, 0, WZC_ACCESS_SET|WZC_ACCESS_QUERY, &WorldSid}};
DbgPrint((TRC_TRACK, "[WZCSvcInitRPCSecurity"));
// create the well known SIDs;
dwErr = RtlNtStatusToDosError(
NetpCreateWellKnownSids(NULL)
);
DbgAssert((dwErr == ERROR_SUCCESS, "Error %d creating the well known Sids!", dwErr));
// create the security object.
if (dwErr == ERROR_SUCCESS)
{
dwErr = RtlNtStatusToDosError(
NetpCreateSecurityObject(
AceData,
sizeof(AceData)/sizeof(ACE_DATA),
NULL,
NULL,
&g_Mapping,
&g_pSecurityDescr)
);
DbgAssert((dwErr == ERROR_SUCCESS, "Error %d creating the global security object!", dwErr));
}
DbgPrint((TRC_TRACK, "WZCSvcInitRPCSecurity]=%d", dwErr));
return dwErr;
}
//-------------------------------------------------
// Check the access for the particular access mask provided
DWORD
WZCSvcCheckRPCAccess(DWORD dwAccess)
{
DWORD dwErr = ERROR_SUCCESS;
if (g_pSecurityDescr != NULL)
{
dwErr = NetpAccessCheckAndAudit(
_T("WZCSVC"),
_T("WZCSVC"),
g_pSecurityDescr,
dwAccess,
&g_Mapping);
DbgPrint((TRC_GENERIC, ">>> Security check reports err=%d.", dwErr));
}
return dwErr;
}
//-------------------------------------------------
// Check the validity of a RAW_DATA pointer
DWORD
WZCSvcCheckParamRawData(PRAW_DATA prd)
{
DWORD dwErr = ERROR_SUCCESS;
if (prd != NULL)
{
if (prd->dwDataLen != 0 && prd->pData == NULL)
dwErr = ERROR_INVALID_PARAMETER;
}
return dwErr;
}
//-------------------------------------------------
// Check the validity of an SSID embedded in a RAW_DATA pointer
DWORD
WZCSvcCheckSSID(PNDIS_802_11_SSID pndSSID, UINT nBytes)
{
DWORD dwErr = ERROR_SUCCESS;
if (pndSSID != NULL)
{
if (nBytes < FIELD_OFFSET(NDIS_802_11_SSID, Ssid) ||
pndSSID->SsidLength > nBytes - FIELD_OFFSET(NDIS_802_11_SSID, Ssid))
dwErr = ERROR_INVALID_PARAMETER;
}
return dwErr;
}
//-------------------------------------------------
// Check the validity of a list of configurations embedded in a RAW_DATA pointer
DWORD
WZCSvcCheckConfig(PWZC_WLAN_CONFIG pwzcConfig, UINT nBytes)
{
DWORD dwErr = ERROR_SUCCESS;
if (pwzcConfig != NULL)
{
if (pwzcConfig->Length > nBytes ||
pwzcConfig->Length != sizeof(WZC_WLAN_CONFIG))
dwErr = ERROR_INVALID_PARAMETER;
if (dwErr == ERROR_SUCCESS)
dwErr = WZCSvcCheckSSID(&pwzcConfig->Ssid, sizeof(NDIS_802_11_SSID));
if (dwErr == ERROR_SUCCESS &&
pwzcConfig->KeyLength > WZCCTL_MAX_WEPK_MATERIAL)
dwErr = ERROR_INVALID_PARAMETER;
}
return dwErr;
}
//-------------------------------------------------
// Check the validity of a list of configurations embedded in a RAW_DATA pointer
DWORD
WZCSvcCheckConfigList(PWZC_802_11_CONFIG_LIST pwzcList, UINT nBytes)
{
DWORD dwErr = ERROR_SUCCESS;
if (pwzcList != NULL)
{
UINT i;
if (nBytes < FIELD_OFFSET(WZC_802_11_CONFIG_LIST, Config))
dwErr = ERROR_INVALID_PARAMETER;
nBytes -= FIELD_OFFSET(WZC_802_11_CONFIG_LIST, Config);
if (dwErr == ERROR_SUCCESS &&
((pwzcList->NumberOfItems * sizeof(WZC_WLAN_CONFIG) > nBytes) ||
(pwzcList->Index > pwzcList->NumberOfItems)
)
)
dwErr = ERROR_INVALID_PARAMETER;
for (i = 0; i < pwzcList->NumberOfItems && dwErr == ERROR_SUCCESS; i++)
dwErr = WZCSvcCheckConfig(&(pwzcList->Config[i]), sizeof(WZC_WLAN_CONFIG));
}
return dwErr;
}
//-------------------------------------------------
// Check the validity of the "input" fields from the INTF_ENTRY.
DWORD
WZCSvcCheckParamIntfEntry(PINTF_ENTRY pIntfEntry)
{
DWORD dwErr = ERROR_SUCCESS;
if (pIntfEntry != NULL)
{
if (dwErr == ERROR_SUCCESS)
dwErr = WZCSvcCheckParamRawData(&pIntfEntry->rdSSID);
if (dwErr == ERROR_SUCCESS)
dwErr = WZCSvcCheckParamRawData(&pIntfEntry->rdBSSID);
if (dwErr == ERROR_SUCCESS)
dwErr = WZCSvcCheckParamRawData(&pIntfEntry->rdStSSIDList);
if (dwErr == ERROR_SUCCESS)
dwErr = WZCSvcCheckConfigList(
(PWZC_802_11_CONFIG_LIST)pIntfEntry->rdStSSIDList.pData,
pIntfEntry->rdStSSIDList.dwDataLen);
if (dwErr == ERROR_SUCCESS)
dwErr = WZCSvcCheckParamRawData(&pIntfEntry->rdCtrlData);
}
return dwErr;
}
//-------------------------------------------------
// Cleanup whatever data was used for RPC security settings
DWORD
WZCSvcTermRPCSecurity()
{
DWORD dwErr = ERROR_SUCCESS;
DbgPrint((TRC_TRACK, "[WZCSvcTermRPCSecurity"));
dwErr = RtlNtStatusToDosError(NetpDeleteSecurityObject(&g_pSecurityDescr));
DbgAssert((dwErr == ERROR_SUCCESS, "Failed to delete the global security descriptor!"));
g_pSecurityDescr = NULL;
NetpFreeWellKnownSids();
DbgPrint((TRC_TRACK, "WZCSvcTermRPCSecurity]=%d", dwErr));
return dwErr;
}
RPC_STATUS CallbackCheckLocal(
IN RPC_IF_HANDLE *Interface,
IN void *Context)
{
RPC_STATUS rpcStat = RPC_S_OK;
LPTSTR pBinding = NULL;
LPTSTR pProtSeq = NULL;
rpcStat = RpcBindingToStringBinding(Context, &pBinding);
if (rpcStat == RPC_S_OK)
{
rpcStat = RpcStringBindingParse(
pBinding,
NULL,
&pProtSeq,
NULL,
NULL,
NULL);
}
if (rpcStat == RPC_S_OK)
{
if (_tcsicmp((LPCTSTR)pProtSeq, _T("ncalrpc")) != 0)
rpcStat = RPC_S_ACCESS_DENIED;
}
if (pBinding != NULL)
RpcStringFree(&pBinding);
if (pProtSeq != NULL)
RpcStringFree(&pProtSeq);
return rpcStat;
}
DWORD
WZCSvcStartRPCServer()
{
DWORD dwStatus = RPC_S_OK;
DbgPrint((TRC_TRACK, "[WZCSvcStartRPCServer"));
if (dwStatus == RPC_S_OK)
{
dwStatus = RpcServerUseProtseqEp(
L"ncalrpc",
10,
L"wzcsvc",
NULL);
if (dwStatus == RPC_S_DUPLICATE_ENDPOINT)
dwStatus = RPC_S_OK;
}
if (dwStatus == RPC_S_OK)
{
dwStatus = RpcServerRegisterIfEx(
winwzc_ServerIfHandle,
0,
0,
RPC_IF_ALLOW_SECURE_ONLY, // WZCSAPI is using RPC_C_PROTECT_LEVEL_PKT_PRIVACY
0, // ignored for non auto-listen interfaces
CallbackCheckLocal);
}
if (dwStatus == RPC_S_OK)
{
dwStatus = RpcServerRegisterAuthInfo(
0,
RPC_C_AUTHN_WINNT,
0,
0);
}
if (dwStatus == RPC_S_OK)
{
dwStatus = RpcServerRegisterAuthInfo(
0,
RPC_C_AUTHN_GSS_KERBEROS,
0,
0);
}
if (dwStatus == RPC_S_OK)
{
dwStatus = RpcServerRegisterAuthInfo(
0,
RPC_C_AUTHN_GSS_NEGOTIATE,
0,
0);
}
if (dwStatus == RPC_S_OK)
{
dwStatus = RpcServerListen(
3,
RPC_C_LISTEN_MAX_CALLS_DEFAULT,
TRUE);
if (dwStatus == RPC_S_ALREADY_LISTENING)
dwStatus = RPC_S_OK;
}
if (dwStatus != RPC_S_OK)
{
RpcServerUnregisterIfEx(
winwzc_ServerIfHandle,
0,
0);
}
g_bRpcStarted = (dwStatus == RPC_S_OK);
WZCSvcInitRPCSecurity();
DbgPrint((TRC_TRACK, "WZCSvcStartRPCServer]=%d", dwStatus));
return (dwStatus);
}
DWORD
WZCSvcStopRPCServer()
{
DWORD dwStatus = RPC_S_OK;
DbgPrint((TRC_TRACK, "[WZCSvcStopRPCServer"));
if (g_bRpcStarted)
{
g_bRpcStarted = FALSE;
WZCSvcTermRPCSecurity();
dwStatus = RpcServerUnregisterIfEx(
winwzc_ServerIfHandle,
0,
0);
// don't stop RPC from listening - other services could rely on this
//RpcMgmtStopServerListening(0);
}
DbgPrint((TRC_TRACK, "WZCSvcStopRPCServer]=%d", dwStatus));
return (dwStatus);
}
DWORD
RpcEnumInterfaces(
STRING_HANDLE pSrvAddr,
PINTFS_KEY_TABLE pIntfsTable)
{
DWORD dwErr = ERROR_SUCCESS;
DWORD dwNumIntfs;
InterlockedIncrement(&g_nThreads);
DbgPrint((TRC_TRACK, "[RpcEnumInterfaces"));
dwErr = WZCSvcCheckRPCAccess(WZC_ACCESS_QUERY);
if (dwErr == ERROR_SUCCESS)
{
dwNumIntfs = LstNumInterfaces();
DbgPrint((TRC_GENERIC,
"Num interfaces = %d",
dwNumIntfs));
if (dwNumIntfs == 0)
goto exit;
pIntfsTable->pIntfs = RpcCAlloc(dwNumIntfs*sizeof(INTF_KEY_ENTRY));
if (pIntfsTable->pIntfs == NULL)
{
dwErr = GetLastError();
goto exit;
}
dwErr = LstGetIntfsKeyInfo(pIntfsTable->pIntfs, &dwNumIntfs);
if (dwErr != ERROR_SUCCESS || dwNumIntfs == 0)
{
RpcFree(pIntfsTable->pIntfs);
pIntfsTable->pIntfs = NULL;
goto exit;
}
pIntfsTable->dwNumIntfs = dwNumIntfs;
for (dwNumIntfs = 0; dwNumIntfs < pIntfsTable->dwNumIntfs; dwNumIntfs++)
{
DbgPrint((TRC_GENERIC,
"Intf %d:\t%S",
dwNumIntfs,
pIntfsTable->pIntfs[dwNumIntfs].wszGuid == NULL ?
L"(null)" :
pIntfsTable->pIntfs[dwNumIntfs].wszGuid));
}
}
exit:
DbgPrint((TRC_TRACK, "RpcEnumInterfaces]=%d", dwErr));
InterlockedDecrement(&g_nThreads);
return dwErr;
}
DWORD
RpcQueryInterface(
STRING_HANDLE pSrvAddr,
DWORD dwInFlags,
PINTF_ENTRY pIntfEntry,
LPDWORD pdwOutFlags)
{
DWORD dwErr = ERROR_SUCCESS;
InterlockedIncrement(&g_nThreads);
DbgPrint((TRC_TRACK, "[RpcQueryInterface(0x%x,%S)", dwInFlags, pIntfEntry->wszGuid));
dwErr = WZCSvcCheckRPCAccess(WZC_ACCESS_QUERY);
if (dwErr == ERROR_SUCCESS)
{
dwErr = LstQueryInterface(dwInFlags, pIntfEntry, pdwOutFlags);
}
DbgPrint((TRC_TRACK, "RpcQueryInterface]=%d", dwErr));
InterlockedDecrement(&g_nThreads);
return dwErr;
}
DWORD
RpcSetInterface(
STRING_HANDLE pSrvAddr,
DWORD dwInFlags,
PINTF_ENTRY pIntfEntry,
LPDWORD pdwOutFlags)
{
DWORD dwErr = ERROR_SUCCESS;
InterlockedIncrement(&g_nThreads);
DbgPrint((TRC_TRACK, "[RpcSetInterface(0x%x,%S)", dwInFlags, pIntfEntry->wszGuid));
dwErr = WZCSvcCheckRPCAccess(WZC_ACCESS_SET);
if (dwErr == ERROR_SUCCESS)
{
dwErr = WZCSvcCheckParamIntfEntry(pIntfEntry);
}
if (dwErr == ERROR_SUCCESS)
{
dwErr = LstSetInterface(dwInFlags, pIntfEntry, pdwOutFlags);
}
DbgPrint((TRC_TRACK, "RpcSetInterface]=%d", dwErr));
InterlockedDecrement(&g_nThreads);
return dwErr;
}
DWORD
RpcRefreshInterface(
STRING_HANDLE pSrvAddr,
DWORD dwInFlags,
PINTF_ENTRY pIntfEntry,
LPDWORD pdwOutFlags)
{
DWORD dwErr = ERROR_SUCCESS;
InterlockedIncrement(&g_nThreads);
DbgPrint((TRC_TRACK, "[RpcRefreshInterface(0x%x,%S)", dwInFlags, pIntfEntry->wszGuid));
dwErr = WZCSvcCheckRPCAccess(WZC_ACCESS_SET);
if (dwErr == ERROR_SUCCESS)
{
dwErr = LstRefreshInterface(dwInFlags, pIntfEntry, pdwOutFlags);
}
DbgPrint((TRC_TRACK, "RpcRefreshInterface]=%d", dwErr));
InterlockedDecrement(&g_nThreads);
return dwErr;
}
DWORD
RpcQueryContext(
STRING_HANDLE pSrvAddr,
DWORD dwInFlags,
PWZC_CONTEXT pContext,
LPDWORD pdwOutFlags)
{
DWORD dwErr = ERROR_SUCCESS;
InterlockedIncrement(&g_nThreads);
DbgPrint((TRC_TRACK, "[RpcQueryContext(0x%x)", dwInFlags));
dwErr = WZCSvcCheckRPCAccess(WZC_ACCESS_QUERY);
if (dwErr == ERROR_SUCCESS)
{
dwErr = WzcContextQuery(dwInFlags, pContext, pdwOutFlags);
}
DbgPrint((TRC_TRACK, "RpcQueryContext]=%d", dwErr));
InterlockedDecrement(&g_nThreads);
return dwErr;
}
DWORD
RpcSetContext(
STRING_HANDLE pSrvAddr,
DWORD dwInFlags,
PWZC_CONTEXT pContext,
LPDWORD pdwOutFlags)
{
DWORD dwErr = ERROR_SUCCESS;
BOOL bLogEnabled = FALSE;
InterlockedIncrement(&g_nThreads);
DbgPrint((TRC_TRACK, "[RpcSetContext(0x%x)", dwInFlags));
dwErr = WZCSvcCheckRPCAccess(WZC_ACCESS_SET);
if (dwErr == ERROR_SUCCESS)
{
dwErr = WzcContextSet(dwInFlags, pContext, pdwOutFlags);
}
DbgPrint((TRC_TRACK, "RpcSetContext]=%d", dwErr));
BAIL_ON_WIN32_ERROR(dwErr);
EnterCriticalSection(&g_wzcInternalCtxt.csContext);
bLogEnabled = ((g_wzcInternalCtxt.wzcContext.dwFlags & WZC_CTXT_LOGGING_ON) != 0);
dwErr = WZCSetLoggingState(bLogEnabled);
BAIL_ON_LOCK_ERROR(dwErr);
lock:
LeaveCriticalSection(&g_wzcInternalCtxt.csContext);
error:
InterlockedDecrement(&g_nThreads);
return dwErr;
}
extern SERVICE_STATUS g_WZCSvcStatus;
DWORD
RpcCmdInterface(
IN DWORD dwHandle,
IN DWORD dwCmdCode,
IN LPWSTR wszIntfGuid,
IN PRAW_DATA prdUserData)
{
DWORD dwErr = ERROR_SUCCESS;
InterlockedIncrement(&g_nThreads);
// We need to avoid processing this command if the service is not currently running
// We need this protection only for this call because other than for the other calls,
// RpcCmdInterface is called from 802.1x which runs within the same service. For all
// the other Rpc stubs, the RPC server is shut down prior to destroying the global data
// hence there is guaranteed no other calls will be made afterwards.
if (g_WZCSvcStatus.dwCurrentState == SERVICE_RUNNING)
{
DbgPrint((TRC_TRACK, "[RpcCmdInterface(0x%x,%S)", dwCmdCode, wszIntfGuid));
dwErr = WZCSvcCheckRPCAccess(WZC_ACCESS_SET);
// currently this is not an RPC call! This is called directly from 802.1x. Consequently,
// WZCSvcCheckRPCAccess will return RPC_S_NO_CALL_ACTIVE. We could either remove the
// RPC check for now, or pass through the RPC_S_NO_CALL_ACTIVE (since later this could
// become an RPC call). We do the latter!
if (dwErr == ERROR_SUCCESS || dwErr == RPC_S_NO_CALL_ACTIVE)
{
dwErr = LstCmdInterface(dwHandle, dwCmdCode, wszIntfGuid, prdUserData);
}
DbgPrint((TRC_TRACK, "RpcCmdInterface]=%d", dwErr));
}
InterlockedDecrement(&g_nThreads);
return dwErr;
}
VOID
WZC_DBLOG_SESSION_HANDLE_rundown(
WZC_DBLOG_SESSION_HANDLE hSession
)
{
if (!g_bRpcStarted) {
return;
}
if (!IsDBOpened()) {
return;
}
if (hSession) {
(VOID) CloseWZCDbLogSession(
hSession
);
}
return;
}
DWORD
RpcOpenWZCDbLogSession(
STRING_HANDLE pServerName,
WZC_DBLOG_SESSION_HANDLE * phSession
)
{
DWORD dwError = 0;
InterlockedIncrement(&g_nThreads);
dwError = WZCSvcCheckRPCAccess(WZC_ACCESS_QUERY);
BAIL_ON_WIN32_ERROR(dwError);
if (!phSession) {
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_WIN32_ERROR(dwError);
}
dwError = OpenWZCDbLogSession(
pServerName,
0,
phSession
);
BAIL_ON_WIN32_ERROR(dwError);
error:
InterlockedDecrement(&g_nThreads);
return (dwError);
}
DWORD
RpcCloseWZCDbLogSession(
WZC_DBLOG_SESSION_HANDLE * phSession
)
{
DWORD dwError = 0;
InterlockedIncrement(&g_nThreads);
dwError = WZCSvcCheckRPCAccess(WZC_ACCESS_QUERY);
BAIL_ON_WIN32_ERROR(dwError);
if (!IsDBOpened()) {
dwError = ERROR_SERVICE_DISABLED;
BAIL_ON_WIN32_ERROR(dwError);
}
if (!phSession) {
InterlockedDecrement(&g_nThreads);
return (ERROR_INVALID_PARAMETER);
}
dwError = CloseWZCDbLogSession(
*phSession
);
BAIL_ON_WIN32_ERROR(dwError);
*phSession = NULL;
error:
InterlockedDecrement(&g_nThreads);
return (dwError);
}
DWORD
RpcEnumWZCDbLogRecords(
WZC_DBLOG_SESSION_HANDLE hSession,
PWZC_DB_RECORD_CONTAINER pTemplateRecordContainer,
PBOOL pbEnumFromStart,
DWORD dwPreferredNumEntries,
PWZC_DB_RECORD_CONTAINER * ppRecordContainer
)
{
DWORD dwError = 0;
PWZC_DB_RECORD pWZCRecords = NULL;
DWORD dwNumRecords = 0;
PWZC_DB_RECORD pTemplateRecord = NULL;
InterlockedIncrement(&g_nThreads);
dwError = WZCSvcCheckRPCAccess(WZC_ACCESS_QUERY);
BAIL_ON_WIN32_ERROR(dwError);
if (!IsDBOpened()) {
dwError = ERROR_SERVICE_DISABLED;
BAIL_ON_WIN32_ERROR(dwError);
}
if (!hSession || !pbEnumFromStart) {
InterlockedDecrement(&g_nThreads);
return (ERROR_NOT_SUPPORTED);
}
if (!pTemplateRecordContainer || !ppRecordContainer ||
!*ppRecordContainer) {
InterlockedDecrement(&g_nThreads);
return (ERROR_INVALID_PARAMETER);
}
if (pTemplateRecordContainer->pWZCRecords) {
if (pTemplateRecordContainer->dwNumRecords != 1) {
InterlockedDecrement(&g_nThreads);
return (ERROR_INVALID_PARAMETER);
}
pTemplateRecord = pTemplateRecordContainer->pWZCRecords;
}
dwError = EnumWZCDbLogRecordsSummary(
hSession,
pTemplateRecord,
pbEnumFromStart,
dwPreferredNumEntries,
&pWZCRecords,
&dwNumRecords,
NULL
);
if (dwError != ERROR_NO_MORE_ITEMS) {
BAIL_ON_WIN32_ERROR(dwError);
}
(*ppRecordContainer)->pWZCRecords = pWZCRecords;
(*ppRecordContainer)->dwNumRecords = dwNumRecords;
InterlockedDecrement(&g_nThreads);
return (dwError);
error:
(*ppRecordContainer)->pWZCRecords = NULL;
(*ppRecordContainer)->dwNumRecords = 0;
InterlockedDecrement(&g_nThreads);
return (dwError);
}
DWORD
RpcFlushWZCDbLog(
WZC_DBLOG_SESSION_HANDLE hSession
)
{
DWORD dwError = 0;
InterlockedIncrement(&g_nThreads);
dwError = WZCSvcCheckRPCAccess(WZC_ACCESS_SET);
BAIL_ON_WIN32_ERROR(dwError);
if (!IsDBOpened()) {
dwError = ERROR_SERVICE_DISABLED;
BAIL_ON_WIN32_ERROR(dwError);
}
if (!hSession){
InterlockedDecrement(&g_nThreads);
return(ERROR_INVALID_PARAMETER);
}
dwError = FlushWZCDbLog(
hSession
);
BAIL_ON_WIN32_ERROR(dwError);
error:
InterlockedDecrement(&g_nThreads);
return (dwError);
}
DWORD
RpcGetWZCDbLogRecord(
WZC_DBLOG_SESSION_HANDLE hSession,
PWZC_DB_RECORD_CONTAINER pTemplateRecordContainer,
PWZC_DB_RECORD_CONTAINER * ppRecordContainer
)
{
DWORD dwError = 0;
PWZC_DB_RECORD pWZCRecords = NULL;
DWORD dwNumRecords = 0;
PWZC_DB_RECORD pTemplateRecord = NULL;
InterlockedIncrement(&g_nThreads);
dwError = WZCSvcCheckRPCAccess(WZC_ACCESS_QUERY);
BAIL_ON_WIN32_ERROR(dwError);
if (!IsDBOpened()) {
dwError = ERROR_SERVICE_DISABLED;
BAIL_ON_WIN32_ERROR(dwError);
}
if(!hSession){
InterlockedDecrement(&g_nThreads);
return(ERROR_NOT_SUPPORTED);
}
if (!pTemplateRecordContainer || !ppRecordContainer ||
!*ppRecordContainer) {
InterlockedDecrement(&g_nThreads);
return (ERROR_INVALID_PARAMETER);
}
if (pTemplateRecordContainer->pWZCRecords) {
if (pTemplateRecordContainer->dwNumRecords != 1) {
InterlockedDecrement(&g_nThreads);
return (ERROR_INVALID_PARAMETER);
}
pTemplateRecord = pTemplateRecordContainer->pWZCRecords;
}
dwError = GetWZCDbLogRecord(
hSession,
pTemplateRecord,
&pWZCRecords,
NULL
);
BAIL_ON_WIN32_ERROR(dwError);
(*ppRecordContainer)->pWZCRecords = pWZCRecords;
(*ppRecordContainer)->dwNumRecords = 1;
InterlockedDecrement(&g_nThreads);
return (dwError);
error:
(*ppRecordContainer)->pWZCRecords = NULL;
(*ppRecordContainer)->dwNumRecords = 0;
InterlockedDecrement(&g_nThreads);
return (dwError);
}