windows-xp/Source/XPSP1/NT/com/rpc/runtime/mtrt/lpcsvr.hxx

/*++

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;

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,
        OUT NETWORK_ADDRESS_VECTOR **ppNetworkAddressVector
        ) ;

    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();
    }

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;
    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;
    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
        ) ;

    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
        );
};



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 ;
    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 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
       );
};


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);

    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__