able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/rpc/runtime/mtrt/dcethunk.cxx

1460 lines
40 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) Microsoft Corporation, 1991 - 1999
Module Name:
dceansi.cxx
Abstract:
This file contains the ansi (as opposed to unicode) versions of the
runtime APIs. All of these APIs simply do conversions between ansi
and unicode, and then call a unicode version of the API to do the
work.
Author:
Michael Montague (mikemon) 18-Dec-1991
Revision History:
--*/
#include <precomp.hxx>
#include <wincrypt.h>
#include <rpcssl.h>
#include <CharConv.hxx>
RPC_STATUS
AnsiToUnicodeString (
IN unsigned char * String,
OUT UNICODE_STRING * UnicodeString
)
/*++
Routine Description:
This helper routine is used to convert an ansi string into a unicode
string.
Arguments:
String - Supplies the ansi string (actually a zero terminated string)
to convert into a unicode string.
UnicodeString - Returns the unicode string. This string will have
to be freed using RtlFreeUnicodeString by the caller.
Return Value:
RPC_S_OK - The ansi string was successfully converted into a unicode
string.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available for the unicode
string.
--*/
{
NTSTATUS NtStatus;
ANSI_STRING AnsiString;
RtlInitAnsiString(&AnsiString,(PSZ) String);
NtStatus = RtlAnsiStringToUnicodeString(UnicodeString,&AnsiString,TRUE);
if (!NT_SUCCESS(NtStatus))
return(RPC_S_OUT_OF_MEMORY);
return(RPC_S_OK);
}
unsigned char *
UnicodeToAnsiString (
IN RPC_CHAR * WideCharString,
OUT RPC_STATUS * RpcStatus
)
/*++
Routine Description:
This routine will convert a unicode string into an ansi string,
including allocating memory for the ansi string.
Arguments:
WideCharString - Supplies the unicode string to be converted into
an ansi string.
RpcStatus - Returns the status of the operation; this will be one
of the following values.
RPC_S_OK - The unicode string has successfully been converted
into an ansi string.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to allocate
the ansi string.
Return Value:
A pointer to the ansi string will be returned.
--*/
{
NTSTATUS NtStatus;
UNICODE_STRING UnicodeString;
ANSI_STRING AnsiString;
unsigned char * NewString;
RtlInitUnicodeString(&UnicodeString,WideCharString);
NtStatus = RtlUnicodeStringToAnsiString(&AnsiString,&UnicodeString,TRUE);
if (!NT_SUCCESS(NtStatus))
{
*RpcStatus = RPC_S_OUT_OF_MEMORY;
return(0);
}
NewString = new unsigned char[AnsiString.Length + 1];
if (NewString == 0)
{
RtlFreeAnsiString(&AnsiString);
*RpcStatus = RPC_S_OUT_OF_MEMORY;
return(0);
}
memcpy(NewString,AnsiString.Buffer,AnsiString.Length + 1);
RtlFreeAnsiString(&AnsiString);
*RpcStatus = RPC_S_OK;
return(NewString);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcBindingFromStringBinding) (
IN THUNK_CHAR *StringBinding,
OUT RPC_BINDING_HANDLE PAPI * Binding
)
/*++
Routine Description:
This routine is the ansi thunk to RpcBindingFromStringBindingW.
Return Value:
RPC_S_OUT_OF_MEMORY - This value will be returned if there is
insufficient memory available to allocate the unicode string.
--*/
{
USES_CONVERSION;
RPC_STATUS RpcStatus;
CHeapInThunk thunkStringBinding;
ATTEMPT_HEAP_IN_THUNK(thunkStringBinding, StringBinding);
RpcStatus = RpcBindingFromStringBinding(thunkStringBinding, Binding);
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcBindingToStringBinding) (
IN RPC_BINDING_HANDLE Binding,
OUT THUNK_CHAR **StringBinding
)
/*++
Routine Description:
This routine is the ansi thunk to RpcBindingToStringBindingW.
Return Value:
RPC_S_OUT_OF_MEMORY - We will return this value if we do not
have enough memory to convert the unicode string binding
into an ansi string binding.
--*/
{
RPC_STATUS RpcStatus;
COutDelThunk thunkStringBinding;
USES_CONVERSION;
RpcStatus = RpcBindingToStringBinding(Binding, thunkStringBinding);
if (RpcStatus != RPC_S_OK)
return(RpcStatus);
ATTEMPT_OUT_THUNK(thunkStringBinding, StringBinding);
return(RpcStatus);
}
/*
static RPC_STATUS
AnsiToUnicodeStringOptional (
IN unsigned char * String OPTIONAL,
OUT UNICODE_STRING * UnicodeString
)
++
Routine Description:
This routine is just the same as AnsiToUnicodeString, except that the
ansi string is optional. If no string is specified, then the buffer
of the unicode string is set to zero.
Arguments:
String - Optionally supplies an ansi string to convert to a unicode
string.
UnicodeString - Returns the converted unicode string.
Return Value:
RPC_S_OK - The ansi string was successfully converted into a unicode
string.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available for the unicode
string.
--
{
if (ARGUMENT_PRESENT(String))
return(AnsiToUnicodeString(String,UnicodeString));
UnicodeString->Buffer = 0;
return(RPC_S_OK);
}
*/
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcStringBindingCompose) (
IN THUNK_CHAR *ObjUuid OPTIONAL,
IN THUNK_CHAR *Protseq OPTIONAL,
IN THUNK_CHAR *NetworkAddr OPTIONAL,
IN THUNK_CHAR *Endpoint OPTIONAL,
IN THUNK_CHAR *Options OPTIONAL,
OUT THUNK_CHAR **StringBinding OPTIONAL
)
/*++
Routine Description:
This routine is the ansi thunk to RpcStringBindingComposeW.
Return Value:
RPC_S_OUT_OF_MEMORY - If insufficient memory is available to
convert unicode string into ansi strings (and back again),
we will return this value.
--*/
{
USES_CONVERSION;
CHeapInThunk thunkedObjUuid;
CStackInThunk thunkedProtseq;
CHeapInThunk thunkedNetworkAddr;
CHeapInThunk thunkedEndpoint;
CHeapInThunk thunkedOptions;
COutDelThunk thunkedStringBinding;
RPC_STATUS RpcStatus;
ATTEMPT_HEAP_IN_THUNK_OPTIONAL(thunkedObjUuid, ObjUuid);
ATTEMPT_STACK_IN_THUNK_OPTIONAL(thunkedProtseq, Protseq);
ATTEMPT_HEAP_IN_THUNK_OPTIONAL(thunkedNetworkAddr, NetworkAddr);
ATTEMPT_HEAP_IN_THUNK_OPTIONAL(thunkedEndpoint, Endpoint);
ATTEMPT_HEAP_IN_THUNK_OPTIONAL(thunkedOptions, Options);
RpcStatus = RpcStringBindingCompose(thunkedObjUuid, thunkedProtseq,
thunkedNetworkAddr, thunkedEndpoint, thunkedOptions,
thunkedStringBinding);
if (RpcStatus != RPC_S_OK)
return(RpcStatus);
if (ARGUMENT_PRESENT(StringBinding))
{
ATTEMPT_OUT_THUNK(thunkedStringBinding, StringBinding);
}
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcStringBindingParse) (
IN THUNK_CHAR * StringBinding,
OUT THUNK_CHAR **ObjUuid OPTIONAL,
OUT THUNK_CHAR **Protseq OPTIONAL,
OUT THUNK_CHAR **NetworkAddr OPTIONAL,
OUT THUNK_CHAR **Endpoint OPTIONAL,
OUT THUNK_CHAR **NetworkOptions OPTIONAL
)
/*++
Routine Description:
This routine is the ansi thunk to RpcStringBindingParseW.
Return Value:
RPC_S_OUT_OF_MEMORY - This will be returned if insufficient memory
is available to convert the strings to and from unicode.
--*/
{
USES_CONVERSION;
CHeapInThunk thunkedStringBinding;
COutDelThunk thunkedObjUuid;
COutDelThunk thunkedProtseq;
COutDelThunk thunkedNetworkAddr;
COutDelThunk thunkedEndpoint;
COutDelThunk thunkedNetworkOptions;
RPC_STATUS RpcStatus;
ATTEMPT_HEAP_IN_THUNK(thunkedStringBinding, StringBinding);
RpcStatus = RpcStringBindingParse(thunkedStringBinding,
thunkedObjUuid, thunkedProtseq, thunkedNetworkAddr,
thunkedEndpoint, thunkedNetworkOptions);
if (RpcStatus != RPC_S_OK)
return(RpcStatus);
if (ARGUMENT_PRESENT(Protseq))
*Protseq = 0;
if (ARGUMENT_PRESENT(NetworkAddr))
*NetworkAddr = 0;
if (ARGUMENT_PRESENT(Endpoint))
*Endpoint = 0;
if (ARGUMENT_PRESENT(NetworkOptions))
*NetworkOptions = 0;
if (ARGUMENT_PRESENT(ObjUuid))
{
RpcStatus = thunkedObjUuid.Convert();
if (RpcStatus != RPC_S_OK)
goto DeleteStringsAndReturn;
*ObjUuid = thunkedObjUuid;
}
if (ARGUMENT_PRESENT(Protseq))
{
RpcStatus = thunkedProtseq.Convert();
if (RpcStatus != RPC_S_OK)
goto DeleteStringsAndReturn;
*Protseq = thunkedProtseq;
}
if (ARGUMENT_PRESENT(NetworkAddr))
{
RpcStatus = thunkedNetworkAddr.Convert();
if (RpcStatus != RPC_S_OK)
goto DeleteStringsAndReturn;
*NetworkAddr = thunkedNetworkAddr;
}
if (ARGUMENT_PRESENT(Endpoint))
{
RpcStatus = thunkedEndpoint.Convert();
if (RpcStatus != RPC_S_OK)
goto DeleteStringsAndReturn;
*Endpoint = thunkedEndpoint;
}
if (ARGUMENT_PRESENT(NetworkOptions))
{
RpcStatus = thunkedNetworkOptions.Convert();
if (RpcStatus != RPC_S_OK)
goto DeleteStringsAndReturn;
*NetworkOptions = thunkedNetworkOptions;
}
DeleteStringsAndReturn:
if (RpcStatus != RPC_S_OK)
{
if (ARGUMENT_PRESENT(Protseq))
{
delete *Protseq;
*Protseq = 0;
}
if (ARGUMENT_PRESENT(NetworkAddr))
{
delete *NetworkAddr;
*NetworkAddr = 0;
}
if (ARGUMENT_PRESENT(Endpoint))
{
delete *Endpoint;
*Endpoint = 0;
}
if (ARGUMENT_PRESENT(NetworkOptions))
{
delete *NetworkOptions;
*NetworkOptions = 0;
}
}
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcNetworkIsProtseqValid) (
IN THUNK_CHAR *Protseq
)
/*++
Routine Description:
This routine is the ansi thunk to RpcNetworkIsProtseqValidW.
Return Value:
RPC_S_OUT_OF_MEMORY - We will return this value if we run out of
memory trying to allocate space for the string.
--*/
{
USES_CONVERSION;
CStackInThunk thunkedProtseq;
RPC_STATUS RpcStatus;
ATTEMPT_STACK_IN_THUNK(thunkedProtseq, Protseq);
RpcStatus = RpcNetworkIsProtseqValid(thunkedProtseq);
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcNetworkInqProtseqs) (
#ifdef UNICODE
OUT RPC_PROTSEQ_VECTORA PAPI * PAPI * ProtseqVector
#else
OUT RPC_PROTSEQ_VECTORW PAPI * PAPI * ProtseqVector
#endif
)
/*++
Routine Description:
This routine is the ansi thunk for RpcNetworkInqProtseqsW.
Return Value:
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to convert
the rpc protocol sequences from unicode into ansi.
--*/
{
RPC_STATUS RpcStatus;
RPC_CHAR *pString;
unsigned int Index, Count;
RpcStatus = RpcNetworkInqProtseqs(
(RPC_PROTSEQ_VECTOR **) ProtseqVector);
if (RpcStatus != RPC_S_OK)
return(RpcStatus);
for (Index = 0, Count = (*ProtseqVector)->Count; Index < Count; Index++)
{
pString = (RPC_CHAR *) (*ProtseqVector)->Protseq[Index];
#ifdef UNICODE
RpcStatus = W2AAttachHelper(pString, (char **) &((*ProtseqVector)->Protseq[Index]));
#else
RpcStatus = A2WAttachHelper((char *) pString, &((*ProtseqVector)->Protseq[Index]));
#endif
delete pString;
if (RpcStatus != RPC_S_OK)
{
#ifdef UNICODE
RpcProtseqVectorFreeA(ProtseqVector);
#else
RpcProtseqVectorFreeW(ProtseqVector);
#endif
return(RpcStatus);
}
}
return(RPC_S_OK);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcProtseqVectorFree) (
#ifdef UNICODE
IN OUT RPC_PROTSEQ_VECTORA PAPI * PAPI * ProtseqVector
#else
IN OUT RPC_PROTSEQ_VECTORW PAPI * PAPI * ProtseqVector
#endif
)
/*++
Routine Description:
This routine is the ansi thunk for RpcProtseqVectorFreeW.
--*/
{
return(RpcProtseqVectorFree((RPC_PROTSEQ_VECTOR **) ProtseqVector));
}
RPC_STATUS RPC_ENTRY
THUNK_FN(I_RpcServerUseProtseq2) (
IN THUNK_CHAR * NetworkAddress,
IN THUNK_CHAR * Protseq,
IN unsigned int MaxCalls,
IN void PAPI * SecurityDescriptor,
IN void * pPolicy
)
{
USES_CONVERSION;
CStackInThunk thunkProtseq;
CHeapInThunk thunkNetworkAddress;
RPC_STATUS RpcStatus;
PRPC_POLICY Policy = (PRPC_POLICY) pPolicy;
ATTEMPT_STACK_IN_THUNK(thunkProtseq, Protseq);
ATTEMPT_HEAP_IN_THUNK_OPTIONAL(thunkNetworkAddress, NetworkAddress);
RpcStatus = I_RpcServerUseProtseq2(thunkNetworkAddress, thunkProtseq, MaxCalls,
SecurityDescriptor, (void *) Policy);
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcServerUseProtseqEx) (
IN THUNK_CHAR *Protseq,
IN unsigned int MaxCalls,
IN void PAPI * SecurityDescriptor,
IN PRPC_POLICY Policy
)
/*++
Routine Description:
This is the ansi thunk to RpcServerUseProtseqW.
Return Value:
RPC_S_OUT_OF_MEMORY - If we do not have enough memory to convert
the ansi strings into unicode strings, this value will be returned.
--*/
{
return THUNK_FN(I_RpcServerUseProtseq2) (NULL, Protseq, MaxCalls, SecurityDescriptor, (void *) Policy) ;
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcServerUseProtseq) (
IN THUNK_CHAR *Protseq,
IN unsigned int MaxCalls,
IN void PAPI * SecurityDescriptor OPTIONAL
)
{
RPC_POLICY Policy ;
Policy.Length = sizeof(RPC_POLICY) ;
Policy.EndpointFlags = 0;
Policy.NICFlags = 0;
return THUNK_FN(I_RpcServerUseProtseq2) (NULL, Protseq, MaxCalls, SecurityDescriptor, (void *) &Policy) ;
}
RPC_STATUS RPC_ENTRY
THUNK_FN(I_RpcServerUseProtseqEp2) (
IN THUNK_CHAR * NetworkAddress,
IN THUNK_CHAR *Protseq,
IN unsigned int MaxCalls,
IN THUNK_CHAR *Endpoint,
IN void PAPI * SecurityDescriptor,
IN void * pPolicy
)
/*++
Routine Description:
This is the ansi thunk to RpcServerUseProtseqEpW.
Return Value:
RPC_S_OUT_OF_MEMORY - If we do not have enough memory to convert
the ansi strings into unicode strings, this value will be returned.
--*/
{
USES_CONVERSION;
CStackInThunk thunkedProtseq;
CHeapInThunk thunkedEndpoint;
CHeapInThunk thunkedNetworkAddress;
PRPC_POLICY Policy = (PRPC_POLICY) pPolicy;
ATTEMPT_STACK_IN_THUNK(thunkedProtseq, Protseq);
ATTEMPT_HEAP_IN_THUNK(thunkedEndpoint, Endpoint);
ATTEMPT_HEAP_IN_THUNK_OPTIONAL(thunkedNetworkAddress, NetworkAddress);
return (I_RpcServerUseProtseqEp2(thunkedNetworkAddress, thunkedProtseq, MaxCalls,
thunkedEndpoint, SecurityDescriptor,
(void *) Policy));
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcServerUseProtseqEpEx) (
IN THUNK_CHAR *Protseq,
IN unsigned int MaxCalls,
IN THUNK_CHAR *Endpoint,
IN void PAPI * SecurityDescriptor,
IN PRPC_POLICY Policy
)
/*++
Routine Description:
This is the ansi thunk to RpcServerUseProtseqEpW.
Return Value:
RPC_S_OUT_OF_MEMORY - If we do not have enough memory to convert
the ansi strings into unicode strings, this value will be returned.
--*/
{
return THUNK_FN(I_RpcServerUseProtseqEp2) (NULL, Protseq, MaxCalls, Endpoint,
SecurityDescriptor, (void *) Policy) ;
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcServerUseProtseqEp) (
IN THUNK_CHAR *Protseq,
IN unsigned int MaxCalls,
IN THUNK_CHAR *Endpoint,
IN void PAPI * SecurityDescriptor
)
{
RPC_POLICY Policy ;
Policy.Length = sizeof(RPC_POLICY) ;
Policy.EndpointFlags = 0;
Policy.NICFlags = 0;
return THUNK_FN(I_RpcServerUseProtseqEp2) (NULL, Protseq, MaxCalls, Endpoint,
SecurityDescriptor, (void *) &Policy) ;
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcServerUseProtseqIfEx) (
IN THUNK_CHAR *Protseq,
IN unsigned int MaxCalls,
IN RPC_IF_HANDLE IfSpec,
IN void PAPI * SecurityDescriptor,
IN PRPC_POLICY Policy
)
/*++
Routine Description:
This is the ansi thunk to RpcServerUseProtseqIfW.
Return Value:
RPC_S_OUT_OF_MEMORY - If we do not have enough memory to convert
the ansi strings into unicode strings, this value will be returned.
--*/
{
USES_CONVERSION;
CStackInThunk thunkedProtseq;
ATTEMPT_STACK_IN_THUNK(thunkedProtseq, Protseq);
return (RpcServerUseProtseqIfEx(thunkedProtseq, MaxCalls,
IfSpec, SecurityDescriptor, Policy));
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcServerUseProtseqIf) (
IN THUNK_CHAR *Protseq,
IN unsigned int MaxCalls,
IN RPC_IF_HANDLE IfSpec,
IN void PAPI * SecurityDescriptor
)
{
RPC_POLICY Policy ;
Policy.Length = sizeof(RPC_POLICY) ;
Policy.EndpointFlags = 0;
Policy.NICFlags = 0;
return THUNK_FN(RpcServerUseProtseqIfEx) ( Protseq, MaxCalls, IfSpec,
SecurityDescriptor, &Policy) ;
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcNsBindingInqEntryName) (
IN RPC_BINDING_HANDLE Binding,
IN unsigned long EntryNameSyntax,
OUT THUNK_CHAR **EntryName
)
/*++
Routine Description:
This routine is the ansi thunk to RpcNsBindingInqEntryNameW.
Return Value:
RPC_S_OUT_OF_MEMORY - We will return this value if we do not
have enough memory to convert the unicode entry name into
an ansi entry name.
--*/
{
RPC_STATUS RpcStatus;
USES_CONVERSION;
COutDelThunk thunkedEntryName;
RpcStatus = RpcNsBindingInqEntryName(Binding, EntryNameSyntax,
thunkedEntryName);
if ( RpcStatus == RPC_S_NO_ENTRY_NAME )
{
ATTEMPT_OUT_THUNK(thunkedEntryName, EntryName);
return(RPC_S_NO_ENTRY_NAME);
}
if ( RpcStatus != RPC_S_OK )
{
return(RpcStatus);
}
ATTEMPT_OUT_THUNK(thunkedEntryName, EntryName);
return(RPC_S_OK);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(UuidToString) (
IN UUID PAPI * Uuid,
OUT THUNK_CHAR **StringUuid
)
/*++
Routine Description:
This routine converts a UUID into its string representation.
Arguments:
Uuid - Supplies the UUID to be converted into string representation.
StringUuid - Returns the string representation of the UUID. The
runtime will allocate the string. The caller is responsible for
freeing the string using RpcStringFree.
Return Value:
RPC_S_OK - We successfully converted the UUID into its string
representation.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to allocate
a string.
--*/
{
// The string representation of a UUID is always 36 character long,
// and we need one more for the terminating zero.
RPC_CHAR String[37];
RPC_STATUS RpcStatus;
InitializeIfNecessary();
((RPC_UUID PAPI *) Uuid)->ConvertToString(String);
String[36] = 0;
#ifdef UNICODE
return W2AAttachHelper(String, (char **)StringUuid);
#else
return A2WAttachHelper((char *)String, StringUuid);
#endif
}
RPC_STATUS RPC_ENTRY
THUNK_FN(UuidFromString) (
IN THUNK_CHAR *StringUuid OPTIONAL,
OUT UUID PAPI * Uuid
)
/*++
Routine Description:
We convert a UUID from its string representation into the binary
representation.
Arguments:
StringUuid - Optionally supplies the string representation of the UUID;
if this argument is not supplied, then the NIL UUID is returned.
Uuid - Returns the binary representation of the UUID.
Return Value:
RPC_S_OK - The string representation was successfully converted into
the binary representation.
RPC_S_INVALID_STRING_UUID - The supplied string UUID is not correct.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to convert the
ansi string into a unicode string.
--*/
{
RPC_UUID RpcUuid;
RPC_STATUS RpcStatus;
USES_CONVERSION;
CHeapInThunk thunkedStringUuid;
if ( StringUuid == 0 )
{
((RPC_UUID PAPI *) Uuid)->SetToNullUuid();
return(RPC_S_OK);
}
ATTEMPT_HEAP_IN_THUNK(thunkedStringUuid, StringUuid);
if (RpcUuid.ConvertFromString(thunkedStringUuid) != 0)
{
return(RPC_S_INVALID_STRING_UUID);
}
((RPC_UUID PAPI *) Uuid)->CopyUuid(&RpcUuid);
return(RPC_S_OK);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcServerRegisterAuthInfo) (
IN THUNK_CHAR *ServerPrincName,
IN unsigned long AuthnSvc,
IN RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn OPTIONAL,
IN void PAPI * Arg OPTIONAL
)
/*++
Routine Description:
This routine is the ansi thunk to RpcServerRegisterAuthInfoW.
Return Value:
RPC_S_OUT_OF_MEMORY - We will return this value if we do not have
enough memory to convert the ansi server principal name into
a unicode string.
--*/
{
USES_CONVERSION;
CHeapInThunk thunkedServerPrincName;
RPC_STATUS RpcStatus;
ATTEMPT_HEAP_IN_THUNK(thunkedServerPrincName, ServerPrincName);
RpcStatus = RpcServerRegisterAuthInfo(thunkedServerPrincName, AuthnSvc,
GetKeyFn, Arg);
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcBindingInqAuthClient) (
IN RPC_BINDING_HANDLE ClientBinding, OPTIONAL
OUT RPC_AUTHZ_HANDLE PAPI * Privs,
OUT THUNK_CHAR **PrincName, OPTIONAL
OUT unsigned long PAPI * AuthnLevel, OPTIONAL
OUT unsigned long PAPI * AuthnSvc, OPTIONAL
OUT unsigned long PAPI * AuthzSvc OPTIONAL
)
{
return THUNK_FN(RpcBindingInqAuthClientEx)( ClientBinding,
Privs,
PrincName,
AuthnLevel,
AuthnSvc,
AuthzSvc,
0
);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcBindingInqAuthClientEx) (
IN RPC_BINDING_HANDLE ClientBinding, OPTIONAL
OUT RPC_AUTHZ_HANDLE PAPI * Privs,
OUT THUNK_CHAR **ServerPrincName, OPTIONAL
OUT unsigned long PAPI * AuthnLevel, OPTIONAL
OUT unsigned long PAPI * AuthnSvc, OPTIONAL
OUT unsigned long PAPI * AuthzSvc, OPTIONAL
IN unsigned long Flags
)
/*++
Routine Description:
This routine is the ansi thunk for RpcBindingInqAuthClientW.
Return Value:
RPC_S_OUT_OF_MEMORY - If we can not allocate space to convert the
unicode server principal name into unicode, we will return this
value.
--*/
{
RPC_STATUS RpcStatus;
USES_CONVERSION;
COutDelThunk thunkedServerPrincName;
RpcStatus = RpcBindingInqAuthClientEx(ClientBinding,
Privs,
(ARGUMENT_PRESENT(ServerPrincName) ? (RPC_CHAR **)thunkedServerPrincName : 0),
AuthnLevel,
AuthnSvc,
AuthzSvc,
Flags);
if ( RpcStatus != RPC_S_OK )
{
return(RpcStatus);
}
if (ARGUMENT_PRESENT(ServerPrincName))
{
ATTEMPT_OUT_THUNK_OPTIONAL(thunkedServerPrincName, ServerPrincName);
}
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcServerInqCallAttributes) (
IN RPC_BINDING_HANDLE ClientBinding, OPTIONAL
IN OUT void *RpcCallAttributes
)
/*++
Routine Description:
This routine is the ansi thunk for RpcServerInqCallAttributes.
Return Value:
RPC_S_OUT_OF_MEMORY - If we can not allocate space to convert the
unicode server principal name into unicode, we will return this
value.
The API can in addition return all errors returned by the Unicode
version.
--*/
{
RPC_STATUS RpcStatus;
USES_CONVERSION;
COutDelThunk thunkedServerPrincName;
RPC_CALL_ATTRIBUTES_V1_W *CallAttributesW;
RPC_CALL_ATTRIBUTES_V1_A *CallAttributesA;
unsigned char *OldClientPrincipalNameBuffer;
RPC_CHAR *NewClientPrincipalNameBuffer = NULL;
ULONG OldClientPrincipalNameBufferLength;
ULONG NewClientPrincipalNameBufferLength;
unsigned char *OldServerPrincipalNameBuffer;
RPC_CHAR *NewServerPrincipalNameBuffer = NULL;
ULONG OldServerPrincipalNameBufferLength;
ULONG NewServerPrincipalNameBufferLength;
// we use the same structure to pass to the unicode API, but
// we save some data members
CallAttributesW =
(RPC_CALL_ATTRIBUTES_V1_W *)RpcCallAttributes;
CallAttributesA =
(RPC_CALL_ATTRIBUTES_V1_A *)RpcCallAttributes;
if (CallAttributesW->Flags & RPC_QUERY_CLIENT_PRINCIPAL_NAME)
{
OldClientPrincipalNameBuffer = CallAttributesA->ClientPrincipalName;
OldClientPrincipalNameBufferLength = CallAttributesA->ClientPrincipalNameBufferLength;
if (OldClientPrincipalNameBufferLength != 0)
{
NewClientPrincipalNameBuffer = new RPC_CHAR[OldClientPrincipalNameBufferLength];
if (NewClientPrincipalNameBuffer == NULL)
{
return RPC_S_OUT_OF_MEMORY;
}
}
else
{
// here CallAttributesW->ClientPrincipalName must be NULL. If it's
// not, the unicode function will return error. Delegate the check to it
NewClientPrincipalNameBuffer = CallAttributesW->ClientPrincipalName;
}
}
if (CallAttributesW->Flags & RPC_QUERY_SERVER_PRINCIPAL_NAME)
{
OldServerPrincipalNameBuffer = CallAttributesA->ServerPrincipalName;
OldServerPrincipalNameBufferLength = CallAttributesA->ServerPrincipalNameBufferLength;
if (OldServerPrincipalNameBufferLength != 0)
{
NewServerPrincipalNameBuffer = new RPC_CHAR[OldServerPrincipalNameBufferLength];
if (NewServerPrincipalNameBuffer == NULL)
{
if ((CallAttributesW->Flags & RPC_QUERY_CLIENT_PRINCIPAL_NAME)
&& (OldClientPrincipalNameBufferLength != 0))
{
ASSERT(NewClientPrincipalNameBuffer != NULL);
delete NewClientPrincipalNameBuffer;
}
return RPC_S_OUT_OF_MEMORY;
}
}
else
{
// here CallAttributesW->ServerPrincipalName must be NULL. If it's
// not, the unicode function will return error. Delegate the check to it
NewServerPrincipalNameBuffer = CallAttributesW->ServerPrincipalName;
}
}
// by now all buffers are allocated, so we don't have failure paths b/n
// here and the API call
if (CallAttributesW->Flags & RPC_QUERY_SERVER_PRINCIPAL_NAME)
{
CallAttributesW->ServerPrincipalName = NewServerPrincipalNameBuffer;
CallAttributesW->ServerPrincipalNameBufferLength *= 2;
}
if (CallAttributesW->Flags & RPC_QUERY_CLIENT_PRINCIPAL_NAME)
{
CallAttributesW->ClientPrincipalName = NewClientPrincipalNameBuffer;
CallAttributesW->ClientPrincipalNameBufferLength *= 2;
}
RpcStatus = RpcServerInqCallAttributes(ClientBinding,
RpcCallAttributes
);
// restore user's values to the structure regardless of failure
if (CallAttributesW->Flags & RPC_QUERY_CLIENT_PRINCIPAL_NAME)
{
NewClientPrincipalNameBufferLength = CallAttributesA->ClientPrincipalNameBufferLength;
CallAttributesA->ClientPrincipalNameBufferLength = OldClientPrincipalNameBufferLength;
CallAttributesA->ClientPrincipalName = OldClientPrincipalNameBuffer;
};
if (CallAttributesW->Flags & RPC_QUERY_SERVER_PRINCIPAL_NAME)
{
NewServerPrincipalNameBufferLength = CallAttributesA->ServerPrincipalNameBufferLength;
CallAttributesA->ServerPrincipalNameBufferLength = OldServerPrincipalNameBufferLength;
CallAttributesA->ServerPrincipalName = OldServerPrincipalNameBuffer;
};
if ((RpcStatus != RPC_S_OK)
&& (RpcStatus != ERROR_MORE_DATA))
{
if ((CallAttributesW->Flags & RPC_QUERY_CLIENT_PRINCIPAL_NAME)
&& (OldClientPrincipalNameBufferLength != 0))
{
ASSERT(NewClientPrincipalNameBuffer != NULL);
delete NewClientPrincipalNameBuffer;
}
if ((CallAttributesW->Flags & RPC_QUERY_SERVER_PRINCIPAL_NAME)
&& (OldServerPrincipalNameBufferLength != 0))
{
ASSERT(NewServerPrincipalNameBuffer != NULL);
delete NewServerPrincipalNameBuffer;
}
return(RpcStatus);
}
ASSERT((RpcStatus == RPC_S_OK)
|| (RpcStatus == ERROR_MORE_DATA));
if (CallAttributesW->Flags & RPC_QUERY_SERVER_PRINCIPAL_NAME)
{
CallAttributesW->ServerPrincipalNameBufferLength = NewServerPrincipalNameBufferLength >> 1;
// if we returned non-zero, and there was enough space in the string to start with, we must
// have returned a string as well
if ((CallAttributesW->ServerPrincipalNameBufferLength > 0)
&& (CallAttributesW->ServerPrincipalNameBufferLength <= OldServerPrincipalNameBufferLength))
{
RtlUnicodeToMultiByteN((char *)CallAttributesA->ServerPrincipalName,
CallAttributesA->ServerPrincipalNameBufferLength,
NULL,
NewServerPrincipalNameBuffer,
NewServerPrincipalNameBufferLength);
}
}
if (CallAttributesW->Flags & RPC_QUERY_CLIENT_PRINCIPAL_NAME)
{
CallAttributesW->ClientPrincipalNameBufferLength = NewClientPrincipalNameBufferLength >> 1;
// if we returned non-zero, and there was enough space in the string to start with, we must
// have returned a string as well
if ((CallAttributesW->ClientPrincipalNameBufferLength > 0)
&& (CallAttributesW->ClientPrincipalNameBufferLength <= OldClientPrincipalNameBufferLength))
{
RtlUnicodeToMultiByteN((char *)CallAttributesA->ClientPrincipalName,
CallAttributesA->ClientPrincipalNameBufferLength,
NULL,
NewClientPrincipalNameBuffer,
NewClientPrincipalNameBufferLength);
}
}
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcBindingInqAuthInfo) (
IN RPC_BINDING_HANDLE Binding,
OUT THUNK_CHAR **ServerPrincName, OPTIONAL
OUT unsigned long PAPI * AuthnLevel, OPTIONAL
OUT unsigned long PAPI * AuthnSvc, OPTIONAL
OUT RPC_AUTH_IDENTITY_HANDLE PAPI * AuthIdentity, OPTIONAL
OUT unsigned long PAPI * AuthzSvc OPTIONAL
)
/*++
Routine Description:
This routine is the ansi thunk for RpcBindingInqAuthInfoW.
Return Value:
RPC_S_OUT_OF_MEMORY - If we can not allocate space to convert the
unicode server principal name into unicode, we will return this
value.
--*/
{
RPC_STATUS RpcStatus;
return( THUNK_FN(RpcBindingInqAuthInfoEx) (
Binding,
ServerPrincName,
AuthnLevel,
AuthnSvc,
AuthIdentity,
AuthzSvc,
0,
0
) );
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcBindingInqAuthInfoEx) (
IN RPC_BINDING_HANDLE Binding,
OUT THUNK_CHAR **ServerPrincName, OPTIONAL
OUT unsigned long PAPI * AuthnLevel, OPTIONAL
OUT unsigned long PAPI * AuthnSvc, OPTIONAL
OUT RPC_AUTH_IDENTITY_HANDLE PAPI * AuthIdentity, OPTIONAL
OUT unsigned long PAPI * AuthzSvc, OPTIONAL
IN unsigned long RpcSecurityQosVersion,
OUT RPC_SECURITY_QOS * SecurityQOS
)
/*++
Routine Description:
This routine is the ansi thunk for RpcBindingInqAuthInfoW.
Return Value:
RPC_S_OUT_OF_MEMORY - If we can not allocate space to convert the
unicode server principal name into unicode, we will return this
value.
--*/
{
RPC_STATUS RpcStatus;
USES_CONVERSION;
COutDelThunk thunkedServerPrincName;
RpcStatus = RpcBindingInqAuthInfoEx(
Binding,
(ARGUMENT_PRESENT(ServerPrincName) ? (RPC_CHAR **)thunkedServerPrincName : 0),
AuthnLevel,
AuthnSvc,
AuthIdentity,
AuthzSvc,
RpcSecurityQosVersion,
SecurityQOS
);
if ( RpcStatus != RPC_S_OK )
{
return(RpcStatus);
}
if (ARGUMENT_PRESENT(ServerPrincName))
{
ATTEMPT_OUT_THUNK(thunkedServerPrincName, ServerPrincName);
}
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcBindingSetAuthInfo)(
IN RPC_BINDING_HANDLE Binding,
IN THUNK_CHAR *ServerPrincName,
IN unsigned long AuthnLevel,
IN unsigned long AuthnSvc,
IN RPC_AUTH_IDENTITY_HANDLE AuthIdentity, OPTIONAL
IN unsigned long AuthzSvc
)
{
return ( THUNK_FN(RpcBindingSetAuthInfoEx)(
Binding,
ServerPrincName,
AuthnLevel,
AuthnSvc,
AuthIdentity,
AuthzSvc,
0
) );
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcBindingSetAuthInfoEx) (
IN RPC_BINDING_HANDLE Binding,
IN THUNK_CHAR *ServerPrincName,
IN unsigned long AuthnLevel,
IN unsigned long AuthnSvc,
IN RPC_AUTH_IDENTITY_HANDLE AuthIdentity, OPTIONAL
IN unsigned long AuthzSvc,
IN RPC_SECURITY_QOS * SecurityQOS
)
/*++
Routine Description:
This routine is the ansi thunk for RpcBindingSetAuthInfoW.
Return Value:
RPC_S_OUT_OF_MEMORY - We will return this value if we do not have
enough memory to convert the ansi server principal name into
a unicode string.
--*/
{
USES_CONVERSION;
CHeapInThunk thunkedServerPrincName;
RPC_STATUS RpcStatus;
RPC_HTTP_TRANSPORT_CREDENTIALS_A *HttpCredentials;
ULONG AdditionalTransportCredentialsType;
RPC_SECURITY_QOS_V2_W SecurityQOS2;
RPC_SECURITY_QOS_V2_W *SecurityQOSToUse;
ATTEMPT_HEAP_IN_THUNK(thunkedServerPrincName, ServerPrincName);
if (SecurityQOS)
{
if (SecurityQOS->Version == RPC_C_SECURITY_QOS_VERSION_1)
{
RpcpMemoryCopy(&SecurityQOS2, SecurityQOS, sizeof(RPC_SECURITY_QOS));
SecurityQOS2.AdditionalSecurityInfoType = 0;
SecurityQOS2.u.HttpCredentials = NULL;
}
else
{
RpcpMemoryCopy(&SecurityQOS2, SecurityQOS, sizeof(RPC_SECURITY_QOS_V2_A));
AdditionalTransportCredentialsType = ((RPC_SECURITY_QOS_V2 *)SecurityQOS)->AdditionalSecurityInfoType;
HttpCredentials = ((RPC_SECURITY_QOS_V2_A *)SecurityQOS)->u.HttpCredentials;
if (AdditionalTransportCredentialsType != RPC_C_AUTHN_INFO_TYPE_HTTP)
{
if (AdditionalTransportCredentialsType != 0)
return(RPC_S_INVALID_ARG);
if (HttpCredentials != NULL)
return(RPC_S_INVALID_ARG);
}
else if (HttpCredentials == NULL)
return(RPC_S_INVALID_ARG);
else
{
if (HttpCredentials->TransportCredentials)
{
if (HttpCredentials->TransportCredentials->User)
{
if (RpcpStringLengthA((const char *)HttpCredentials->TransportCredentials->User)
!= HttpCredentials->TransportCredentials->UserLength)
{
return(RPC_S_INVALID_ARG);
}
}
else if (HttpCredentials->TransportCredentials->UserLength)
return(RPC_S_INVALID_ARG);
if (HttpCredentials->TransportCredentials->Domain)
{
if (RpcpStringLengthA((const char *)HttpCredentials->TransportCredentials->Domain)
!= HttpCredentials->TransportCredentials->DomainLength)
{
return(RPC_S_INVALID_ARG);
}
}
else if (HttpCredentials->TransportCredentials->DomainLength)
return(RPC_S_INVALID_ARG);
if (HttpCredentials->TransportCredentials->Password)
{
if (RpcpStringLengthA((const char *)HttpCredentials->TransportCredentials->Password)
!= HttpCredentials->TransportCredentials->PasswordLength)
{
return(RPC_S_INVALID_ARG);
}
}
else if (HttpCredentials->TransportCredentials->PasswordLength)
return(RPC_S_INVALID_ARG);
if (HttpCredentials->TransportCredentials->Flags != SEC_WINNT_AUTH_IDENTITY_ANSI)
return(RPC_S_INVALID_ARG);
}
// if you don't want to authenticate against anyone, you can't authenticate
if (HttpCredentials->AuthenticationTarget == 0)
return(RPC_S_INVALID_ARG);
// if you don't support any method of authentication, you can't authenticate
if (HttpCredentials->NumberOfAuthnSchemes == 0)
return(RPC_S_INVALID_ARG);
// if you don't support any method of authentication, you can't authenticate
if (HttpCredentials->AuthnSchemes == NULL)
return(RPC_S_INVALID_ARG);
SecurityQOS2.u.HttpCredentials = ConvertToUnicodeHttpTransportCredentials (
HttpCredentials);
if (SecurityQOS2.u.HttpCredentials == NULL)
return RPC_S_OUT_OF_MEMORY;
}
}
SecurityQOSToUse = &SecurityQOS2;
}
else
{
SecurityQOSToUse = NULL;
}
RpcStatus = RpcBindingSetAuthInfoEx(Binding, thunkedServerPrincName,
AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvc, (RPC_SECURITY_QOS *)SecurityQOSToUse);
if (SecurityQOSToUse && (SecurityQOS2.AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP))
{
// free the converted credentials
WipeOutAuthIdentity(SecurityQOS2.u.HttpCredentials->TransportCredentials);
FreeHttpTransportCredentials(SecurityQOS2.u.HttpCredentials);
}
return(RpcStatus);
}
RPC_STATUS RPC_ENTRY
THUNK_FN(RpcMgmtInqServerPrincName) (
IN RPC_BINDING_HANDLE Binding,
IN unsigned long AuthnSvc,
OUT THUNK_CHAR **ServerPrincName
)
/*++
Routine Description:
This routine is the ansi thunk for RpcMgmtInqServerPrincNameW.
Return Value:
RPC_S_OUT_OF_MEMORY - We will return this value if we do not have
enough memory to convert the unicode server principal name into
an ansi string.
--*/
{
RPC_STATUS RpcStatus;
USES_CONVERSION;
COutDelThunk thunkedServerPrincName;
RpcStatus = RpcMgmtInqServerPrincName(Binding, AuthnSvc, thunkedServerPrincName);
if ( RpcStatus != RPC_S_OK )
{
return(RpcStatus);
}
ATTEMPT_OUT_THUNK(thunkedServerPrincName, ServerPrincName);
return(RPC_S_OK);
}
RPCRTAPI
RPC_STATUS
RPC_ENTRY
THUNK_FN(RpcCertGeneratePrincipalName)(
PCCERT_CONTEXT Context,
DWORD Flags,
OUT THUNK_CHAR **pBuffer
)
{
USES_CONVERSION;
COutDelThunk thunkedServerPrincName;
RPC_STATUS Status = RpcCertGeneratePrincipalName( Context,
Flags,
thunkedServerPrincName
);
if (Status != RPC_S_OK)
{
return Status;
}
ATTEMPT_OUT_THUNK(thunkedServerPrincName, pBuffer);
return Status;
}
Reference in a new issue Copy permalink