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.
1588 lines
36 KiB
1588 lines
36 KiB
/*++
|
|
|
|
Copyright (C) Microsoft Corporation, 1992 - 1999
|
|
|
|
Module Name:
|
|
|
|
lpcsvr.hxx
|
|
|
|
Abstract:
|
|
|
|
Class definition for the server side of RPC on LPC protocol
|
|
engine.
|
|
|
|
Author:
|
|
|
|
Steven Zeck (stevez) 12/17/91 (spcsvr.hxx)
|
|
|
|
Revision History:
|
|
|
|
16-Dec-1992 mikemon
|
|
|
|
Rewrote the majority of the code and added comments.
|
|
|
|
-- mazharm code fork from spcsvr.hxx
|
|
|
|
05/13/96 mazharm merged WMSG/LRPC into a common protocol
|
|
9/22/97 no more WMSG
|
|
|
|
Kamen Moutafov (kamenm) Jan-2000 Support for multiple transfer syntaxes
|
|
Kamen Moutafov (KamenM) Dec 99 - Feb 2000 - Support for cell debugging stuff
|
|
--*/
|
|
|
|
#ifndef __LPCSVR_HXX__
|
|
#define __LPCSVR_HXX__
|
|
|
|
class LRPC_SASSOCIATION;
|
|
class LRPC_CASSOCIATION;
|
|
class LRPC_ADDRESS;
|
|
class LRPC_SERVER ;
|
|
class LRPC_SCALL ;
|
|
class LRPC_SERVER ;
|
|
class LRPC_CASSOCIATION_DICT;
|
|
|
|
|
|
// the next four are protected by the LrpcMutex
|
|
extern LRPC_CASSOCIATION_DICT * LrpcAssociationDict;
|
|
|
|
// the number of associations in the LrpcAssociationDict
|
|
// dictionary that have their fAssociationLingered member set
|
|
extern long LrpcLingeredAssociations;
|
|
|
|
// the total number of LRPC associations destroyed in this process
|
|
// this is used to dynamically turn on garbage collection if
|
|
// necessary
|
|
extern ULONG LrpcDestroyedAssociations;
|
|
|
|
// each time the number of destroyed associations is divisible by
|
|
// NumberOfLrpcDestroyedAssociationsToSample, we check this timestamp
|
|
// and compare it to the current. If the difference is more than
|
|
// DestroyedLrpcAssociationBatchThreshold, we will turn on
|
|
// garbage collection automatically
|
|
extern ULARGE_INTEGER LastDestroyedAssociationsBatchTimestamp;
|
|
|
|
const ULONG NumberOfLrpcDestroyedAssociationsToSample = 128;
|
|
|
|
// in 100 nano-second intervals, this constant is 1 second
|
|
const DWORD DestroyedLrpcAssociationBatchThreshold = 1000 * 10 * 1000;
|
|
|
|
// 4 is an arbitrary number designed to ensure reasonably sized cache
|
|
// Feel free to change it if there is a perf reason for that
|
|
const long MaxLrpcLingeredAssociations = 4;
|
|
extern LRPC_SERVER *GlobalLrpcServer;
|
|
|
|
RPC_STATUS
|
|
InitializeLrpcServer(
|
|
) ;
|
|
|
|
extern RPC_STATUS
|
|
InitializeLrpcIfNecessary(
|
|
) ;
|
|
|
|
#define LrpcSetEndpoint(Endpoint) (\
|
|
GlobalLrpcServer->SetEndpoint(Endpoint))
|
|
#define LrpcGetEndpoint(Endpoint) (\
|
|
GlobalLrpcServer->GetEndpoint(Endpoint))
|
|
|
|
NEW_SDICT(LRPC_SASSOCIATION);
|
|
NEW_SDICT(LRPC_SCALL) ;
|
|
|
|
#define SERVER_KEY_MASK 0x8000
|
|
#define SERVERKEY(_x_) ((_x_) & 0x80000000)
|
|
|
|
#define CLEANUP goto cleanup
|
|
|
|
#define COPYMSG(LrpcCopy, LrpcMessage) \
|
|
LrpcCopy->LpcHeader.ClientId = LrpcMessage->LpcHeader.ClientId ; \
|
|
LrpcCopy->LpcHeader.CallbackId = LrpcMessage->LpcHeader.CallbackId ; \
|
|
LrpcCopy->LpcHeader.MessageId = LrpcMessage->LpcHeader.MessageId ; \
|
|
LrpcCopy->LpcHeader.u2.s2.DataInfoOffset = \
|
|
LrpcMessage->LpcHeader.u2.s2.DataInfoOffset
|
|
|
|
#define INITMSG(LrpcMessage, CId, Cbd, MId) \
|
|
(LrpcMessage)->LpcHeader.ClientId = ClientIdToMsgClientId(CId) ;\
|
|
(LrpcMessage)->LpcHeader.CallbackId = Cbd ;\
|
|
(LrpcMessage)->LpcHeader.MessageId = MId
|
|
|
|
#define AllocateMessage() ((LRPC_MESSAGE *) RpcAllocateBuffer(sizeof(LRPC_MESSAGE)))
|
|
#define FreeMessage(x) (RpcFreeBuffer((x)))
|
|
|
|
//
|
|
// The high bit of the sequence number
|
|
// is used to determine if it is a client or server
|
|
// key.
|
|
// CAUTION: Big endian implementations need to swap this
|
|
// around
|
|
//
|
|
typedef struct {
|
|
USHORT AssocKey;
|
|
USHORT SeqNumber;
|
|
} LPC_KEY;
|
|
|
|
|
|
|
|
class LRPC_SERVER
|
|
{
|
|
private:
|
|
LRPC_ADDRESS *Address ;
|
|
RPC_CHAR * Endpoint;
|
|
BOOL EndpointInitialized ;
|
|
MUTEX ServerMutex ;
|
|
|
|
public:
|
|
LRPC_SERVER(
|
|
IN OUT RPC_STATUS *Status
|
|
) ;
|
|
|
|
RPC_STATUS
|
|
InitializeAsync (
|
|
) ;
|
|
|
|
void
|
|
GetEndpoint(
|
|
IN RPC_CHAR *Endpoint
|
|
)
|
|
{
|
|
RpcpStringCopy(Endpoint, this->Endpoint) ;
|
|
}
|
|
|
|
RPC_STATUS
|
|
SetEndpoint(
|
|
IN RPC_CHAR *Endpoint
|
|
)
|
|
{
|
|
if (EndpointInitialized == 0)
|
|
{
|
|
this->Endpoint = DuplicateString(Endpoint) ;
|
|
if (this->Endpoint == 0)
|
|
{
|
|
return RPC_S_OUT_OF_MEMORY ;
|
|
}
|
|
|
|
EndpointInitialized = 1 ;
|
|
}
|
|
|
|
return RPC_S_OK ;
|
|
}
|
|
|
|
void
|
|
AcquireMutex(
|
|
)
|
|
{
|
|
ServerMutex.Request() ;
|
|
}
|
|
|
|
void
|
|
ReleaseMutex(
|
|
)
|
|
{
|
|
ServerMutex.Clear() ;
|
|
}
|
|
|
|
void VerifyOwned(void)
|
|
{
|
|
ServerMutex.VerifyOwned();
|
|
}
|
|
|
|
BOOL
|
|
TryRequestMutex (
|
|
void
|
|
)
|
|
{
|
|
return ServerMutex.TryRequest();
|
|
}
|
|
} ;
|
|
|
|
inline void LrpcMutexRequest(void)
|
|
{
|
|
GlobalLrpcServer->AcquireMutex();
|
|
}
|
|
|
|
inline void LrpcMutexClear(void)
|
|
{
|
|
GlobalLrpcServer->ReleaseMutex();
|
|
}
|
|
|
|
inline void LrpcMutexVerifyOwned(void)
|
|
{
|
|
GlobalLrpcServer->VerifyOwned();
|
|
}
|
|
|
|
inline BOOL LrpcMutexTryRequest(void)
|
|
{
|
|
return GlobalLrpcServer->TryRequestMutex();
|
|
}
|
|
|
|
|
|
class LRPC_ADDRESS : public RPC_ADDRESS
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
Fields:
|
|
|
|
LpcAddressPort - Contains the connection port which this address will
|
|
use to wait for clients to connect.
|
|
|
|
CallThreadCount - Contains the number of call threads we have executing.
|
|
|
|
MinimumCallThreads - Contains the minimum number of call threads.
|
|
|
|
ServerListeningFlag - Contains a flag indicating whether or not the server
|
|
is listening for remote procedure calls. A non-zero value indicates
|
|
that it is listening.
|
|
|
|
ActiveCallCount - Contains the number of remote procedure calls active
|
|
on this address.
|
|
|
|
AssociationDictionary - Contains the dictionary of associations on this
|
|
address. We need this to map from an association key into the
|
|
correct association. This is necessary to prevent a race condition
|
|
between deleting an association and using it.
|
|
|
|
--*/
|
|
{
|
|
private:
|
|
|
|
HANDLE LpcAddressPort;
|
|
long CallThreadCount;
|
|
long MinimumCallThreads;
|
|
LRPC_SASSOCIATION_DICT AssociationDictionary;
|
|
int AssociationCount ;
|
|
USHORT SequenceNumber;
|
|
CellTag DebugCellTag;
|
|
DebugEndpointInfo *DebugCell;
|
|
|
|
// not protected - operated by interlocks. We push on the list,
|
|
// but we never pop, knowing addresses don't get deleted.
|
|
LRPC_ADDRESS *AddressChain;
|
|
|
|
// the next three are protected by the LrpcMutex
|
|
// If TickleMessage is non-zero, this means that the
|
|
// address has been prepared for tickling. Once it
|
|
// is initialized, fTickleMessageAvailable is used
|
|
// to tell whether the TickleMessage is currently posted
|
|
// or not. If it is already posted, no need to repost.
|
|
BOOL fTickleMessageAvailable;
|
|
LRPC_BIND_EXCHANGE *TickleMessage;
|
|
UNICODE_STRING ThisAddressLoopbackString;
|
|
|
|
// the number of threads on this address doing long wait
|
|
INTERLOCKED_INTEGER ThreadsDoingLongWait;
|
|
|
|
// The vector of network addresses this object is listening on.
|
|
// For LRPC it is just a 1-element vector containing the computer name.
|
|
NETWORK_ADDRESS_VECTOR *pNetworkAddressVector;
|
|
|
|
public:
|
|
unsigned int ServerListeningFlag ;
|
|
BOOL fServerThreadsStarted;
|
|
|
|
LRPC_ADDRESS (
|
|
OUT RPC_STATUS * Status
|
|
);
|
|
|
|
~LRPC_ADDRESS (
|
|
void
|
|
)
|
|
{
|
|
if (DebugCell)
|
|
{
|
|
FreeCell(DebugCell, &DebugCellTag);
|
|
DebugCell = NULL;
|
|
}
|
|
}
|
|
|
|
virtual RPC_STATUS
|
|
ServerStartingToListen (
|
|
IN unsigned int MinimumCallThreads,
|
|
IN unsigned int MaximumConcurrentCalls
|
|
);
|
|
|
|
virtual void
|
|
ServerStoppedListening (
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
ServerSetupAddress (
|
|
IN RPC_CHAR * NetworkAddress,
|
|
IN RPC_CHAR * *Endpoint,
|
|
IN unsigned int PendingQueueSize,
|
|
IN void * SecurityDescriptor, OPTIONAL
|
|
IN unsigned long EndpointFlags,
|
|
IN unsigned long NICFlags
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
LRPC_ADDRESS::CompleteListen (
|
|
);
|
|
|
|
inline void
|
|
DereferenceAssociation (
|
|
IN LRPC_SASSOCIATION * Association
|
|
);
|
|
|
|
friend BOOL
|
|
RecvLotsaCallsWrapper(
|
|
IN LRPC_ADDRESS * Address
|
|
);
|
|
|
|
RPC_STATUS
|
|
BeginLongCall(
|
|
void
|
|
);
|
|
|
|
BOOL
|
|
EndLongCall(
|
|
void
|
|
);
|
|
|
|
inline BOOL
|
|
PrepareForLoopbackTicklingIfNecessary (
|
|
void
|
|
)
|
|
{
|
|
LrpcMutexVerifyOwned();
|
|
|
|
if (TickleMessage)
|
|
return TRUE;
|
|
|
|
return PrepareForLoopbackTickling();
|
|
}
|
|
|
|
BOOL
|
|
LoopbackTickle (
|
|
void
|
|
);
|
|
|
|
inline BOOL
|
|
IsPreparedForLoopbackTickling (
|
|
void
|
|
)
|
|
{
|
|
return (TickleMessage != NULL);
|
|
}
|
|
|
|
inline LRPC_ADDRESS *
|
|
GetNextAddress (
|
|
void
|
|
)
|
|
{
|
|
return AddressChain;
|
|
}
|
|
|
|
inline int
|
|
GetNumberOfThreadsDoingShortWait (
|
|
void
|
|
)
|
|
{
|
|
return CallThreadCount - ThreadsDoingLongWait.GetInteger();
|
|
}
|
|
|
|
NETWORK_ADDRESS_VECTOR *
|
|
GetNetworkAddressVector (
|
|
void
|
|
)
|
|
{
|
|
return pNetworkAddressVector;
|
|
}
|
|
|
|
private:
|
|
|
|
RPC_STATUS
|
|
ActuallySetupAddress (
|
|
IN RPC_CHAR *Endpoint,
|
|
IN void * SecurityDescriptor
|
|
);
|
|
|
|
inline LRPC_SASSOCIATION *
|
|
ReferenceAssociation (
|
|
IN unsigned long AssociationKey
|
|
);
|
|
|
|
inline LRPC_CASSOCIATION *
|
|
ReferenceClientAssoc (
|
|
IN unsigned long AssociationKey
|
|
);
|
|
|
|
void
|
|
ReceiveLotsaCalls (
|
|
);
|
|
|
|
void
|
|
DealWithNewClient (
|
|
IN LRPC_MESSAGE * ConnectionRequest
|
|
);
|
|
|
|
void
|
|
DealWithConnectResponse (
|
|
IN LRPC_MESSAGE * ConnectResponse
|
|
) ;
|
|
|
|
void
|
|
RejectNewClient (
|
|
IN LRPC_MESSAGE * ConnectionRequest,
|
|
IN RPC_STATUS Status
|
|
);
|
|
|
|
BOOL
|
|
DealWithLRPCRequest (
|
|
IN LRPC_MESSAGE * LrpcMessage,
|
|
IN LRPC_MESSAGE * LrpcReplyMessage,
|
|
IN LRPC_SASSOCIATION *Association,
|
|
OUT LRPC_MESSAGE **LrpcResponse
|
|
) ;
|
|
|
|
BOOL fKeepThread(
|
|
)
|
|
{
|
|
// we keep at least two threads per address, to avoid creating the
|
|
// second thread each time a call arrives. Note that the second
|
|
// thread is free to timeout on the port and exit, the question
|
|
// is that it doesn't exit immediately after the call, as this will
|
|
// cause unnecessary creation/deletions of threads
|
|
return (((CallThreadCount - ActiveCallCount) <= 2)
|
|
|| (CallThreadCount <= MinimumCallThreads));
|
|
}
|
|
|
|
typedef enum
|
|
{
|
|
asctDestroyContextHandle = 0,
|
|
asctCleanupIdleSContext
|
|
} AssociationCallbackType;
|
|
|
|
void
|
|
EnumerateAndCallEachAssociation (
|
|
IN AssociationCallbackType asctType,
|
|
IN OUT void *Context OPTIONAL
|
|
);
|
|
|
|
virtual void
|
|
DestroyContextHandlesForInterface (
|
|
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
|
|
IN BOOL RundownContextHandles
|
|
);
|
|
|
|
virtual void
|
|
CleanupIdleSContexts (
|
|
void
|
|
);
|
|
|
|
BOOL
|
|
PrepareForLoopbackTickling (
|
|
void
|
|
);
|
|
|
|
void HandleInvalidAssociationReference (
|
|
IN LRPC_MESSAGE *RequestMessage,
|
|
IN OUT LRPC_MESSAGE **ReplyMessage,
|
|
IN ULONG AssociationKey
|
|
);
|
|
};
|
|
|
|
|
|
class LRPC_SBINDING
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
Each object of this class represents a binding to an interface by a
|
|
client.
|
|
|
|
Fields:
|
|
|
|
RpcInterface - Contains a pointer to the bound interface.
|
|
|
|
PresentationContext - Contains the key which the client will send when
|
|
it wants to use this binding.
|
|
|
|
--*/
|
|
{
|
|
friend class LRPC_SASSOCIATION;
|
|
friend class LRPC_SCALL;
|
|
friend class LRPC_ADDRESS;
|
|
|
|
private:
|
|
|
|
RPC_INTERFACE * RpcInterface;
|
|
int PresentationContext;
|
|
int SelectedTransferSyntaxIndex;
|
|
LUID ClientLuid;
|
|
unsigned long SequenceNumber;
|
|
|
|
public:
|
|
|
|
LRPC_SBINDING (
|
|
IN RPC_INTERFACE * RpcInterface,
|
|
IN int SelectedTransferSyntax
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
We will construct a LRPC_SBINDING.
|
|
|
|
Arguments:
|
|
|
|
RpcInterface - Supplies the bound interface.
|
|
|
|
TransferSyntax - Supplies the transfer syntax which the client will use
|
|
over this binding.
|
|
|
|
--*/
|
|
{
|
|
this->RpcInterface = RpcInterface;
|
|
SequenceNumber = 0;
|
|
SelectedTransferSyntaxIndex = SelectedTransferSyntax;
|
|
}
|
|
|
|
RPC_STATUS
|
|
CheckSecurity (
|
|
SCALL * Context
|
|
);
|
|
|
|
inline unsigned short GetOnTheWirePresentationContext(void)
|
|
{
|
|
return (unsigned short)PresentationContext;
|
|
}
|
|
|
|
inline void SetPresentationContextFromPacket(unsigned short PresentContext)
|
|
{
|
|
PresentationContext = (int) PresentContext;
|
|
}
|
|
|
|
inline int GetPresentationContext (void)
|
|
{
|
|
return PresentationContext;
|
|
}
|
|
|
|
inline void SetPresentationContext (int PresentContext)
|
|
{
|
|
PresentationContext = PresentContext;
|
|
}
|
|
|
|
inline void GetSelectedTransferSyntaxAndDispatchTable(
|
|
OUT RPC_SYNTAX_IDENTIFIER **SelectedTransferSyntax,
|
|
OUT PRPC_DISPATCH_TABLE *SelectedDispatchTable)
|
|
{
|
|
RpcInterface->GetSelectedTransferSyntaxAndDispatchTable(SelectedTransferSyntaxIndex,
|
|
SelectedTransferSyntax, SelectedDispatchTable);
|
|
}
|
|
|
|
DWORD GetInterfaceFirstDWORD(void)
|
|
{
|
|
return RpcInterface->GetInterfaceFirstDWORD();;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
typedef void * LRPC_BUFFER;
|
|
|
|
NEW_SDICT(LRPC_SBINDING);
|
|
NEW_SDICT(LRPC_CLIENT_BUFFER);
|
|
NEW_SDICT2(LRPC_SCALL, PVOID);
|
|
NEW_NAMED_SDICT2(LRPC_SCALL_THREAD, LRPC_SCALL, HANDLE);
|
|
|
|
#define USER_NAME_LEN 256
|
|
#define DOMAIN_NAME_LEN 128
|
|
|
|
extern const SID AnonymousSid;
|
|
|
|
|
|
class LRPC_SCONTEXT
|
|
{
|
|
public:
|
|
HANDLE hToken;
|
|
LUID ClientLuid;
|
|
RPC_CHAR *ClientName;
|
|
int RefCount;
|
|
LRPC_SASSOCIATION *Association;
|
|
AUTHZ_CLIENT_CONTEXT_HANDLE AuthzClientContext;
|
|
|
|
LRPC_SCONTEXT (
|
|
IN HANDLE MyToken,
|
|
IN LUID *UserLuid,
|
|
IN LRPC_SASSOCIATION *MyAssociation,
|
|
IN BOOL fDefaultLogonId,
|
|
IN BOOL fAnonymousToken
|
|
);
|
|
|
|
~LRPC_SCONTEXT (
|
|
void
|
|
);
|
|
|
|
void AddReference();
|
|
void RemoveReference();
|
|
void Destroy();
|
|
|
|
RPC_STATUS
|
|
GetUserName (
|
|
IN OUT ULONG *ClientPrincipalNameBufferLength OPTIONAL,
|
|
OUT RPC_CHAR **UserName,
|
|
IN HANDLE hUserToken OPTIONAL
|
|
);
|
|
|
|
static const unsigned int Deleted = 1;
|
|
static const unsigned int DefaultLogonId = 2;
|
|
static const unsigned int Anonymous = 4;
|
|
static const unsigned int ServerSideOnly = 8;
|
|
|
|
inline void SetDeletedFlag(void)
|
|
{
|
|
Flags.SetFlagUnsafe(Deleted);
|
|
}
|
|
inline void ClearDeletedFlag(void)
|
|
{
|
|
Flags.ClearFlagUnsafe(Deleted);
|
|
}
|
|
inline BOOL GetDeletedFlag(void)
|
|
{
|
|
return Flags.GetFlag(Deleted);
|
|
}
|
|
|
|
inline void SetDefaultLogonIdFlag(void)
|
|
{
|
|
Flags.SetFlagUnsafe(DefaultLogonId);
|
|
}
|
|
inline void ClearDefaultLogonIdFlag(void)
|
|
{
|
|
Flags.ClearFlagUnsafe(DefaultLogonId);
|
|
}
|
|
inline BOOL GetDefaultLogonIdFlag(void)
|
|
{
|
|
return Flags.GetFlag(DefaultLogonId);
|
|
}
|
|
|
|
inline void SetAnonymousFlag(void)
|
|
{
|
|
Flags.SetFlagUnsafe(Anonymous);
|
|
}
|
|
inline void ClearAnonymousFlag(void)
|
|
{
|
|
Flags.ClearFlagUnsafe(Anonymous);
|
|
}
|
|
inline BOOL GetAnonymousFlag(void)
|
|
{
|
|
return Flags.GetFlag(Anonymous);
|
|
}
|
|
|
|
inline void SetServerSideOnlyFlag(void)
|
|
{
|
|
Flags.SetFlagUnsafe(ServerSideOnly);
|
|
}
|
|
inline void ClearServerSideOnlyFlag(void)
|
|
{
|
|
Flags.ClearFlagUnsafe(ServerSideOnly);
|
|
}
|
|
inline BOOL GetServerSideOnlyFlag(void)
|
|
{
|
|
return Flags.GetFlag(ServerSideOnly);
|
|
}
|
|
|
|
static const ULONG CONTEXT_IDLE_TIMEOUT = 2 * 60 * 1000; // 2 minutes
|
|
|
|
inline void UpdateLastAccessTime (void)
|
|
{
|
|
LastAccessTime = NtGetTickCount();
|
|
}
|
|
|
|
inline BOOL IsIdle (void)
|
|
{
|
|
// make sure if the tick count wraps the calculation is still valid
|
|
return (NtGetTickCount() - LastAccessTime > CONTEXT_IDLE_TIMEOUT);
|
|
}
|
|
|
|
private:
|
|
static TOKEN_USER *
|
|
GetSID (
|
|
IN HANDLE hToken
|
|
);
|
|
|
|
static RPC_STATUS
|
|
LookupUser (
|
|
IN SID *pSid,
|
|
OUT RPC_CHAR **UserName
|
|
);
|
|
|
|
// changed either on creation, or within
|
|
// the Association mutex
|
|
CompositeFlags Flags;
|
|
|
|
// the last access time for server side only contexts.
|
|
// Undefined if the context is not server side only
|
|
// It is used to determine whether the context is idle
|
|
ULONG LastAccessTime;
|
|
};
|
|
|
|
NEW_SDICT(LRPC_SCONTEXT);
|
|
|
|
|
|
class LRPC_SASSOCIATION : public ASSOCIATION_HANDLE
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
|
|
Fields:
|
|
|
|
LpcServerPort - Contains the LPC server communication port.
|
|
|
|
Bindings - Contains the dictionary of bindings with the client. This
|
|
information is necessary to dispatch remote procedure calls to the
|
|
correct stub.
|
|
|
|
Address - Contains the address which this association is over.
|
|
|
|
AssociationReferenceCount - Contains a count of the number of objects
|
|
referencing this association. This will be the number of outstanding
|
|
remote procedure calls, and one for LPC (because of the context
|
|
pointer). We will protect this fielding using the global mutex.
|
|
|
|
Buffers - Contains the dictionary of buffers to be written into the
|
|
client's address space on demand.
|
|
|
|
AssociationKey - Contains the key for this association in the dictionary
|
|
of associations maintained by the address.
|
|
|
|
ClientThreadDict - This dictionary contains one entry per client thread. Each entry
|
|
contains a list of SCALLS representing calls made by that client thread. The
|
|
calls need to be causally ordered.
|
|
|
|
--*/
|
|
{
|
|
friend class LRPC_ADDRESS;
|
|
friend class LRPC_SCALL;
|
|
friend class LRPC_SCONTEXT;
|
|
friend void
|
|
SetFaultPacket (
|
|
IN LRPC_MESSAGE *LrpcMessage,
|
|
IN RPC_STATUS Status,
|
|
IN int Flags,
|
|
IN LRPC_SCALL *CurrentCall OPTIONAL
|
|
);
|
|
|
|
private:
|
|
|
|
long AssociationReferenceCount;
|
|
USHORT DictionaryKey;
|
|
USHORT SequenceNumber;
|
|
HANDLE LpcServerPort;
|
|
HANDLE LpcReplyPort ;
|
|
LRPC_ADDRESS * Address;
|
|
LRPC_SBINDING_DICT Bindings;
|
|
// -1 indicates exclusive lock. Positive values are shared locks
|
|
INTERLOCKED_INTEGER BindingsCollectionLock;
|
|
int Aborted ;
|
|
long Deleted ;
|
|
LRPC_SCALL *CachedSCall;
|
|
LONG CachedSCallAvailable;
|
|
BOOL fFirstCall;
|
|
LRPC_CLIENT_BUFFER_DICT Buffers ;
|
|
MUTEX AssociationMutex ;
|
|
QUEUE FreeSCallQueue ;
|
|
LRPC_SCALL_THREAD_DICT2 ClientThreadDict ;
|
|
LRPC_SCONTEXT_DICT SContextDict;
|
|
|
|
public:
|
|
|
|
LRPC_SCALL_DICT2 SCallDict ;
|
|
|
|
|
|
LRPC_SASSOCIATION (
|
|
IN LRPC_ADDRESS * Address,
|
|
IN RPC_STATUS *Status
|
|
);
|
|
|
|
~LRPC_SASSOCIATION (
|
|
);
|
|
|
|
RPC_STATUS
|
|
AddBinding (
|
|
IN OUT LRPC_BIND_EXCHANGE * BindExchange
|
|
);
|
|
|
|
void
|
|
DealWithBindMessage (
|
|
IN LRPC_MESSAGE * LrpcMessage
|
|
);
|
|
|
|
LRPC_MESSAGE *
|
|
DealWithCopyMessage (
|
|
IN LRPC_COPY_MESSAGE * LrpcMessage
|
|
) ;
|
|
|
|
NTSTATUS
|
|
ReplyMessage (
|
|
IN LRPC_MESSAGE * LrpcMessage
|
|
) ;
|
|
|
|
RPC_STATUS
|
|
SaveToken (
|
|
IN LRPC_MESSAGE *LrpcMessage,
|
|
OUT HANDLE *pTokenHandle,
|
|
IN BOOL fRestoreToken = 0
|
|
) ;
|
|
|
|
LRPC_MESSAGE *
|
|
DealWithBindBackMessage (
|
|
IN LRPC_MESSAGE *BindBack
|
|
) ;
|
|
|
|
RPC_STATUS
|
|
BindBack (
|
|
IN RPC_CHAR *Endpoint,
|
|
IN DWORD pAssocKey,
|
|
IN BYTE *Cookie
|
|
) ;
|
|
|
|
LRPC_MESSAGE *
|
|
DealWithPartialRequest (
|
|
IN LRPC_MESSAGE **LrpcMessage
|
|
) ;
|
|
|
|
void
|
|
Delete(
|
|
) ;
|
|
|
|
RPC_STATUS
|
|
AllocateSCall (
|
|
IN LRPC_MESSAGE *LrpcMessage,
|
|
IN LRPC_MESSAGE *LrpcReply,
|
|
IN unsigned int Flags,
|
|
IN LRPC_SCALL **SCall
|
|
) ;
|
|
|
|
void
|
|
FreeSCall (
|
|
LRPC_SCALL *SCall
|
|
) ;
|
|
|
|
int
|
|
MaybeQueueSCall (
|
|
IN LRPC_SCALL *SCall
|
|
) ;
|
|
|
|
LRPC_SCALL *
|
|
GetNextSCall (
|
|
IN LRPC_SCALL *SCall
|
|
) ;
|
|
|
|
RPC_STATUS
|
|
GetClientName (
|
|
IN LRPC_SCALL *SCall,
|
|
IN OUT ULONG *ClientPrincipalNameBufferLength OPTIONAL, // in bytes
|
|
OUT RPC_CHAR **ClientPrincipalName
|
|
);
|
|
|
|
void
|
|
AbortAssociation (
|
|
)
|
|
{
|
|
Aborted = 1 ;
|
|
}
|
|
|
|
LRPC_SCONTEXT *
|
|
FindSecurityContext (
|
|
ULONG SecurityContextId
|
|
)
|
|
{
|
|
LRPC_SCONTEXT *SContext;
|
|
|
|
AssociationMutex.Request();
|
|
SContext = SContextDict.Find(SecurityContextId);
|
|
if (SContext)
|
|
{
|
|
SContext->AddReference();
|
|
}
|
|
AssociationMutex.Clear();
|
|
|
|
return SContext;
|
|
}
|
|
|
|
int
|
|
IsAborted(
|
|
)
|
|
{
|
|
return Aborted ;
|
|
}
|
|
|
|
void
|
|
MaybeDereference (
|
|
)
|
|
{
|
|
if (Aborted)
|
|
{
|
|
Delete() ;
|
|
}
|
|
}
|
|
|
|
LRPC_ADDRESS *
|
|
InqAddress(
|
|
)
|
|
{
|
|
return Address ;
|
|
}
|
|
|
|
virtual RPC_STATUS CreateThread(void);
|
|
virtual void RundownNotificationCompleted(void);
|
|
|
|
void
|
|
CleanupIdleSContexts (
|
|
void
|
|
);
|
|
|
|
inline BOOL
|
|
IsDeleted (
|
|
void
|
|
)
|
|
{
|
|
return (Deleted >= 0);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
class LRPC_SCALL : public SCALL
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
Fields:
|
|
|
|
Association - Contains the association over which the remote procedure
|
|
call was received. We need this information to make callbacks and
|
|
to send the reply.
|
|
|
|
LrpcMessage - Contains the request message. We need this to send callbacks
|
|
as well as the reply.
|
|
|
|
SBinding - Contains the binding being used for this remote procedure call.
|
|
|
|
ObjectUuidFlag - Contains a flag indicting whether or not an object
|
|
uuid was specified for this remote procedure call. A non-zero
|
|
value indicates that an object uuid was specified.
|
|
|
|
ObjectUuid - Optionally contains the object uuid for this call, if one
|
|
was specified.
|
|
|
|
ClientId - Contains the thread identifier of the thread which made the
|
|
remote procedure call.
|
|
|
|
MessageId - Contains an identifier used by LPC to identify the current
|
|
remote procedure call.
|
|
|
|
PushedResponse - When the client needs to send a large response to the
|
|
server it must be transfered via a request. This holds the pushed
|
|
response until the request gets here.
|
|
|
|
--*/
|
|
{
|
|
friend class LRPC_SASSOCIATION;
|
|
friend class LRPC_ADDRESS;
|
|
friend void
|
|
SetFaultPacket (
|
|
IN LRPC_MESSAGE *LrpcMessage,
|
|
IN RPC_STATUS Status,
|
|
IN int Flags,
|
|
IN LRPC_SCALL *CurrentCall OPTIONAL
|
|
);
|
|
|
|
private:
|
|
CLIENT_AUTH_INFO AuthInfo;
|
|
LRPC_SASSOCIATION * Association;
|
|
LRPC_MESSAGE * LrpcRequestMessage;
|
|
LRPC_MESSAGE * LrpcReplyMessage;
|
|
LRPC_SBINDING * SBinding;
|
|
unsigned int ObjectUuidFlag;
|
|
ULONG CallId;
|
|
CLIENT_ID ClientId;
|
|
ULONG MessageId;
|
|
ULONG CallbackId;
|
|
void * PushedResponse;
|
|
ULONG CurrentBufferLength ;
|
|
int BufferComplete ;
|
|
LRPC_MESSAGE *LrpcAsyncReplyMessage;
|
|
unsigned int Flags ;
|
|
BOOL FirstSend ;
|
|
BOOL PipeSendCalled ;
|
|
int Deleted ;
|
|
RPC_UUID ObjectUuid;
|
|
|
|
DebugCallInfo *DebugCell;
|
|
|
|
// Async RPC
|
|
EVENT *ReceiveEvent ;
|
|
MUTEX *CallMutex ;
|
|
|
|
// the cell tag to the DebugCell above
|
|
CellTag DebugCellTag;
|
|
|
|
ULONG RcvBufferLength ;
|
|
BOOL ReceiveComplete ;
|
|
BOOL AsyncReply ;
|
|
LRPC_SCALL *NextSCall ;
|
|
LRPC_SCALL *LastSCall ;
|
|
ULONG NeededLength;
|
|
|
|
BOOL fSyncDispatch ;
|
|
BOOL Choked ;
|
|
BOOL fSendMoreExpected; //Async Pipe only
|
|
long CancelPending;
|
|
|
|
RPC_MESSAGE RpcMessage;
|
|
RPC_RUNTIME_INFO RuntimeInfo;
|
|
QUEUE BufferQueue ;
|
|
|
|
RPC_CHAR *ClientPrincipalName;
|
|
public:
|
|
LRPC_SCONTEXT *SContext;
|
|
|
|
LRPC_SCALL (OUT RPC_STATUS *RpcStatus)
|
|
{
|
|
ObjectType = LRPC_SCALL_TYPE;
|
|
ReceiveEvent = 0;
|
|
CallMutex = 0;
|
|
LrpcAsyncReplyMessage = 0;
|
|
ClientPrincipalName = NULL;
|
|
*RpcStatus = RPC_S_OK;
|
|
|
|
if (IsServerSideDebugInfoEnabled())
|
|
{
|
|
DebugCell = (DebugCallInfo *)AllocateCell(&DebugCellTag);
|
|
if (DebugCell == NULL)
|
|
*RpcStatus = RPC_S_OUT_OF_MEMORY;
|
|
else
|
|
{
|
|
memset(DebugCell, 0, sizeof(DebugCallInfo));
|
|
DebugCell->FastInit = 0;
|
|
DebugCell->Type = dctCallInfo;
|
|
DebugCell->Status = (BYTE)csAllocated;
|
|
DebugCell->CallFlags = DBGCELL_CACHED_CALL | DBGCELL_LRPC_CALL;
|
|
DebugCell->LastUpdateTime = NtGetTickCount();
|
|
}
|
|
}
|
|
else
|
|
DebugCell = NULL;
|
|
}
|
|
|
|
~LRPC_SCALL (
|
|
)
|
|
{
|
|
if (ReceiveEvent)
|
|
{
|
|
if (CallId != (ULONG) -1)
|
|
{
|
|
Association->AssociationMutex.Request() ;
|
|
Association->SCallDict.Delete(ULongToPtr(CallId));
|
|
Association->AssociationMutex.Clear() ;
|
|
}
|
|
|
|
delete ReceiveEvent;
|
|
delete CallMutex ;
|
|
}
|
|
|
|
if (DebugCell)
|
|
{
|
|
FreeCell(DebugCell, &DebugCellTag);
|
|
}
|
|
|
|
if (LrpcAsyncReplyMessage)
|
|
{
|
|
FreeMessage(LrpcAsyncReplyMessage);
|
|
}
|
|
}
|
|
|
|
virtual RPC_STATUS
|
|
NegotiateTransferSyntax (
|
|
IN OUT PRPC_MESSAGE Message
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
GetBuffer (
|
|
IN OUT PRPC_MESSAGE Message,
|
|
IN UUID *ObjectUuid
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
SendReceive (
|
|
IN OUT PRPC_MESSAGE Message
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
Send (
|
|
IN OUT PRPC_MESSAGE Messsage
|
|
) ;
|
|
|
|
virtual RPC_STATUS
|
|
Receive (
|
|
IN PRPC_MESSAGE Message,
|
|
IN unsigned int Size
|
|
) ;
|
|
|
|
virtual RPC_STATUS
|
|
AsyncSend (
|
|
IN OUT PRPC_MESSAGE Message
|
|
) ;
|
|
|
|
virtual RPC_STATUS
|
|
AsyncReceive (
|
|
IN OUT PRPC_MESSAGE Message,
|
|
IN unsigned int Size
|
|
) ;
|
|
|
|
virtual RPC_STATUS
|
|
SetAsyncHandle (
|
|
IN PRPC_ASYNC_STATE pAsync
|
|
) ;
|
|
|
|
virtual RPC_STATUS
|
|
AbortAsyncCall (
|
|
IN PRPC_ASYNC_STATE pAsync,
|
|
IN unsigned long ExceptionCode
|
|
) ;
|
|
|
|
virtual void
|
|
FreeBuffer (
|
|
IN PRPC_MESSAGE Message
|
|
);
|
|
|
|
virtual void
|
|
FreePipeBuffer (
|
|
IN PRPC_MESSAGE Message
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
ReallocPipeBuffer (
|
|
IN PRPC_MESSAGE Message,
|
|
IN unsigned int NewSize
|
|
) ;
|
|
|
|
virtual RPC_STATUS
|
|
ImpersonateClient (
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
RevertToSelf (
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
GetAuthorizationContext (
|
|
IN BOOL ImpersonateOnReturn,
|
|
IN AUTHZ_RESOURCE_MANAGER_HANDLE AuthzResourceManager,
|
|
IN PLARGE_INTEGER pExpirationTime OPTIONAL,
|
|
IN LUID Identifier,
|
|
IN DWORD Flags,
|
|
IN PVOID DynamicGroupArgs OPTIONAL,
|
|
OUT PAUTHZ_CLIENT_CONTEXT_HANDLE pAuthzClientContext
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
IsClientLocal (
|
|
OUT unsigned int * ClientLocalFlag
|
|
);
|
|
|
|
virtual void
|
|
IsClientDisconnected (
|
|
OUT BOOL *ClientIsDisconnected
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
ConvertToServerBinding (
|
|
OUT RPC_BINDING_HANDLE __RPC_FAR * ServerBinding
|
|
);
|
|
|
|
virtual void
|
|
InquireObjectUuid (
|
|
OUT RPC_UUID * ObjectUuid
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
ToStringBinding (
|
|
OUT RPC_CHAR ** StringBinding
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
GetAssociationContextCollection (
|
|
OUT ContextCollection **CtxCollection
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
InquireAuthClient (
|
|
OUT RPC_AUTHZ_HANDLE * Privileges,
|
|
OUT RPC_CHAR * * ServerPrincipalName, OPTIONAL
|
|
OUT unsigned long * AuthenticationLevel,
|
|
OUT unsigned long * AuthenticationService,
|
|
OUT unsigned long * AuthorizationService,
|
|
IN unsigned long Flags
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
InquireCallAttributes (
|
|
IN OUT void *RpcCallAttributes
|
|
);
|
|
|
|
virtual RPC_STATUS
|
|
InqTransportType(
|
|
OUT unsigned int __RPC_FAR * Type
|
|
)
|
|
{
|
|
*Type = TRANSPORT_TYPE_LPC ;
|
|
|
|
return (RPC_S_OK) ;
|
|
}
|
|
|
|
virtual BOOL
|
|
IsSyncCall (
|
|
)
|
|
{
|
|
return !pAsync ;
|
|
}
|
|
|
|
virtual unsigned
|
|
TestCancel(
|
|
)
|
|
{
|
|
return InterlockedExchange(&CancelPending, 0);
|
|
}
|
|
|
|
virtual void
|
|
FreeObject (
|
|
) ;
|
|
|
|
BOOL
|
|
IsClientAsync (
|
|
)
|
|
{
|
|
return ((Flags & LRPC_SYNC_CLIENT) == 0);
|
|
}
|
|
|
|
RPC_STATUS
|
|
ActivateCall (
|
|
IN LRPC_SASSOCIATION * Association,
|
|
IN LRPC_MESSAGE * LrpcMessage,
|
|
IN LRPC_MESSAGE * LrpcReplyMessage,
|
|
IN unsigned int Flags
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
description
|
|
|
|
Arguments:
|
|
|
|
arg1 - description
|
|
|
|
--*/
|
|
|
|
{
|
|
RPC_STATUS Status = RPC_S_OK;
|
|
|
|
this->Association = Association;
|
|
this->LrpcRequestMessage = LrpcMessage;
|
|
this->LrpcReplyMessage = LrpcReplyMessage;
|
|
ObjectUuidFlag = 0;
|
|
PushedResponse = 0;
|
|
CurrentBufferLength = 0;
|
|
BufferComplete = 0;
|
|
this->Flags = Flags ;
|
|
FirstSend = 1;
|
|
PipeSendCalled = 0;
|
|
Deleted = 0;
|
|
SBinding = 0;
|
|
SetReferenceCount(2);
|
|
pAsync = 0;
|
|
NextSCall = 0;
|
|
LastSCall = 0;
|
|
CancelPending = 0;
|
|
|
|
if (DebugCell)
|
|
{
|
|
DebugCell->Status = (BYTE)csActive;
|
|
if (Association->CachedSCall == this)
|
|
DebugCell->CallFlags = DBGCELL_CACHED_CALL | DBGCELL_LRPC_CALL;
|
|
else
|
|
DebugCell->CallFlags = DBGCELL_CACHED_CALL;
|
|
DebugCell->LastUpdateTime = NtGetTickCount();
|
|
}
|
|
|
|
// Async RPC stuff
|
|
|
|
RuntimeInfo.Length = sizeof(RPC_RUNTIME_INFO) ;
|
|
RpcMessage.ReservedForRuntime = &RuntimeInfo;
|
|
RpcMessage.RpcFlags = 0;
|
|
|
|
if (LrpcMessage->Rpc.RpcHeader.SecurityContextId != -1)
|
|
{
|
|
SContext = Association->FindSecurityContext(
|
|
LrpcMessage->Rpc.RpcHeader.SecurityContextId);
|
|
if (SContext == NULL)
|
|
{
|
|
Status = RPC_S_ACCESS_DENIED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SContext = NULL;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
inline void DeactivateCall (void)
|
|
{
|
|
if (DebugCell)
|
|
{
|
|
DebugCell->Status = (BYTE)csAllocated;
|
|
DebugCell->LastUpdateTime = NtGetTickCount();
|
|
}
|
|
}
|
|
|
|
RPC_STATUS
|
|
ProcessResponse (
|
|
IN LRPC_MESSAGE **LrpcMessage
|
|
) ;
|
|
|
|
inline RPC_STATUS
|
|
LrpcMessageToRpcMessage (
|
|
IN LRPC_MESSAGE * LrpcMessage,
|
|
IN OUT PRPC_MESSAGE Message
|
|
) ;
|
|
|
|
void
|
|
DealWithRequestMessage (
|
|
);
|
|
|
|
void
|
|
HandleRequest (
|
|
) ;
|
|
|
|
LRPC_SASSOCIATION *
|
|
InqAssociation (
|
|
)
|
|
{
|
|
return Association;
|
|
}
|
|
|
|
LRPC_MESSAGE *
|
|
InitMsg (
|
|
)
|
|
{
|
|
INITMSG(LrpcReplyMessage,
|
|
ClientId,
|
|
CallbackId,
|
|
MessageId) ;
|
|
|
|
LrpcReplyMessage->LpcHeader.u1.s1.TotalLength =
|
|
LrpcReplyMessage->LpcHeader.u1.s1.DataLength+sizeof(PORT_MESSAGE);
|
|
|
|
return LrpcReplyMessage;
|
|
}
|
|
|
|
virtual RPC_STATUS
|
|
InqConnection (
|
|
OUT void **ConnId,
|
|
OUT BOOL *pfFirstCall
|
|
)
|
|
{
|
|
ASSERT(Association);
|
|
*ConnId = Association;
|
|
|
|
if (InterlockedIncrement((LONG *) &(Association->fFirstCall)) == 1)
|
|
{
|
|
*pfFirstCall = 1;
|
|
}
|
|
else
|
|
{
|
|
*pfFirstCall = 0;
|
|
}
|
|
|
|
return RPC_S_OK;
|
|
}
|
|
|
|
inline HANDLE InqLocalClientPID (
|
|
void
|
|
)
|
|
{
|
|
return ClientId.UniqueProcess;
|
|
}
|
|
|
|
private:
|
|
RPC_STATUS
|
|
GetBufferDo(
|
|
IN OUT PRPC_MESSAGE Message,
|
|
IN unsigned long NewSize,
|
|
IN BOOL fDataValid
|
|
) ;
|
|
|
|
RPC_STATUS
|
|
SetupCall (
|
|
) ;
|
|
|
|
RPC_STATUS
|
|
GetCoalescedBuffer (
|
|
IN PRPC_MESSAGE Message,
|
|
IN BOOL BufferValid
|
|
) ;
|
|
|
|
RPC_STATUS
|
|
SendRequest (
|
|
IN OUT PRPC_MESSAGE Messsage,
|
|
OUT BOOL *Shutup
|
|
) ;
|
|
|
|
void
|
|
SendReply (
|
|
);
|
|
|
|
NTSTATUS
|
|
SendDGReply (
|
|
IN LRPC_MESSAGE *LrpcMessage
|
|
)
|
|
{
|
|
NTSTATUS NtStatus ;
|
|
|
|
LrpcMessage->LpcHeader.u2.ZeroInit = 0;
|
|
LrpcMessage->LpcHeader.CallbackId = 0;
|
|
LrpcMessage->LpcHeader.MessageId = 0;
|
|
LrpcMessage->LpcHeader.u1.s1.TotalLength =
|
|
LrpcMessage->LpcHeader.u1.s1.DataLength+sizeof(PORT_MESSAGE);
|
|
|
|
NtStatus = NtRequestPort(Association->LpcReplyPort,
|
|
(PORT_MESSAGE *) LrpcMessage);
|
|
|
|
if (!NT_SUCCESS(NtStatus))
|
|
{
|
|
#if DBG
|
|
if ((NtStatus != STATUS_INVALID_CID)
|
|
&& (NtStatus != STATUS_REPLY_MESSAGE_MISMATCH)
|
|
&& (NtStatus != STATUS_PORT_DISCONNECTED))
|
|
{
|
|
PrintToDebugger("RPC : NtRequestPort : %lx, 0x%x, 0x%x\n",
|
|
NtStatus, this, Association->LpcReplyPort);
|
|
ASSERT(NtStatus != STATUS_INVALID_HANDLE);
|
|
}
|
|
#endif // DBG
|
|
Association->Delete();
|
|
}
|
|
|
|
|
|
return NtStatus ;
|
|
}
|
|
|
|
LRPC_SBINDING *
|
|
LookupBinding (
|
|
IN unsigned short PresentContextId
|
|
);
|
|
};
|
|
|
|
class LRPC_SCALL_AVRF : public LRPC_SCALL
|
|
/*++
|
|
|
|
Class Description:
|
|
|
|
This class overwrites an LRPC_SCALL for use with RPC verifier.
|
|
Methods will perform some checks.
|
|
|
|
--*/
|
|
{
|
|
public:
|
|
|
|
LRPC_SCALL_AVRF (OUT RPC_STATUS *RpcStatus) : LRPC_SCALL(RpcStatus) {}
|
|
|
|
RPC_STATUS
|
|
ImpersonateClient (
|
|
);
|
|
|
|
};
|
|
|
|
|
|
inline NTSTATUS
|
|
LRPC_SASSOCIATION::ReplyMessage(
|
|
IN LRPC_MESSAGE * LrpcMessage
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Send a reply to a request
|
|
|
|
Arguments:
|
|
|
|
LrpcMessage - Reply message
|
|
|
|
Return Value:
|
|
|
|
RPC_S_OK - Function succeeded
|
|
RPC_S_OUT_OF_MEMORY - we ran out of memory
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS NtStatus ;
|
|
|
|
LrpcMessage->LpcHeader.u1.s1.TotalLength =
|
|
LrpcMessage->LpcHeader.u1.s1.DataLength + sizeof(PORT_MESSAGE);
|
|
|
|
LogEvent(SU_SASSOC, EV_PKT_OUT, this, UlongToHandle(LrpcMessage->LpcHeader.MessageId),
|
|
(HandleToULong(LrpcMessage->LpcHeader.ClientId.UniqueProcess)<<16 | \
|
|
(HandleToULong(LrpcMessage->LpcHeader.ClientId.UniqueThread))), 1, 0);
|
|
|
|
NtStatus = NtReplyPort(LpcServerPort,
|
|
(PORT_MESSAGE *) LrpcMessage) ;
|
|
|
|
if (!NT_SUCCESS(NtStatus))
|
|
{
|
|
#if DBG
|
|
PrintToDebugger("RPC : NtReplyPort : %lx, 0x%x, 0x%x\n",
|
|
NtStatus,
|
|
this,
|
|
LpcReplyPort);
|
|
ASSERT(NtStatus != STATUS_INVALID_HANDLE);
|
|
#endif
|
|
Delete();
|
|
}
|
|
|
|
return NtStatus ;
|
|
}
|
|
|
|
inline void
|
|
LRPC_SCONTEXT::AddReference()
|
|
{
|
|
Association->AssociationMutex.VerifyOwned();
|
|
ASSERT(RefCount);
|
|
|
|
RefCount++;
|
|
}
|
|
|
|
inline void
|
|
LRPC_SCONTEXT::RemoveReference()
|
|
{
|
|
LRPC_SASSOCIATION *MyAssoc = Association;
|
|
|
|
Association->AssociationMutex.Request();
|
|
RefCount--;
|
|
if (RefCount == 0)
|
|
{
|
|
delete this;
|
|
}
|
|
MyAssoc->AssociationMutex.Clear();
|
|
}
|
|
|
|
inline void
|
|
LRPC_SCONTEXT::Destroy()
|
|
{
|
|
Association->AssociationMutex.VerifyOwned();
|
|
if (GetDeletedFlag() == 0)
|
|
{
|
|
SetDeletedFlag();
|
|
RefCount--;
|
|
if (RefCount == 0)
|
|
{
|
|
delete this;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif //__LPCSVR_HXX__
|