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.
2757 lines
66 KiB
2757 lines
66 KiB
/*++
|
|
|
|
Copyright (c) 1999 Microsoft Corporation
|
|
|
|
|
|
Module Name:
|
|
|
|
spdrpc.c
|
|
|
|
Abstract:
|
|
|
|
This module contains all of the code to service the
|
|
RPC calls made to the SPD server.
|
|
|
|
Author:
|
|
|
|
abhisheV 30-September-1999
|
|
|
|
Environment
|
|
|
|
User Level: Win32
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
|
|
#include "precomp.h"
|
|
|
|
|
|
VOID
|
|
TRANSPORTFILTER_HANDLE_rundown(
|
|
TRANSPORTFILTER_HANDLE hFilter
|
|
)
|
|
{
|
|
if (!gbSPDRPCServerUp) {
|
|
return;
|
|
}
|
|
|
|
if (hFilter) {
|
|
(VOID) DeleteTransportFilter(
|
|
hFilter
|
|
);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcAddTransportFilter(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
DWORD dwFlags,
|
|
PTRANSPORT_FILTER_CONTAINER pFilterContainer,
|
|
TRANSPORTFILTER_HANDLE * phFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTRANSPORT_FILTER pTransportFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pFilterContainer || !phFilter) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pFilterContainer->pTransportFilters) ||
|
|
!(pFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pTransportFilter = pFilterContainer->pTransportFilters;
|
|
|
|
if (pTransportFilter && (pTransportFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = AddTransportFilter(
|
|
pServerName,
|
|
dwVersion,
|
|
dwFlags,
|
|
pTransportFilter,
|
|
NULL,
|
|
phFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcDeleteTransportFilter(
|
|
TRANSPORTFILTER_HANDLE * phFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (!phFilter) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = DeleteTransportFilter(
|
|
*phFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
*phFilter = NULL;
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcEnumTransportFilters(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PTRANSPORT_FILTER_CONTAINER pTemplateFilterContainer,
|
|
DWORD dwLevel,
|
|
GUID gGenericFilterID,
|
|
DWORD dwPreferredNumEntries,
|
|
PTRANSPORT_FILTER_CONTAINER * ppFilterContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTRANSPORT_FILTER pTransportFilters = NULL;
|
|
DWORD dwNumFilters = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
PTRANSPORT_FILTER pTransportTemplateFilter = NULL;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pTemplateFilterContainer || !ppFilterContainer || !pdwResumeHandle ||
|
|
!*ppFilterContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
switch (dwLevel) {
|
|
|
|
case ENUM_GENERIC_FILTERS:
|
|
case ENUM_SELECT_SPECIFIC_FILTERS:
|
|
case ENUM_SPECIFIC_FILTERS:
|
|
break;
|
|
|
|
default:
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
break;
|
|
|
|
}
|
|
|
|
if ((pTemplateFilterContainer->dwNumFilters) ||
|
|
(pTemplateFilterContainer->pTransportFilters)) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = EnumTransportFilters(
|
|
pServerName,
|
|
dwVersion,
|
|
pTransportTemplateFilter,
|
|
dwLevel,
|
|
gGenericFilterID,
|
|
dwPreferredNumEntries,
|
|
&pTransportFilters,
|
|
&dwNumFilters,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppFilterContainer)->pTransportFilters = pTransportFilters;
|
|
(*ppFilterContainer)->dwNumFilters = dwNumFilters;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppFilterContainer)->pTransportFilters = NULL;
|
|
(*ppFilterContainer)->dwNumFilters = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcSetTransportFilter(
|
|
TRANSPORTFILTER_HANDLE hFilter,
|
|
DWORD dwVersion,
|
|
PTRANSPORT_FILTER_CONTAINER pFilterContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTRANSPORT_FILTER pTransportFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!hFilter || !pFilterContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pFilterContainer->pTransportFilters) ||
|
|
!(pFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pTransportFilter = pFilterContainer->pTransportFilters;
|
|
|
|
if (pTransportFilter && (pTransportFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = SetTransportFilter(
|
|
hFilter,
|
|
dwVersion,
|
|
pTransportFilter,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcGetTransportFilter(
|
|
TRANSPORTFILTER_HANDLE hFilter,
|
|
DWORD dwVersion,
|
|
PTRANSPORT_FILTER_CONTAINER * ppFilterContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTRANSPORT_FILTER pTransportFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!hFilter || !ppFilterContainer || !*ppFilterContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = GetTransportFilter(
|
|
hFilter,
|
|
dwVersion,
|
|
&pTransportFilter,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppFilterContainer)->pTransportFilters = pTransportFilter;
|
|
(*ppFilterContainer)->dwNumFilters = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppFilterContainer)->pTransportFilters = NULL;
|
|
(*ppFilterContainer)->dwNumFilters = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcAddQMPolicy(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
DWORD dwFlags,
|
|
PIPSEC_QM_POLICY_CONTAINER pQMPolicyContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_QM_POLICY pQMPolicy = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pQMPolicyContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pQMPolicyContainer->pPolicies) ||
|
|
!(pQMPolicyContainer->dwNumPolicies)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pQMPolicy = pQMPolicyContainer->pPolicies;
|
|
|
|
dwError = AddQMPolicy(
|
|
pServerName,
|
|
dwVersion,
|
|
dwFlags,
|
|
pQMPolicy,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcDeleteQMPolicy(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
LPWSTR pszPolicyName
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pszPolicyName || !*pszPolicyName) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = DeleteQMPolicy(
|
|
pServerName,
|
|
dwVersion,
|
|
pszPolicyName,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcEnumQMPolicies(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PIPSEC_QM_POLICY_CONTAINER pQMTempPolicyContainer,
|
|
DWORD dwFlags,
|
|
DWORD dwPreferredNumEntries,
|
|
PIPSEC_QM_POLICY_CONTAINER * ppQMPolicyContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_QM_POLICY pQMPolicies = NULL;
|
|
DWORD dwNumPolicies = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
PIPSEC_QM_POLICY pQMTemplatePolicy = NULL;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pQMTempPolicyContainer || !ppQMPolicyContainer || !pdwResumeHandle ||
|
|
!*ppQMPolicyContainer) {
|
|
//
|
|
// Do not bail to error from here.
|
|
//
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if ((pQMTempPolicyContainer->dwNumPolicies) ||
|
|
(pQMTempPolicyContainer->pPolicies)) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = EnumQMPolicies(
|
|
pServerName,
|
|
dwVersion,
|
|
pQMTemplatePolicy,
|
|
dwFlags,
|
|
dwPreferredNumEntries,
|
|
&pQMPolicies,
|
|
&dwNumPolicies,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppQMPolicyContainer)->pPolicies = pQMPolicies;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = dwNumPolicies;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppQMPolicyContainer)->pPolicies = NULL;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcSetQMPolicy(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
LPWSTR pszPolicyName,
|
|
PIPSEC_QM_POLICY_CONTAINER pQMPolicyContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_QM_POLICY pQMPolicy = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pszPolicyName || !*pszPolicyName ||
|
|
!pQMPolicyContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pQMPolicyContainer->pPolicies) ||
|
|
!(pQMPolicyContainer->dwNumPolicies)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pQMPolicy = pQMPolicyContainer->pPolicies;
|
|
|
|
dwError = SetQMPolicy(
|
|
pServerName,
|
|
dwVersion,
|
|
pszPolicyName,
|
|
pQMPolicy,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcGetQMPolicy(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
LPWSTR pszPolicyName,
|
|
DWORD dwFlags,
|
|
PIPSEC_QM_POLICY_CONTAINER * ppQMPolicyContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_QM_POLICY pQMPolicy = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pszPolicyName || !*pszPolicyName || !ppQMPolicyContainer ||
|
|
!*ppQMPolicyContainer) {
|
|
//
|
|
// Do not bail to error from here.
|
|
//
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = GetQMPolicy(
|
|
pServerName,
|
|
dwVersion,
|
|
pszPolicyName,
|
|
dwFlags,
|
|
&pQMPolicy,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppQMPolicyContainer)->pPolicies = pQMPolicy;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppQMPolicyContainer)->pPolicies = NULL;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcAddMMPolicy(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
DWORD dwFlags,
|
|
PIPSEC_MM_POLICY_CONTAINER pMMPolicyContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_MM_POLICY pMMPolicy = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pMMPolicyContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pMMPolicyContainer->pPolicies) ||
|
|
!(pMMPolicyContainer->dwNumPolicies)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pMMPolicy = pMMPolicyContainer->pPolicies;
|
|
|
|
dwError = AddMMPolicy(
|
|
pServerName,
|
|
dwVersion,
|
|
dwFlags,
|
|
pMMPolicy,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcDeleteMMPolicy(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
LPWSTR pszPolicyName
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pszPolicyName || !*pszPolicyName) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = DeleteMMPolicy(
|
|
pServerName,
|
|
dwVersion,
|
|
pszPolicyName,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcEnumMMPolicies(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PIPSEC_MM_POLICY_CONTAINER pMMTempPolicyContainer,
|
|
DWORD dwFlags,
|
|
DWORD dwPreferredNumEntries,
|
|
PIPSEC_MM_POLICY_CONTAINER * ppMMPolicyContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_MM_POLICY pMMPolicies = NULL;
|
|
DWORD dwNumPolicies = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
PIPSEC_MM_POLICY pMMTemplatePolicy = NULL;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pMMTempPolicyContainer || !ppMMPolicyContainer || !pdwResumeHandle ||
|
|
!*ppMMPolicyContainer) {
|
|
//
|
|
// Do not bail to error from here.
|
|
//
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if ((pMMTempPolicyContainer->dwNumPolicies) ||
|
|
(pMMTempPolicyContainer->pPolicies)) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = EnumMMPolicies(
|
|
pServerName,
|
|
dwVersion,
|
|
pMMTemplatePolicy,
|
|
dwFlags,
|
|
dwPreferredNumEntries,
|
|
&pMMPolicies,
|
|
&dwNumPolicies,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppMMPolicyContainer)->pPolicies = pMMPolicies;
|
|
(*ppMMPolicyContainer)->dwNumPolicies = dwNumPolicies;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppMMPolicyContainer)->pPolicies = NULL;
|
|
(*ppMMPolicyContainer)->dwNumPolicies = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcSetMMPolicy(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
LPWSTR pszPolicyName,
|
|
PIPSEC_MM_POLICY_CONTAINER pMMPolicyContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_MM_POLICY pMMPolicy = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pszPolicyName || !*pszPolicyName ||
|
|
!pMMPolicyContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pMMPolicyContainer->pPolicies) ||
|
|
!(pMMPolicyContainer->dwNumPolicies)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pMMPolicy = pMMPolicyContainer->pPolicies;
|
|
|
|
dwError = SetMMPolicy(
|
|
pServerName,
|
|
dwVersion,
|
|
pszPolicyName,
|
|
pMMPolicy,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcGetMMPolicy(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
LPWSTR pszPolicyName,
|
|
PIPSEC_MM_POLICY_CONTAINER * ppMMPolicyContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_MM_POLICY pMMPolicy = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pszPolicyName || !*pszPolicyName || !ppMMPolicyContainer ||
|
|
!*ppMMPolicyContainer) {
|
|
//
|
|
// Do not bail to error from here.
|
|
//
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = GetMMPolicy(
|
|
pServerName,
|
|
dwVersion,
|
|
pszPolicyName,
|
|
&pMMPolicy,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppMMPolicyContainer)->pPolicies = pMMPolicy;
|
|
(*ppMMPolicyContainer)->dwNumPolicies = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppMMPolicyContainer)->pPolicies = NULL;
|
|
(*ppMMPolicyContainer)->dwNumPolicies = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
VOID
|
|
MMFILTER_HANDLE_rundown(
|
|
MMFILTER_HANDLE hMMFilter
|
|
)
|
|
{
|
|
if (!gbSPDRPCServerUp) {
|
|
return;
|
|
}
|
|
|
|
if (hMMFilter) {
|
|
(VOID) DeleteMMFilter(
|
|
hMMFilter
|
|
);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcAddMMFilter(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
DWORD dwFlags,
|
|
PMM_FILTER_CONTAINER pMMFilterContainer,
|
|
MMFILTER_HANDLE * phMMFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PMM_FILTER pMMFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pMMFilterContainer || !phMMFilter) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pMMFilterContainer->pMMFilters) ||
|
|
!(pMMFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pMMFilter = pMMFilterContainer->pMMFilters;
|
|
|
|
if (pMMFilter && (pMMFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = AddMMFilter(
|
|
pServerName,
|
|
dwVersion,
|
|
dwFlags,
|
|
pMMFilter,
|
|
NULL,
|
|
phMMFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcDeleteMMFilter(
|
|
MMFILTER_HANDLE * phMMFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (!phMMFilter) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = DeleteMMFilter(
|
|
*phMMFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
*phMMFilter = NULL;
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcEnumMMFilters(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PMM_FILTER_CONTAINER pTemplateFilterContainer,
|
|
DWORD dwLevel,
|
|
GUID gGenericFilterID,
|
|
DWORD dwPreferredNumEntries,
|
|
PMM_FILTER_CONTAINER * ppMMFilterContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PMM_FILTER pMMFilters = NULL;
|
|
DWORD dwNumFilters = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
PMM_FILTER pMMTemplateFilter = NULL;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pTemplateFilterContainer || !ppMMFilterContainer || !pdwResumeHandle ||
|
|
!*ppMMFilterContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
switch (dwLevel) {
|
|
|
|
case ENUM_GENERIC_FILTERS:
|
|
case ENUM_SELECT_SPECIFIC_FILTERS:
|
|
case ENUM_SPECIFIC_FILTERS:
|
|
break;
|
|
|
|
default:
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
break;
|
|
|
|
}
|
|
|
|
if ((pTemplateFilterContainer->dwNumFilters) ||
|
|
(pTemplateFilterContainer->pMMFilters)) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = EnumMMFilters(
|
|
pServerName,
|
|
dwVersion,
|
|
pMMTemplateFilter,
|
|
dwLevel,
|
|
gGenericFilterID,
|
|
dwPreferredNumEntries,
|
|
&pMMFilters,
|
|
&dwNumFilters,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppMMFilterContainer)->pMMFilters = pMMFilters;
|
|
(*ppMMFilterContainer)->dwNumFilters = dwNumFilters;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppMMFilterContainer)->pMMFilters = NULL;
|
|
(*ppMMFilterContainer)->dwNumFilters = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcSetMMFilter(
|
|
MMFILTER_HANDLE hMMFilter,
|
|
DWORD dwVersion,
|
|
PMM_FILTER_CONTAINER pMMFilterContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PMM_FILTER pMMFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!hMMFilter || !pMMFilterContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pMMFilterContainer->pMMFilters) ||
|
|
!(pMMFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pMMFilter = pMMFilterContainer->pMMFilters;
|
|
|
|
if (pMMFilter && (pMMFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = SetMMFilter(
|
|
hMMFilter,
|
|
dwVersion,
|
|
pMMFilter,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcGetMMFilter(
|
|
MMFILTER_HANDLE hMMFilter,
|
|
DWORD dwVersion,
|
|
PMM_FILTER_CONTAINER * ppMMFilterContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PMM_FILTER pMMFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!hMMFilter || !ppMMFilterContainer || !*ppMMFilterContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = GetMMFilter(
|
|
hMMFilter,
|
|
dwVersion,
|
|
&pMMFilter,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppMMFilterContainer)->pMMFilters = pMMFilter;
|
|
(*ppMMFilterContainer)->dwNumFilters = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppMMFilterContainer)->pMMFilters = NULL;
|
|
(*ppMMFilterContainer)->dwNumFilters = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcMatchMMFilter(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PMM_FILTER_CONTAINER pMMFilterContainer,
|
|
DWORD dwFlags,
|
|
DWORD dwPreferredNumEntries,
|
|
PMM_FILTER_CONTAINER * ppMMFilterContainer,
|
|
PIPSEC_MM_POLICY_CONTAINER * ppMMPolicyContainer,
|
|
PMM_AUTH_METHODS_CONTAINER * ppMMAuthContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PMM_FILTER pMMFilter = NULL;
|
|
PMM_FILTER pMatchedMMFilters = NULL;
|
|
PIPSEC_MM_POLICY pMatchedMMPolicies = NULL;
|
|
PINT_MM_AUTH_METHODS pMatchedMMAuthMethods = NULL;
|
|
DWORD dwNumMatches = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pMMFilterContainer || !ppMMFilterContainer ||
|
|
!ppMMPolicyContainer || !ppMMAuthContainer || !pdwResumeHandle ||
|
|
!*ppMMFilterContainer || !*ppMMPolicyContainer || !*ppMMAuthContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (!(pMMFilterContainer->pMMFilters) ||
|
|
!(pMMFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pMMFilter = pMMFilterContainer->pMMFilters;
|
|
|
|
if (pMMFilter && (pMMFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = IntMatchMMFilter(
|
|
pServerName,
|
|
dwVersion,
|
|
pMMFilter,
|
|
dwFlags,
|
|
dwPreferredNumEntries,
|
|
&pMatchedMMFilters,
|
|
&pMatchedMMPolicies,
|
|
&pMatchedMMAuthMethods,
|
|
&dwNumMatches,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppMMFilterContainer)->pMMFilters = pMatchedMMFilters;
|
|
(*ppMMFilterContainer)->dwNumFilters = dwNumMatches;
|
|
(*ppMMPolicyContainer)->pPolicies = pMatchedMMPolicies;
|
|
(*ppMMPolicyContainer)->dwNumPolicies = dwNumMatches;
|
|
dwError = SPDConvertArrayIntMMAuthToExt(
|
|
pMatchedMMAuthMethods,
|
|
&(*ppMMAuthContainer)->pMMAuthMethods,
|
|
dwNumMatches
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
(*ppMMAuthContainer)->dwNumAuthMethods = dwNumMatches;
|
|
|
|
SPDFreeIntMMAuthMethodsArray(
|
|
pMatchedMMAuthMethods,
|
|
dwNumMatches
|
|
);
|
|
pMatchedMMAuthMethods = NULL;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
if (pMatchedMMFilters) {
|
|
FreeMMFilters(
|
|
dwNumMatches,
|
|
pMatchedMMFilters
|
|
);
|
|
}
|
|
|
|
if (pMatchedMMPolicies) {
|
|
FreeMMPolicies(
|
|
dwNumMatches,
|
|
pMatchedMMPolicies
|
|
);
|
|
}
|
|
|
|
SPDFreeIntMMAuthMethodsArray(
|
|
pMatchedMMAuthMethods,
|
|
dwNumMatches
|
|
);
|
|
|
|
(*ppMMFilterContainer)->pMMFilters = NULL;
|
|
(*ppMMFilterContainer)->dwNumFilters = 0;
|
|
(*ppMMPolicyContainer)->pPolicies = NULL;
|
|
(*ppMMPolicyContainer)->dwNumPolicies = 0;
|
|
(*ppMMAuthContainer)->pMMAuthMethods = NULL;
|
|
(*ppMMAuthContainer)->dwNumAuthMethods = 0;
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcMatchTransportFilter(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PTRANSPORT_FILTER_CONTAINER pTxFilterContainer,
|
|
DWORD dwFlags,
|
|
DWORD dwPreferredNumEntries,
|
|
PTRANSPORT_FILTER_CONTAINER * ppTxFilterContainer,
|
|
PIPSEC_QM_POLICY_CONTAINER * ppQMPolicyContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTRANSPORT_FILTER pTxFilter = NULL;
|
|
PTRANSPORT_FILTER pMatchedTxFilters = NULL;
|
|
PIPSEC_QM_POLICY pMatchedQMPolicies = NULL;
|
|
DWORD dwNumMatches = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pTxFilterContainer || !ppTxFilterContainer ||
|
|
!ppQMPolicyContainer || !pdwResumeHandle ||
|
|
!*ppTxFilterContainer || !*ppQMPolicyContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (!(pTxFilterContainer->pTransportFilters) ||
|
|
!(pTxFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pTxFilter = pTxFilterContainer->pTransportFilters;
|
|
|
|
if (pTxFilter && (pTxFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = MatchTransportFilter(
|
|
pServerName,
|
|
dwVersion,
|
|
pTxFilter,
|
|
dwFlags,
|
|
dwPreferredNumEntries,
|
|
&pMatchedTxFilters,
|
|
&pMatchedQMPolicies,
|
|
&dwNumMatches,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppTxFilterContainer)->pTransportFilters = pMatchedTxFilters;
|
|
(*ppTxFilterContainer)->dwNumFilters = dwNumMatches;
|
|
(*ppQMPolicyContainer)->pPolicies = pMatchedQMPolicies;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = dwNumMatches;
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppTxFilterContainer)->pTransportFilters = NULL;
|
|
(*ppTxFilterContainer)->dwNumFilters = 0;
|
|
(*ppQMPolicyContainer)->pPolicies = NULL;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = 0;
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcGetQMPolicyByID(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
GUID gQMPolicyID,
|
|
DWORD dwFlags,
|
|
PIPSEC_QM_POLICY_CONTAINER * ppQMPolicyContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_QM_POLICY pQMPolicy = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!ppQMPolicyContainer || !*ppQMPolicyContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = GetQMPolicyByID(
|
|
pServerName,
|
|
dwVersion,
|
|
gQMPolicyID,
|
|
dwFlags,
|
|
&pQMPolicy,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppQMPolicyContainer)->pPolicies = pQMPolicy;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppQMPolicyContainer)->pPolicies = NULL;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcGetMMPolicyByID(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
GUID gMMPolicyID,
|
|
PIPSEC_MM_POLICY_CONTAINER * ppMMPolicyContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_MM_POLICY pMMPolicy = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!ppMMPolicyContainer || !*ppMMPolicyContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = GetMMPolicyByID(
|
|
pServerName,
|
|
dwVersion,
|
|
gMMPolicyID,
|
|
&pMMPolicy,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppMMPolicyContainer)->pPolicies = pMMPolicy;
|
|
(*ppMMPolicyContainer)->dwNumPolicies = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppMMPolicyContainer)->pPolicies = NULL;
|
|
(*ppMMPolicyContainer)->dwNumPolicies = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcAddMMAuthMethods(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
DWORD dwFlags,
|
|
PMM_AUTH_METHODS_CONTAINER pMMAuthContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PINT_MM_AUTH_METHODS pMMAuthMethods = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pMMAuthContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pMMAuthContainer->pMMAuthMethods) ||
|
|
!(pMMAuthContainer->dwNumAuthMethods)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = ConvertExtMMAuthToInt(
|
|
pMMAuthContainer->pMMAuthMethods,
|
|
&pMMAuthMethods
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
dwError = IntAddMMAuthMethods(
|
|
pServerName,
|
|
dwVersion,
|
|
dwFlags,
|
|
IPSEC_SOURCE_WINIPSEC,
|
|
pMMAuthMethods,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
FreeIntMMAuthMethods(pMMAuthMethods);
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcDeleteMMAuthMethods(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
GUID gMMAuthID
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = DeleteMMAuthMethods(
|
|
pServerName,
|
|
dwVersion,
|
|
gMMAuthID,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcEnumMMAuthMethods(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PMM_AUTH_METHODS_CONTAINER pMMTempAuthContainer,
|
|
DWORD dwFlags,
|
|
DWORD dwPreferredNumEntries,
|
|
PMM_AUTH_METHODS_CONTAINER * ppMMAuthContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PINT_MM_AUTH_METHODS pMMAuthMethods = NULL;
|
|
DWORD dwNumAuthMethods = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
PINT_MM_AUTH_METHODS pMMTemplateAuthMethods = NULL;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pMMTempAuthContainer || !ppMMAuthContainer || !pdwResumeHandle ||
|
|
!*ppMMAuthContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if ((pMMTempAuthContainer->dwNumAuthMethods) ||
|
|
(pMMTempAuthContainer->pMMAuthMethods)) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = IntEnumMMAuthMethods(
|
|
pServerName,
|
|
dwVersion,
|
|
pMMTemplateAuthMethods,
|
|
dwFlags,
|
|
dwPreferredNumEntries,
|
|
&pMMAuthMethods,
|
|
&dwNumAuthMethods,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
dwError = SPDConvertArrayIntMMAuthToExt(
|
|
pMMAuthMethods,
|
|
&(*ppMMAuthContainer)->pMMAuthMethods,
|
|
dwNumAuthMethods
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
(*ppMMAuthContainer)->dwNumAuthMethods = dwNumAuthMethods;
|
|
|
|
SPDFreeIntMMAuthMethodsArray(
|
|
pMMAuthMethods,
|
|
dwNumAuthMethods
|
|
);
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
(*ppMMAuthContainer)->pMMAuthMethods = NULL;
|
|
(*ppMMAuthContainer)->dwNumAuthMethods = 0;
|
|
|
|
SPDFreeIntMMAuthMethodsArray(
|
|
pMMAuthMethods,
|
|
dwNumAuthMethods
|
|
);
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcSetMMAuthMethods(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
GUID gMMAuthID,
|
|
PMM_AUTH_METHODS_CONTAINER pMMAuthContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PINT_MM_AUTH_METHODS pMMAuthMethods = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pMMAuthContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pMMAuthContainer->pMMAuthMethods) ||
|
|
!(pMMAuthContainer->dwNumAuthMethods)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = ConvertExtMMAuthToInt(
|
|
pMMAuthContainer->pMMAuthMethods,
|
|
&pMMAuthMethods
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
dwError = IntSetMMAuthMethods(
|
|
pServerName,
|
|
dwVersion,
|
|
gMMAuthID,
|
|
pMMAuthMethods,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
FreeIntMMAuthMethods(pMMAuthMethods);
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcGetMMAuthMethods(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
GUID gMMAuthID,
|
|
PMM_AUTH_METHODS_CONTAINER * ppMMAuthContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PINT_MM_AUTH_METHODS pMMAuthMethods = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!ppMMAuthContainer || !*ppMMAuthContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = IntGetMMAuthMethods(
|
|
pServerName,
|
|
dwVersion,
|
|
gMMAuthID,
|
|
&pMMAuthMethods,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
dwError = SPDConvertIntMMAuthToExt(
|
|
pMMAuthMethods,
|
|
&(*ppMMAuthContainer)->pMMAuthMethods
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
(*ppMMAuthContainer)->dwNumAuthMethods = 1;
|
|
|
|
SPDFreeIntMMAuthMethods(pMMAuthMethods, TRUE);
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
SPDFreeIntMMAuthMethods(pMMAuthMethods, TRUE);
|
|
(*ppMMAuthContainer)->pMMAuthMethods = NULL;
|
|
(*ppMMAuthContainer)->dwNumAuthMethods = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcQueryIPSecStatistics(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PIPSEC_STATISTICS_CONTAINER * ppIpsecStatsContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_STATISTICS pIpsecStatistics = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!ppIpsecStatsContainer || !*ppIpsecStatsContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = QueryIPSecStatistics(
|
|
pServerName,
|
|
dwVersion,
|
|
&pIpsecStatistics,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppIpsecStatsContainer)->pIpsecStatistics = pIpsecStatistics;
|
|
(*ppIpsecStatsContainer)->dwNumIpsecStats = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppIpsecStatsContainer)->pIpsecStatistics = NULL;
|
|
(*ppIpsecStatsContainer)->dwNumIpsecStats = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcEnumQMSAs(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PQM_SA_CONTAINER pQMSATempContainer,
|
|
DWORD dwFlags,
|
|
DWORD dwPreferredNumEntries,
|
|
PQM_SA_CONTAINER * ppQMSAContainer,
|
|
LPDWORD pdwNumTotalQMSAs,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_QM_SA pQMSATemplate = NULL;
|
|
PIPSEC_QM_SA pQMSAs = NULL;
|
|
DWORD dwNumQMSAs = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pQMSATempContainer || !ppQMSAContainer ||
|
|
!pdwNumTotalQMSAs || !pdwResumeHandle ||
|
|
!*ppQMSAContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if ((pQMSATempContainer->dwNumQMSAs) || (pQMSATempContainer->pQMSAs)) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = EnumQMSAs(
|
|
pServerName,
|
|
dwVersion,
|
|
pQMSATemplate,
|
|
dwFlags,
|
|
dwPreferredNumEntries,
|
|
&pQMSAs,
|
|
&dwNumQMSAs,
|
|
pdwNumTotalQMSAs,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppQMSAContainer)->pQMSAs = pQMSAs;
|
|
(*ppQMSAContainer)->dwNumQMSAs = dwNumQMSAs;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppQMSAContainer)->pQMSAs = NULL;
|
|
(*ppQMSAContainer)->dwNumQMSAs = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
VOID
|
|
TUNNELFILTER_HANDLE_rundown(
|
|
TUNNELFILTER_HANDLE hFilter
|
|
)
|
|
{
|
|
if (!gbSPDRPCServerUp) {
|
|
return;
|
|
}
|
|
|
|
if (hFilter) {
|
|
(VOID) DeleteTunnelFilter(
|
|
hFilter
|
|
);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcAddTunnelFilter(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
DWORD dwFlags,
|
|
PTUNNEL_FILTER_CONTAINER pFilterContainer,
|
|
TUNNELFILTER_HANDLE * phFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTUNNEL_FILTER pTunnelFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pFilterContainer || !phFilter) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pFilterContainer->pTunnelFilters) ||
|
|
!(pFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pTunnelFilter = pFilterContainer->pTunnelFilters;
|
|
|
|
if (pTunnelFilter && (pTunnelFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = AddTunnelFilter(
|
|
pServerName,
|
|
dwVersion,
|
|
dwFlags,
|
|
pTunnelFilter,
|
|
NULL,
|
|
phFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcDeleteTunnelFilter(
|
|
TUNNELFILTER_HANDLE * phFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (!phFilter) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = DeleteTunnelFilter(
|
|
*phFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
*phFilter = NULL;
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcEnumTunnelFilters(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PTUNNEL_FILTER_CONTAINER pTemplateFilterContainer,
|
|
DWORD dwLevel,
|
|
GUID gGenericFilterID,
|
|
DWORD dwPreferredNumEntries,
|
|
PTUNNEL_FILTER_CONTAINER * ppFilterContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTUNNEL_FILTER pTunnelFilters = NULL;
|
|
DWORD dwNumFilters = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
PTUNNEL_FILTER pTunnelTemplateFilter = NULL;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pTemplateFilterContainer || !ppFilterContainer || !pdwResumeHandle ||
|
|
!*ppFilterContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
switch (dwLevel) {
|
|
|
|
case ENUM_GENERIC_FILTERS:
|
|
case ENUM_SELECT_SPECIFIC_FILTERS:
|
|
case ENUM_SPECIFIC_FILTERS:
|
|
break;
|
|
|
|
default:
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
break;
|
|
|
|
}
|
|
|
|
if ((pTemplateFilterContainer->dwNumFilters) ||
|
|
(pTemplateFilterContainer->pTunnelFilters)) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = EnumTunnelFilters(
|
|
pServerName,
|
|
dwVersion,
|
|
pTunnelTemplateFilter,
|
|
dwLevel,
|
|
gGenericFilterID,
|
|
dwPreferredNumEntries,
|
|
&pTunnelFilters,
|
|
&dwNumFilters,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppFilterContainer)->pTunnelFilters = pTunnelFilters;
|
|
(*ppFilterContainer)->dwNumFilters = dwNumFilters;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppFilterContainer)->pTunnelFilters = NULL;
|
|
(*ppFilterContainer)->dwNumFilters = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcSetTunnelFilter(
|
|
TUNNELFILTER_HANDLE hFilter,
|
|
DWORD dwVersion,
|
|
PTUNNEL_FILTER_CONTAINER pFilterContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTUNNEL_FILTER pTunnelFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!hFilter || !pFilterContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pFilterContainer->pTunnelFilters) ||
|
|
!(pFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pTunnelFilter = pFilterContainer->pTunnelFilters;
|
|
|
|
if (pTunnelFilter && (pTunnelFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = SetTunnelFilter(
|
|
hFilter,
|
|
dwVersion,
|
|
pTunnelFilter,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcGetTunnelFilter(
|
|
TUNNELFILTER_HANDLE hFilter,
|
|
DWORD dwVersion,
|
|
PTUNNEL_FILTER_CONTAINER * ppFilterContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTUNNEL_FILTER pTunnelFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!hFilter || !ppFilterContainer || !*ppFilterContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = GetTunnelFilter(
|
|
hFilter,
|
|
dwVersion,
|
|
&pTunnelFilter,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppFilterContainer)->pTunnelFilters = pTunnelFilter;
|
|
(*ppFilterContainer)->dwNumFilters = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppFilterContainer)->pTunnelFilters = NULL;
|
|
(*ppFilterContainer)->dwNumFilters = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcMatchTunnelFilter(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PTUNNEL_FILTER_CONTAINER pTnFilterContainer,
|
|
DWORD dwFlags,
|
|
DWORD dwPreferredNumEntries,
|
|
PTUNNEL_FILTER_CONTAINER * ppTnFilterContainer,
|
|
PIPSEC_QM_POLICY_CONTAINER * ppQMPolicyContainer,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTUNNEL_FILTER pTnFilter = NULL;
|
|
PTUNNEL_FILTER pMatchedTnFilters = NULL;
|
|
PIPSEC_QM_POLICY pMatchedQMPolicies = NULL;
|
|
DWORD dwNumMatches = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pTnFilterContainer || !ppTnFilterContainer ||
|
|
!ppQMPolicyContainer || !pdwResumeHandle ||
|
|
!*ppTnFilterContainer || !*ppQMPolicyContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if (!(pTnFilterContainer->pTunnelFilters) ||
|
|
!(pTnFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pTnFilter = pTnFilterContainer->pTunnelFilters;
|
|
|
|
if (pTnFilter && (pTnFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = MatchTunnelFilter(
|
|
pServerName,
|
|
dwVersion,
|
|
pTnFilter,
|
|
dwFlags,
|
|
dwPreferredNumEntries,
|
|
&pMatchedTnFilters,
|
|
&pMatchedQMPolicies,
|
|
&dwNumMatches,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppTnFilterContainer)->pTunnelFilters = pMatchedTnFilters;
|
|
(*ppTnFilterContainer)->dwNumFilters = dwNumMatches;
|
|
(*ppQMPolicyContainer)->pPolicies = pMatchedQMPolicies;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = dwNumMatches;
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppTnFilterContainer)->pTunnelFilters = NULL;
|
|
(*ppTnFilterContainer)->dwNumFilters = 0;
|
|
(*ppQMPolicyContainer)->pPolicies = NULL;
|
|
(*ppQMPolicyContainer)->dwNumPolicies = 0;
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcOpenMMFilterHandle(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PMM_FILTER_CONTAINER pMMFilterContainer,
|
|
MMFILTER_HANDLE * phMMFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PMM_FILTER pMMFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pMMFilterContainer || !phMMFilter) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pMMFilterContainer->pMMFilters) ||
|
|
!(pMMFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pMMFilter = pMMFilterContainer->pMMFilters;
|
|
|
|
if (pMMFilter && (pMMFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = OpenMMFilterHandle(
|
|
pServerName,
|
|
dwVersion,
|
|
pMMFilter,
|
|
NULL,
|
|
phMMFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcCloseMMFilterHandle(
|
|
MMFILTER_HANDLE * phMMFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (!phMMFilter) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = CloseMMFilterHandle(
|
|
*phMMFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
*phMMFilter = NULL;
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcOpenTransportFilterHandle(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PTRANSPORT_FILTER_CONTAINER pFilterContainer,
|
|
TRANSPORTFILTER_HANDLE * phFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTRANSPORT_FILTER pTransportFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pFilterContainer || !phFilter) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pFilterContainer->pTransportFilters) ||
|
|
!(pFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pTransportFilter = pFilterContainer->pTransportFilters;
|
|
|
|
if (pTransportFilter && (pTransportFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = OpenTransportFilterHandle(
|
|
pServerName,
|
|
dwVersion,
|
|
pTransportFilter,
|
|
NULL,
|
|
phFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcCloseTransportFilterHandle(
|
|
TRANSPORTFILTER_HANDLE * phFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (!phFilter) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = CloseTransportFilterHandle(
|
|
*phFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
*phFilter = NULL;
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcOpenTunnelFilterHandle(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PTUNNEL_FILTER_CONTAINER pFilterContainer,
|
|
TUNNELFILTER_HANDLE * phFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PTUNNEL_FILTER pTunnelFilter = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pFilterContainer || !phFilter) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pFilterContainer->pTunnelFilters) ||
|
|
!(pFilterContainer->dwNumFilters)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
pTunnelFilter = pFilterContainer->pTunnelFilters;
|
|
|
|
if (pTunnelFilter && (pTunnelFilter->IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = OpenTunnelFilterHandle(
|
|
pServerName,
|
|
dwVersion,
|
|
pTunnelFilter,
|
|
NULL,
|
|
phFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcCloseTunnelFilterHandle(
|
|
TUNNELFILTER_HANDLE * phFilter
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (!phFilter) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = CloseTunnelFilterHandle(
|
|
*phFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
*phFilter = NULL;
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcEnumIpsecInterfaces(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PIPSEC_INTERFACE_CONTAINER pIpsecIfTempContainer,
|
|
DWORD dwFlags,
|
|
DWORD dwPreferredNumEntries,
|
|
PIPSEC_INTERFACE_CONTAINER * ppIpsecIfContainer,
|
|
LPDWORD pdwNumTotalInterfaces,
|
|
LPDWORD pdwResumeHandle
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PIPSEC_INTERFACE_INFO pIpsecIfTemplate = NULL;
|
|
PIPSEC_INTERFACE_INFO pIpsecInterfaces = NULL;
|
|
DWORD dwNumInterfaces = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!pIpsecIfTempContainer || !ppIpsecIfContainer ||
|
|
!pdwNumTotalInterfaces || !pdwResumeHandle ||
|
|
!*ppIpsecIfContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
if ((pIpsecIfTempContainer->dwNumInterfaces) ||
|
|
(pIpsecIfTempContainer->pIpsecInterfaces)) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = EnumIPSecInterfaces(
|
|
pServerName,
|
|
dwVersion,
|
|
pIpsecIfTemplate,
|
|
dwFlags,
|
|
dwPreferredNumEntries,
|
|
&pIpsecInterfaces,
|
|
&dwNumInterfaces,
|
|
pdwNumTotalInterfaces,
|
|
pdwResumeHandle,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppIpsecIfContainer)->pIpsecInterfaces = pIpsecInterfaces;
|
|
(*ppIpsecIfContainer)->dwNumInterfaces = dwNumInterfaces;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppIpsecIfContainer)->pIpsecInterfaces = NULL;
|
|
(*ppIpsecIfContainer)->dwNumInterfaces = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
|
|
DWORD
|
|
RpcDeleteQMSAs(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PQM_SA_CONTAINER pQMSAContainer,
|
|
DWORD dwFlags
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
if (dwVersion) {
|
|
dwError = ERROR_NOT_SUPPORTED;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!pQMSAContainer) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (!(pQMSAContainer->pQMSAs) ||
|
|
!(pQMSAContainer->dwNumQMSAs)) {
|
|
dwError = ERROR_INVALID_PARAMETER;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
if (pQMSAContainer->pQMSAs &&
|
|
(pQMSAContainer->pQMSAs->IpsecQMFilter.IpVersion != IPSEC_PROTOCOL_V4)) {
|
|
dwError = ERROR_INVALID_LEVEL;
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
}
|
|
|
|
dwError = ValidateQMFilterAddresses(
|
|
&pQMSAContainer->pQMSAs->IpsecQMFilter
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
dwError = DeleteQMSAs(
|
|
pServerName,
|
|
dwVersion,
|
|
pQMSAContainer->pQMSAs,
|
|
dwFlags,
|
|
NULL
|
|
);
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
error:
|
|
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|
|
DWORD
|
|
WINAPI
|
|
RpcQuerySpdPolicyState(
|
|
STRING_HANDLE pServerName,
|
|
DWORD dwVersion,
|
|
PSPD_POLICY_STATE_CONTAINER * ppSpdPolicyStateContainer
|
|
)
|
|
{
|
|
DWORD dwError = 0;
|
|
PSPD_POLICY_STATE pSpdPolicyState = NULL;
|
|
BOOL bImpersonating = FALSE;
|
|
|
|
dwError = SPDImpersonateClient(
|
|
&bImpersonating
|
|
);
|
|
if (dwError) {
|
|
return (dwError);
|
|
}
|
|
|
|
if (dwVersion) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_NOT_SUPPORTED);
|
|
}
|
|
|
|
if (!ppSpdPolicyStateContainer || !*ppSpdPolicyStateContainer) {
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
dwError = QuerySpdPolicyState(
|
|
pServerName,
|
|
dwVersion,
|
|
&pSpdPolicyState,
|
|
NULL
|
|
);
|
|
|
|
BAIL_ON_WIN32_ERROR(dwError);
|
|
|
|
(*ppSpdPolicyStateContainer)->pSpdPolicyStates = pSpdPolicyState;
|
|
(*ppSpdPolicyStateContainer)->dwNumPolicyStates = 1;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
|
|
error:
|
|
|
|
(*ppSpdPolicyStateContainer)->pSpdPolicyStates = NULL;
|
|
(*ppSpdPolicyStateContainer)->dwNumPolicyStates = 0;
|
|
SPDRevertToSelf(bImpersonating);
|
|
return (dwError);
|
|
}
|
|
|