windows-server-2003/com/rpc/runtime/mtrt/osfsvr.hxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1990 - 1999
//
//  File:       osfsvr.hxx
//
//--------------------------------------------------------------------------

/* --------------------------------------------------------------------

File : osfsvr.hxx

Title : Classes for the OSF RPC protocol module (server classes).

Description :

History :

mikemon    ??-??-??    Beginning of recorded history.
mikemon    10-15-90    Changed the shutdown functionality to PauseExecution
                       rather than suspending and resuming a thread.
mikemon    10-16-90    Added ListenThreadCompleted to OSF_ADDRESS.
Kamen Moutafov      (kamenm)    Jan-2000    Support for multiple transfer syntaxes
Kamen Moutafov (KamenM) Dec 99 - Feb 2000 - Support for cell debugging stuff

-------------------------------------------------------------------- */

#ifndef __OSFSVR_HXX__
#define __OSFSVR_HXX__

enum OSF_SCALL_STATE
{
    NewRequest,
    CallCancelled,
    CallAborted,
    CallCompleted,
    ReceivedCallback,
    ReceivedCallbackReply,
    ReceivedFault
};

class OSF_SCONNECTION;
class OSF_SCALL;

NEW_SDICT(OSF_ASSOCIATION);
#define InqTransAddress(RpcTransportAddress) \
    ((OSF_ADDRESS *) \
            ((char *) RpcTransportAddress - sizeof(OSF_ADDRESS)))

#define InqTransSConnection(RpcTransportConnection) \
    ((OSF_SCONNECTION *) \
            ((char *) RpcTransportConnection - sizeof(OSF_SCONNECTION)))

#define InqTransSCall(RpcSourceContext) \
    ((OSF_SCALL *) ((char *) RpcSourceContext - sizeof(OSF_SCALL)))

NEW_SDICT(OSF_SCONNECTION);

const int NumberOfAssociationsDictionaries = 8;
const int MutexAllocationSize = ( ((unsigned long)(sizeof(MUTEX)) + ((4)-1)) & ~(4 - 1) );

class OSF_ADDRESS : public RPC_ADDRESS
/*++

Class Description:

Fields:

    SetupAddressOccurred - Contains a flag which indicates whether or
        not SetupAddressWithEndpoint or SetupAddressUnknownEndpoint
        have been called and returned success.  A value of non-zero
        indicates that the above (SetupAddress* has been called and
        succeeded) occured.

    ServerInfo - Contains the pointers to the loadable transport
        routines for the transport type of this address.

--*/
{
private:
    OSF_ASSOCIATION_DICT Associations[NumberOfAssociationsDictionaries];
    unsigned char AssociationBucketMutexMemory[MutexAllocationSize * NumberOfAssociationsDictionaries];
    RPC_CONNECTION_TRANSPORT * ServerInfo;
    unsigned int SetupAddressOccurred;
    int ServerListeningFlag;
    DebugEndpointInfo *DebugCell;
    CellTag DebugCellTag;

public:
    OSF_ADDRESS (
        IN TRANS_INFO  * RpcTransInfoInfo,
        IN OUT RPC_STATUS  * RpcStatus
        );

    ~OSF_ADDRESS (
        );

    virtual RPC_STATUS
    ServerStartingToListen (
        IN unsigned int MinimumCallThreads,
        IN unsigned int MaximumConcurrentCalls
        );

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

#ifndef NO_PLUG_AND_PLAY

    virtual void
    PnpNotify (
        );

#endif

    OSF_SCONNECTION *
    NewConnection (
        );

    RPC_TRANSPORT_ADDRESS
    InqRpcTransportAddress (
        );

    RPC_STATUS
    CompleteListen (
        );

    RPC_STATUS
    CreateThread (
        );

    virtual unsigned int // Returns the length of the secondary address.
    TransSecondarySize ( // The length will be used to allocate a buffer.
        );

    virtual RPC_STATUS
    TransSecondary ( // Places the secondary address in the specified buffer.
        IN unsigned char * Address, // Buffer for the address.
        IN unsigned int AddressLength // Length of the buffer.
        );

    void
    ServerStoppedListening (
        );

    OSF_ASSOCIATION * // Returns the association deleted or 0.
    RemoveAssociation ( // Remove the association specified by Key from this
                       // address.
        IN int Key,
        IN OSF_ASSOCIATION *pAssociation
        );

    int // Indicates success (0), or an error (-1).
    AddAssociation ( // Add the specified association to this address.
        IN OSF_ASSOCIATION * TheAssociation
        );

    OSF_ASSOCIATION *
    FindAssociation (
        IN unsigned long AssociationGroupId,
        IN RPC_CLIENT_PROCESS_IDENTIFIER * ClientProcess
        );

    int
    IsServerListening (
        ) ;

    void *
    operator new (
    size_t allocBlock,
    unsigned int xtraBytes
    );

    inline static int GetHashBucketForAssociation(IN unsigned long AssociationGroupId)
    {
        return (AssociationGroupId % NumberOfAssociationsDictionaries);
    }

    inline MUTEX *GetAssociationBucketMutex(IN int HashIndex)
    {
        MUTEX *pMutex;
        pMutex = (MUTEX *)(&AssociationBucketMutexMemory[MutexAllocationSize * HashIndex]);
        ASSERT((((ULONG_PTR)pMutex) % 4) == 0);
        return pMutex;
    }

    inline void GetDebugCellIDForThisObject(OUT DebugCellID *CellID)
    {
        GetDebugCellIDFromDebugCell((DebugCellUnion *)DebugCell, &DebugCellTag, CellID);
    }

    virtual void
    DestroyContextHandlesForInterface (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN BOOL RundownContextHandles
        );

    NETWORK_ADDRESS_VECTOR *
    GetNetworkAddressVector (
        void
        )
    {
        return ServerInfo->GetNetworkAddressVector(InqRpcTransportAddress());
    }
};


inline RPC_STATUS
OSF_ADDRESS::CreateThread (
    )
{
    return TransInfo->CreateThread();
}


inline RPC_TRANSPORT_ADDRESS
OSF_ADDRESS::InqRpcTransportAddress (
    )
/*++

Return Value:

    A pointer to the transport data for this address will be returned.

--*/
{
    return((RPC_TRANSPORT_ADDRESS)
            (((char *) this) + sizeof(OSF_ADDRESS)));
}


inline void *
OSF_ADDRESS::operator new (
    size_t allocBlock,
    unsigned int xtraBytes
    )
{
    void * pvTemp = RpcpFarAllocate(allocBlock + xtraBytes);

    return(pvTemp);
}

inline int
OSF_ADDRESS::IsServerListening (
    )
{
    return ServerListeningFlag ;
}

#define RPCSTATUS_GET_CREATETHREAD(x)  Server->CreateThread( \
                         (THREAD_PROC)&ReceiveLotsaCallsWrapper,x);

class OSF_SBINDING
{
private:

    RPC_INTERFACE *       Interface;
    unsigned int          PresentContext;
    unsigned long         CurrentSecId;
    int                   SelectedTransferSyntaxIndex;  // zero based

public:
    unsigned long SequenceNumber ;

    OSF_SBINDING ( // Constructor.
        IN RPC_INTERFACE * TheInterface,
        IN int PContext,
        IN int SelectedTransferSyntaxIndex
        );

    RPC_INTERFACE *
    GetInterface (
        ) {return(Interface);}

    unsigned int
    GetPresentationContext (
        ) {return(PresentContext);}

    inline RPC_STATUS
    CheckSecurity (
       SCALL * Call,
       unsigned long AuthId
       );

    void GetSelectedTransferSyntaxAndDispatchTable(
        OUT RPC_SYNTAX_IDENTIFIER **SelectedTransferSyntax,
        OUT PRPC_DISPATCH_TABLE *SelectedDispatchTable)
    {
        Interface->GetSelectedTransferSyntaxAndDispatchTable(SelectedTransferSyntaxIndex,
            SelectedTransferSyntax, SelectedDispatchTable);
    }

    inline RPC_SYNTAX_IDENTIFIER *GetInterfaceId (
        void
        )
    {
        return &(Interface->InqInterfaceInformation()->InterfaceId);
    }

    inline RPC_SYNTAX_IDENTIFIER *GetTransferSyntaxId (
        void
        )
    {
        RPC_DISPATCH_TABLE *Ignored;
        RPC_SYNTAX_IDENTIFIER *TransferSyntaxId;

        Interface->GetSelectedTransferSyntaxAndDispatchTable(SelectedTransferSyntaxIndex,
            &TransferSyntaxId, &Ignored);

        return TransferSyntaxId;
    }

#if DBG
    inline void 
    InterfaceForCallDoesNotUseStrict (
        void
        )
    {
        Interface->InterfaceDoesNotUseStrict();
    }
#endif
};

class OSF_SCONNECTION;
NEW_SDICT(OSF_SBINDING);
NEW_SDICT(SECURITY_CONTEXT);


class OSF_SCALL : public SCALL
/*++
Class Description:

Fields:
    ObjectUuid - Contains the object UUID specified for the remote
        procedure call by the client.

    ObjectUuidSpecified - Contains a flag which indicates whether
        or not the remote procedure call specified an object UUID.
        This field will be zero if an object UUID was not specified
        in the call, and non-zero if one was specified.

    ServerSecurityContext - Contains the security context for this connection
        if security is being performed at the rpc protocol level.

    AuthenticationLevel - Contains a value indicating what authentication
        is being performed at the rpc protocol level.  A value of
        RPC_C_AUTHN_LEVEL_NONE indicates that no authentication is being
        performed at the rpc protocol level.

    AuthenticationService - Contains which authentication service is being
        used at the rpc protocol level.

    AuthorizationService - Contains which authorization service is being
        used at the rpc protocol level.

    AdditionalSpaceForSecurity - Contains the amount of space to save for
        security in each buffer we allocate.

    CachedBuffer - Contains cached buffer.

    CachedBufferLength - Contains the length of the cached buffer.

    DceSecurityInfo - Contains the security information necessary for
        DCE security to work correctly.

    SavedPac - While a call is being dispatched to manager, the manager
        could query for a PAC. However, manager is not explicitly going
        to free the PAC. Runtime is supposed to do that. This feild
        takes care of that.

    AuthzSvc - Authorization service

--*/
{
friend OSF_SCONNECTION;
private:
    // data member ordering is optimized for locality
    // If you modify something, make sure that the section boundaries are
    // preserved. It is assumed that in the common case the OSF_SCALL is used
    // by a thread at a time. Ordering is by frequency of usage, regardless of
    // read/write
    // Most frequently used section ( >= 3 times per call):
    OSF_SCONNECTION *Connection;
    OSF_SBINDING * CurrentBinding;
    void *CurrentBuffer;
    unsigned int CurrentBufferLength ;
    int CurrentOffset;
    ULONG MaxSecuritySize;
    // the info for the first call. This has to be on the
    // heap, because it is used on the async paths
    // recursive callback info is on the stack, because we
    // know in recursive callback we're only sync
    RPC_MESSAGE FirstCallRpcMessage;
    RPC_RUNTIME_INFO FirstCallRuntimeInfo;

    // ~2 times per call use
    OSF_ADDRESS *Address;
    unsigned long CallId;
    int CallStack;
    void *LastBuffer;
    int DispatchBufferOffset;
    ULONG MaximumFragmentLength;
    MUTEX CallMutex;
    BOOL FirstSend;

    // ~1 time per call use
    unsigned int ObjectUuidSpecified;
    BOOL fCallDispatched;
    int ProcNum;
    OSF_SCALL_STATE CurrentState;
    BOOL fSecurityFailure;
    THREAD * Thread;
    int DispatchFlags;
    CellTag CellTag;
    DebugCallInfo *DebugCell;

    // not used or used few times
    int FirstFrag ;
    BOOL fPipeCall;
    int AllocHint;
    ULONG RcvBufferLength;
    ULONG NeededLength;
    ULONG ActualBufferLength;
    QUEUE BufferQueue;
    BOOL fChoked;
    BOOL fPeerChoked;

    int      CallOrphaned;
    unsigned long SavedHeaderSize;
    void  * SavedHeader;
    EVENT SyncEvent;
    void *SendContext;
    RPC_UUID ObjectUuid;

    BOOL fAsyncPipeCall;

    // This is a captured value of the flag RPC_C_NOTIFY_ON_SEND_COMPLETE
    // from pAsync->Flags.  We need to capture it since when async pipes are
    // used with no notification pAsync may be gone while a send-complete
    // response is being processed, but we will need to read this flag.
    BOOL fNotifyOnSendComplete;

    void
    UpdateBuffersAfterNonLastSend (
        IN PVOID NewBuffer,
        IN int RemainingLength,
        IN OUT RPC_MESSAGE *Message
        )
    {
        if (RemainingLength)
            {
            Message->Buffer = NewBuffer;
            Message->BufferLength = RemainingLength;
            ActualBufferLength = RemainingLength;
            }
        else
            {
            Message->Buffer = 0;
            Message->BufferLength = 0;
            ActualBufferLength = 0;
            }
    }

public:
    LONG     CancelPending;

    OSF_SCALL (
        IN OSF_SCONNECTION *Connection,
        IN OUT RPC_STATUS *Status
        );

    virtual ~OSF_SCALL (
        );

    virtual RPC_STATUS
    SendReceive (
        IN OUT PRPC_MESSAGE Message
        );

    virtual RPC_STATUS
    NegotiateTransferSyntax (
        IN OUT PRPC_MESSAGE Message
        );

    virtual RPC_STATUS
    GetBuffer (
        IN OUT PRPC_MESSAGE Message,
        IN UUID *ObjectUuid
        );

    RPC_STATUS
    GetBufferDo (
        IN OUT void ** ppBuffer,
        IN unsigned int culRequiredLength,
        IN BOOL fDataValid = 0,
        IN unsigned int DataLength = 0,
        IN unsigned long Extra = 0
        );

    void
    FreeBufferDo (
        IN void *pBuffer
        );

    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
    Receive (
        IN OUT 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
        ) ;

    void
    SendFault (
        IN RPC_STATUS Status,
        IN int DidNotExecute
        );

    RPC_STATUS
    TransGetBuffer ( // Allocate a buffer of the specified size.
        OUT void * * Buffer,
        IN unsigned int BufferLength
        );

    virtual void
    TransFreeBuffer ( // Free a buffer.
        IN void  * Buffer
        );

    virtual BOOL
    IsSyncCall (
        );

    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 void
    ProcessSendComplete (
        IN RPC_STATUS EventStatus,
        IN BUFFER Buffer
        );

    BOOL
    BeginRpcCall (
        IN rpcconn_common * Packet,
        IN unsigned int PacketLength
        );

    BOOL
    ProcessReceivedPDU (
        IN rpcconn_common * Packet,
        IN unsigned int PacketLength,
        IN BOOL fDispatch = 0
        );

    RPC_STATUS
    GetCoalescedBuffer (
        IN PRPC_MESSAGE Message,
        BOOL fForceExtra
        );

    BOOL
    DispatchRPCCall (
        IN unsigned char PTYPE,
        IN unsigned short OpNum
        );

    void
    DispatchHelper (
        );

    RPC_STATUS
    Send(
        IN OUT PRPC_MESSAGE Message
        ) ;

    RPC_STATUS
    SendRequestOrResponse (
        IN OUT PRPC_MESSAGE Message,
        IN unsigned char PacketType
        );

    RPC_STATUS
    SendNextFragment (
        void
        );

    void
    InquireObjectUuid (
        OUT RPC_UUID  * ObjectUuid
        );

    RPC_STATUS
    ConvertToServerBinding (
        OUT RPC_BINDING_HANDLE __RPC_FAR * ServerBinding
        );

    RPC_STATUS
    ToStringBinding (
        OUT RPC_CHAR  *  * StringBinding
        );

    RPC_STATUS
    Cancel(
        void * ThreadHandle
        );

    unsigned
    TestCancel(
        );

    RPC_STATUS
    ImpersonateClient (
        );

    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
    GetAssociationContextCollection (
        OUT ContextCollection **CtxCollection
        ) ;

    virtual RPC_STATUS
    IsClientLocal (
        OUT unsigned int  * ClientLocalFlag
        ) ;

    virtual void 
    IsClientDisconnected (
        OUT BOOL *ClientIsDisconnected
        );

    virtual RPC_STATUS
    InqTransportType(
        OUT unsigned int __RPC_FAR * Type
        ) ;

    void
    ActivateCall (
        );

    virtual void
    FreeObject (
        );

    virtual void
    RemoveReference (
       );

    void * operator new (
       size_t allocBlock,
       unsigned int xtraBytes
       );

    void
    CleanupCall (
        );

    void CleanupCallAndSendFault (IN RPC_STATUS Status,
        IN int DidNotExecute);

    virtual RPC_STATUS
    InqConnection (
        OUT void **ConnId,
        OUT BOOL *pfFirstCall
        );

    void
    AbortCall (
        )
    {
        CallMutex.Request();

        CurrentState = CallAborted;
        AsyncStatus = RPC_S_CALL_FAILED;

        // Wake up the thread that was flow controlled, if any
        if (fChoked == 1)
            {
            // Raising event for choked OSF_SCALL
            fChoked = 0;
            SyncEvent.Raise();
            CallMutex.Clear();

            // Since this is a pipe call, cleanup will be done on the send
            // thread; so return.
            return;
            }

        CallMutex.Clear();

        if (fCallDispatched == 0)
            {
            CleanupCall();

            //
            // Remove the reply reference
            //
            RemoveReference();

            //
            // Remove the dispatch reference
            //
            RemoveReference();

            return;
            }
    
        if (CallStack > 0)
            {
            SyncEvent.Raise();
            }

    }

    virtual RPC_STATUS
    InqSecurityContext (
        OUT void **SecurityContextHandle
        );

    inline BOOL
    IsSecure(
        void
        );

    inline void DeactivateCall(void)
    {
        if (DebugCell)
            {
            DebugCell->Status = csAllocated;
            // take down the async and pipe call flags
            // since they are per call instance
            DebugCell->CallFlags &= ~(DBGCELL_ASYNC_CALL | DBGCELL_PIPE_CALL);
            }
    }

    RPC_STATUS
    InqLocalConnAddress (
        IN OUT void *Buffer,
        IN OUT unsigned long *BufferSize,
        OUT unsigned long *AddressFormat
        );

#if DBG
    virtual void
    InterfaceForCallDoesNotUseStrict (
        void
        );
#endif

    void
    WakeUpPipeThreadIfNecessary (
        IN RPC_STATUS Status
        );

    inline RPC_STATUS
    TurnOnOffKeepAlives (
        IN BOOL TurnOn,
        IN ULONG Time,
        IN ULONG Interval
        );

    BOOL ProcessVerificationTrailer (
        IN rpc_sec_verification_trailer_command *FirstCommand,
        IN unsigned char *BufferEnd,
        IN RPC_MESSAGE *RpcMessage
        );

    BOOL CheckVerificationTrailer (
        IN unsigned char *BufferStart,
        IN unsigned char *BufferEnd,
        IN RPC_MESSAGE *RpcMessage
        );
};

inline void *
OSF_SCALL::operator new (
    size_t allocBlock,
    unsigned int xtraBytes
    )
{
    void * pvTemp = RpcpFarAllocate(allocBlock + xtraBytes);

    return(pvTemp);
}


inline BOOL
OSF_SCALL::IsSyncCall (
    )
{
    return !pAsync ;
}

NEW_SDICT2(OSF_SCALL, PVOID);

class OSF_SCALL_AVRF : public OSF_SCALL
/*++

Class Description:

  This class overwrites an OSF_SCALL for use with RPC verifier.
  Methods will perform some checks.

--*/
{
public:

    OSF_SCALL_AVRF (
        IN OSF_SCONNECTION *Connection,
        IN OUT RPC_STATUS *Status
        ) : OSF_SCALL(Connection, Status) {}

    RPC_STATUS
    ImpersonateClient (
        )
    {
    // If we are running with RPC veirfier and fault injection is enabled
    // for RpcImpersonateClient, see if we should fail it.
    if (pRpcVerifierSettings->fFaultInjectImpersonateClient)
        {
        // See if enough time has passed to start the fault injection.
        if (!pRpcVerifierSettings->DelayFaultInjectImpersonateClient ||
            GetTickCount() - gProcessStartTime > pRpcVerifierSettings->DelayFaultInjectImpersonateClient*1000)
            {
            if (RndBool(pRpcVerifierSettings->ProbFaultInjectImpersonateClient))
                {
                return RPC_S_OUT_OF_MEMORY;
                }
            }
        }

    return OSF_SCALL::ImpersonateClient();
    }

};

typedef SECURITY_STATUS
(SEC_ENTRY *SecpSetIPAddressFn)
    (
    PUCHAR  lpIpAddress,
    ULONG   cchIpAddress
    );


class OSF_SCONNECTION : public SCONNECTION
/*++

Class Description:

Fields:
    Association - Contains the association to which this connection
        belongs.  This field will be zero until after the initial client
        bind request has been accepted.

    SavedHeader - Unbyte swapped header + - do that check sums work

    ServerInfo - Contains the pointers to the loadable transport
        routines for the transport type of this connection.

    ConnectionClosedFlag - Contains a flag which will be non-zero if
        the connection is closed, and zero otherwise.

    ReferenceCount - The open connection and each dispatched call
        own one reference.
--*/
{
friend OSF_SCALL;
friend OSF_ADDRESS;
private:
   // data member ordering is optimized for locality
   // If you modify something, make sure that the section boundaries are
   // preserved. It is assumed that in the common case the OSF_SCALL is used
   // by a thread at a time. Ordering is by frequency of usage, regardless of
   // read/write
   // Most frequenty used section (>= 3 times per call)
   BOOL fExclusive;
   BOOL CachedSCallAvailable;
   CLIENT_AUTH_INFO AuthInfo;   // actually, only the AuthLevel is used, but we don't want to
                                // split it

   // ~2 times per call
   RPC_CONNECTION_TRANSPORT * ServerInfo;
   unsigned int AdditionalSpaceForSecurity;
   unsigned int ConnectionClosedFlag;
public:
   RPC_TRANSPORT_CONNECTION TransConnection;
private:
   SECURITY_CONTEXT * CurrentSecurityContext;

   // ~1 times per call
   OSF_ASSOCIATION * Association;
   OSF_ADDRESS *Address;
   unsigned long DataRep;
   unsigned long RpcSecurityBeingUsed;
   DCE_SECURITY_INFO DceSecurityInfo;
   OSF_SCALL *CachedSCall;
   OSF_SBINDING_DICT Bindings;
   DebugConnectionInfo *DebugCell;
public:
   unsigned short MaxFrag;
private:
   CellTag DebugCellTag;

   // actively used in non-nominal paths
   OSF_SCALL_DICT2 CallDict;
   MUTEX ConnMutex;
   SECURITY_CONTEXT_DICT SecurityContextDict;
   void  * SavedHeader;
   unsigned long SavedHeaderSize;

   // not used or used few times
   unsigned AuthContextId;
   unsigned long SecurityContextAltered;
   unsigned long CurrentCallId;
   BOOL AuthContinueNeeded;
   BOOL fDontFlush;
   DCE_INIT_SECURITY_INFO InitSecurityInfo;
   BOOL fKeepalivesTurnedOn;

   static const unsigned int ClientSupportsHeaderSigning = 1;
   // can be ClientSupportsHeaderSigning. Not protected from multithreaded access
   CompositeFlags Flags;

   static DLL *Secur32Dll;
   static SecpSetIPAddressFn SecpSetIPAddressFnPtr;

public:
   BOOL fFirstCall;
   BOOL fCurrentlyDispatched;
   QUEUE CallQueue;

    OSF_SCONNECTION (
        IN OSF_ADDRESS * TheAddress,
        IN RPC_CONNECTION_TRANSPORT * ServerInfo,
        IN OUT RPC_STATUS  * RpcStatus
        );

    ~OSF_SCONNECTION (
        );

    virtual RPC_STATUS
    TransSend (
        IN void * Buffer,
        IN unsigned int BufferLength
        );

    virtual RPC_STATUS
    TransAsyncSend (
        IN void * Buffer,
        IN unsigned int BufferLength,
        IN void *SendContext
        );

    virtual RPC_STATUS
    TransAsyncReceive (
        );

    virtual void
    FreeObject (
        );

    void
    AbortConnection (
        );

    unsigned int
    TransMaximumSend (
        );

    RPC_STATUS
    TransImpersonateClient (
        );

    void
    TransRevertToSelf (
        );

    void
    TransQueryClientProcess (
        OUT RPC_CLIENT_PROCESS_IDENTIFIER * ClientProcess
        );

    void
    TransQueryClientIpAddress (
        IN OUT RPC_CLIENT_IP_ADDRESS *ClientIpAddress
        );

    RPC_STATUS
    TransQueryClientNetworkAddress (
        OUT RPC_CHAR ** NetworkAddress
        );

    void
    SetDictKey (
        IN int DictKey
        );

    void * operator new (
    size_t allocBlock,
    unsigned int xtraBytes
    );

    RPC_STATUS
    SendFragment(
        IN OUT rpcconn_common  *pFragment,
        IN unsigned int LastFragmentFlag,
        IN unsigned int HeaderSize,
        IN unsigned int MaxSecuritySize,
        IN unsigned int DataLength,
        IN unsigned int MaximumFragmentLength,
        IN unsigned char  *MyReservedForSecurity,
        IN BOOL fAsync = 0,
        IN void *SendContext = 0
        ) ;

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

    RPC_STATUS
    InquireCallAttributes (
        IN OUT void *RpcCallAttributes
        );

    RPC_STATUS
    ImpersonateClient (
        );

    RPC_STATUS
    RevertToSelf (
        );

    RPC_STATUS
    GetAssociationContextCollection (
        OUT ContextCollection **AssociationContext
        );

    RPC_STATUS
    IsClientLocal (
        OUT unsigned int  * ClientLocalFlag
        );

    void 
    IsClientDisconnected (
        OUT BOOL *ClientIsDisconnected
        )
    {
        *ClientIsDisconnected = IsDeleted();
    }

    RPC_STATUS
    TransGetBuffer ( // Allocate a buffer of the specified size.
        OUT void * * Buffer,
        IN unsigned int BufferLength
        );

    virtual void
    TransFreeBuffer ( // Free a buffer.
        IN void  * Buffer
        );

    int
    AssociationRequested (
        IN rpcconn_bind * BindPacket,
        IN unsigned int BindPacketLength
        );

    RPC_STATUS
    EatAuthInfoFromPacket (
        IN rpcconn_request  * Request,
        IN OUT int  * RequestLength,
        IN OUT void  *  *SavedHeader,
        IN OUT unsigned long *SavedHeaderSize
        );

    int // Indicates success (0), or an internal error code.
    AlterContextRequested ( // Process the alter context request.  Send
                            // a reply.
        IN rpcconn_alter_context * pAlterContext,
        IN unsigned int culAlterContextLength
        );

    int // Indicates success (0), or an internal error code.
    SendBindNak ( // Construct and send the bind nak packet using the
                  // specified reject reason.
        IN p_reject_reason_t reject_reason,
        IN unsigned long CallId
        );

    inline
    SECURITY_CONTEXT *
    FindSecurityContext(
        unsigned long Id,
        unsigned long Level,
        unsigned long Svc
       );

    BOOL
    MaybeQueueThisCall (
        IN OSF_SCALL *ThisCall
        );

    void
    AbortQueuedCalls (
        );

    void
    DispatchQueuedCalls (
        );

    inline BOOL IsExclusive(void)
    {
        return fExclusive;
    }

    inline void SetClientSupportsHeaderSigningFlag(void)
    {
        Flags.SetFlagUnsafe(ClientSupportsHeaderSigning);
    }
    inline void ClearClientSupportsHeaderSigningFlag(void)
    {
        Flags.ClearFlagInterlocked(ClientSupportsHeaderSigning);
    }
    inline BOOL GetClientSupportsHeaderSigningFlag(void)
    {
        return Flags.GetFlag(ClientSupportsHeaderSigning);
    }

private:

    int
    ProcessPContextList (
        IN OSF_ADDRESS * Address,
        IN p_cont_list_t * PContextList,
        IN OUT unsigned int * PContextListLength,
        OUT p_result_list_t * ResultList
        );

    RPC_STATUS
    GetServerPrincipalName (
        IN unsigned long Flags,
        OUT RPC_CHAR **ServerPrincipalName OPTIONAL
        );

    UINT
    CalculateAdditionalSpaceForSecurity (
        IN ULONG AuthenticationLevel,
        IN ULONG AuthenticationService
        );

    RPC_STATUS EnsureSecur32DllLoaded (
        void
        );

public:

    void
    SendFault (
        IN RPC_STATUS Status,
        IN int DidNotExecute,
        IN unsigned long CallId,
        IN p_context_id_t p_cont_id = 0
        );

    BOOL
    PickleEEInfoIntoPacket (
        IN size_t PickleStartOffset,
        OUT PVOID *Packet,
        OUT size_t *PacketSize);


    OSF_ASSOCIATION *
    TheAssociation (
        ) {return(Association);}

    void
    RemoveFromAssociation (
        );

    virtual RPC_STATUS
    InqTransportType(
        OUT unsigned int __RPC_FAR * Type
        ) ;

    OSF_SBINDING *
    LookupBinding (
        IN p_context_id_t PresentContextId
        );

    inline void
    CleanupPac(
        );

    void
    ProcessReceiveComplete (
        IN RPC_STATUS EventStatus,
        IN BUFFER Buffer,
        IN UINT BufferLength
        );

    void
    FreeSCall (
        IN OSF_SCALL *SCall,
        IN BOOL fRemove = 0
        );

    OSF_SCALL *
    FindCall (
        unsigned long CallId
        );

    inline RPC_STATUS
    InqLocalConnAddress (
        IN OUT void *Buffer,
        IN OUT unsigned long *BufferSize,
        OUT unsigned long *AddressFormat
        )
    {
        // Querying the local address has some transient
        // effects on the Winsock options for the connection.
        // We cannot do this on non-exclusive connections
        // as it may affect calls in progress
        if (ServerInfo->QueryLocalAddress && fExclusive)
            {
            return ServerInfo->QueryLocalAddress(TransConnection,
                Buffer,
                BufferSize,
                AddressFormat);
            }
        else
            return RPC_S_CANNOT_SUPPORT;
    }

    RPC_STATUS
    TurnOnOffKeepAlives (
        IN BOOL TurnOn,
        IN ULONG Timeout,
        IN ULONG Interval
        );

    inline BOOL IsHttpTransport (
        void
        )
    {
        return (ServerInfo->SetLastBufferToFree != NULL);
    }

    inline RPC_STATUS SetLastBufferToFree (
        IN void *BufferToFree
        )
    {
        ASSERT(ServerInfo->SetLastBufferToFree);
        return ServerInfo->SetLastBufferToFree (TransConnection, BufferToFree);
    }

    RPC_STATUS
    AcceptFirstTime (
        IN SECURITY_CREDENTIALS * NewCredentials,
        IN SECURITY_BUFFER_DESCRIPTOR PAPI * InputBufferDescriptor,
        IN OUT SECURITY_BUFFER_DESCRIPTOR PAPI * OutputBufferDescriptor,
        IN unsigned long AuthenticationLevel,
        IN unsigned long DataRepresentation,
        IN unsigned long NewContextNeededFlag
        );

    RPC_STATUS
    AcceptThirdLeg (
        IN unsigned long DataRepresentation,
        IN SECURITY_BUFFER_DESCRIPTOR PAPI * BufferDescriptor,
        OUT SECURITY_BUFFER_DESCRIPTOR PAPI * OutBufferDescriptor
        );
};

inline  OSF_SCALL *
OSF_SCONNECTION::FindCall (
    unsigned long CallId
    )
{
    OSF_SCALL *SCall;

    ConnMutex.Request();
    SCall = CallDict.Find(ULongToPtr(CallId));
    if (SCall)
        {
        SCall->AddReference(); // CALL++
        }
    ConnMutex.Clear();

    return SCall;
}

inline void *
OSF_SCONNECTION::operator new (
    size_t allocBlock,
    unsigned int xtraBytes
    )
{
    void * pvTemp = RpcpFarAllocate(allocBlock + xtraBytes);

    return(pvTemp);
}


inline void
OSF_SCONNECTION::CleanupPac (
    )
{
    if ((CurrentSecurityContext != 0) && (AuthInfo.PacHandle != 0))
       {
       CurrentSecurityContext->DeletePac( AuthInfo.PacHandle );
       AuthInfo.PacHandle = 0;
       }
}



inline
SECURITY_CONTEXT *
OSF_SCONNECTION::FindSecurityContext(
       unsigned long Id,
       unsigned long Level,
       unsigned long Svc
       )
{
  SECURITY_CONTEXT *Sec;
  DictionaryCursor cursor;

  SecurityContextDict.Reset(cursor);
  while ( (Sec = SecurityContextDict.Next(cursor)) != 0 )
        {
        if ( (Sec->AuthContextId == Id)
           &&(Sec->AuthenticationLevel == Level)
           &&(Sec->AuthenticationService == Svc) )
           {
           break;
           }
        }

   return (Sec);
}


inline RPC_STATUS
OSF_SCONNECTION::InqTransportType(
        OUT unsigned int __RPC_FAR * Type
        )
{
    *Type = TRANSPORT_TYPE_CN ;

    return (RPC_S_OK) ;
}


inline RPC_STATUS
OSF_SCALL::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
    )
{
    return Connection->InquireAuthClient(Privileges,
                                              ServerPrincipalName,
                                              AuthenticationLevel,
                                              AuthenticationService,
                                              AuthorizationService,
                                              Flags);

}

inline RPC_STATUS
OSF_SCALL::InquireCallAttributes (
    IN OUT void *RpcCallAttributes
    )
{
    return Connection->InquireCallAttributes(RpcCallAttributes);
}

inline RPC_STATUS
OSF_SCALL::IsClientLocal (
    OUT unsigned int  * ClientLocalFlag
    )
{
    return Connection->IsClientLocal(ClientLocalFlag);
}

inline void 
OSF_SCALL::IsClientDisconnected (
    OUT BOOL *ClientIsDisconnected
    )
{
    Connection->IsClientDisconnected(ClientIsDisconnected);
}

inline RPC_STATUS
OSF_SCALL::InqTransportType(
   OUT unsigned int __RPC_FAR * Type
   )
{
    return Connection->InqTransportType(Type);
}

inline RPC_STATUS
OSF_SCALL::InqSecurityContext (
    OUT void **SecurityContextHandle
    )
{
    *SecurityContextHandle = Connection->CurrentSecurityContext->InqSecurityContext();
    return RPC_S_OK;
}

inline BOOL
OSF_SCALL::IsSecure(
    void
    )
{
    return (Connection->CurrentSecurityContext != NULL);
}


inline void
OSF_SCALL::ActivateCall (
    )
{
    CallStack = 0;
    ObjectUuidSpecified = 0;
    CallOrphaned = 0;
    CurrentBuffer = 0;
    CurrentBufferLength = 0 ;
    CurrentOffset = 0;
    AsyncStatus = RPC_S_OK;
    Address = Connection->Address;
    fPipeCall = 0;
    fCallDispatched = 0;
    DispatchBuffer = 0;
    DispatchBufferOffset = 0;
    AllocHint = 0;

    RcvBufferLength = 0;
    CurrentState = NewRequest;
    FirstFrag = 1;
    pAsync = 0;
    CallingThread = 0;
    CachedAPCInfoAvailable = 1;
    NestingCall = 0;
    FirstSend = 1;
    NeededLength = 0;
    LastBuffer = 0;
    MaxSecuritySize = 0;
    MaximumFragmentLength = Connection->MaxFrag;
    fChoked = 0;
    fPeerChoked = 0;
    fSecurityFailure = 0;
    DispatchFlags = RPC_BUFFER_COMPLETE;
    CurrentBinding = 0;
    fAsyncPipeCall = 0;
    fNotifyOnSendComplete = 0;
    
    if (DebugCell)
        {
        DebugCell->Status = csActive;
        }

    //
    // Start out with two references. One for the dispatch
    // and the other for the reply. This overrides the default
    // which is one reference.
    //
    //
    // Try changing this to a better interlocked operation
    //

    // we have the following special case to take care of:
    // for performance reasons, the previous call will make
    // itself available before it takes down its references.
    // We may start piling our references on top of its 
    // references, thus preventing the refcount from dropping
    // to zero, and leaving one extra refcount on the connection
    // (because the call will drop its refcount on the connection
    // only when its own refcount goes to 0). This if statement
    // will detect when this special case happens, and will
    // drop the connection refcount for the previous call
    if ((AddReference() > 1) && (Connection->CachedSCall == this) && (Connection->IsExclusive()))
        Connection->RemoveReference();
    AddReference();
}

inline void
OSF_SCALL::RemoveReference (
    )
{
    OSF_SCALL *DeletedCall;
    int refcount;

    if (Connection->fExclusive)
        {
        REFERENCED_OBJECT::RemoveReference();
        }
    else
        {
        Connection->ConnMutex.Request();
        refcount = RefCount.Decrement();

        LogEvent(SU_SCALL, EV_DEC, this, 0, refcount, 1);

        if (refcount == 0)
            {
            DeletedCall = Connection->CallDict.Delete(ULongToPtr(CallId));
            Connection->ConnMutex.Clear();

            ASSERT(DeletedCall == 0 || DeletedCall == this);

            FreeObject();

            //
            // Warning: The SCALL could have been nuked at this point.
            // DO NOT touch the SCALL after this
            //
            }
        else
            {
            Connection->ConnMutex.Clear();
            }
        }
}


inline void
OSF_SCALL::CleanupCall (
    )
{
    BUFFER Buffer;
    unsigned int ignore;
    BOOL fMutexTaken = FALSE;
    BOOL IsExclusiveConnection = Connection->IsExclusive();

    if (pAsync)
        {
        DoPostDispatchProcessing();

        ASSERT(fCallDispatched);
        FreeBufferDo(DispatchBuffer);
        if (IsExclusiveConnection)
            {
            CurrentBinding->GetInterface()->EndCall(0, 1);
            if (CurrentBinding->GetInterface()->IsAutoListenInterface())
                {
                // This is the path where async calls complete.
                // We need to decrement CallNumber.
                CurrentBinding->GetInterface()->EndAutoListenCall(TRUE);
                }   
            }
        }

    if (fCallDispatched == 0 && DispatchBuffer)
        {
        FreeBufferDo(DispatchBuffer);
        }

   Connection->CleanupPac();

   DeactivateCall();

   // For non-exclusive pipe calls we need to make the call available and
   // free the buffers within a critical section.  This ensures that another
   // thread will not pick up the available call and start adding buffers to the
   // queue while we are wiping it out.
   if (fPipeCall && !IsExclusiveConnection)
       {
       CallMutex.Request();
       fMutexTaken = TRUE;
       }

   if (IsExclusiveConnection)
       {
       Connection->CachedSCallAvailable = 1;
       }

    // Buffers must not be left over from this call
    // If there are left over buffers, free them
    if (!BufferQueue.IsQueueEmpty())
        {
        if (fMutexTaken == FALSE)
            CallMutex.Request();

        while (Buffer = BufferQueue.TakeOffQueue(&ignore))
            {
            Connection->TransFreeBuffer((char *) Buffer-sizeof(rpcconn_response));
            }

        CallMutex.Clear();
        fMutexTaken = FALSE;
        }

    if (fMutexTaken == TRUE)
        CallMutex.Clear();
}


inline void
OSF_SCALL::FreeObject (
    )
/*++
Function Name:CleanupCall

Parameters:

Description:

Returns:

--*/
{
   LogEvent(SU_SCALL, EV_DELETE, this, 0, 0, 0);
   Connection->FreeSCall(this);
}

inline RPC_STATUS
OSF_SCALL::InqConnection (
    OUT void **ConnId,
    OUT BOOL *pfFirstCall
    )
{
    ASSERT(Connection);
    *ConnId = Connection;

    if (InterlockedIncrement((LONG *) &(Connection->fFirstCall)) == 1)
        {
        *pfFirstCall = 1;
        }
    else
        {
        *pfFirstCall = 0;
        }

    return RPC_S_OK;
}

inline RPC_STATUS
OSF_SCALL::TurnOnOffKeepAlives (
    IN BOOL TurnOn,
    IN ULONG Time,
    IN ULONG Interval
    )
{
    return Connection->TurnOnOffKeepAlives (TurnOn, Time, Interval);
}


class OSF_ASSOCIATION : public ASSOCIATION_HANDLE
{
private:

    int ConnectionCount;
    unsigned long AssociationGroupId;
    int AssociationDictKey;
    OSF_ADDRESS * Address;
    RPC_CLIENT_PROCESS_IDENTIFIER ClientProcess;

public:
    OSF_ASSOCIATION (
        IN OSF_ADDRESS * TheAddress,
        IN RPC_CLIENT_PROCESS_IDENTIFIER * ClientProcess,
        OUT RPC_STATUS * Status
        );

    ~OSF_ASSOCIATION ( // Destructor.
        );

    void
    AddConnection ( // Add a connection to the association.
        void
        );

    // Remove a connection from the association without taking
    // the mutex. Returns non-zero if 'this' is to be deleted
    BOOL
    RemoveConnectionUnsafe ( 
        void
        );

    void
    RemoveConnection ( // Remove a connection from the association.
        void
        );

    int // Returns the association group id for this association.
    AssocGroupId (
        void
        ) 
    {
        return(AssociationGroupId);
    }

    OSF_ADDRESS *
    TheAddress (
        void
        ) 
    {
        return(Address);
    }

    int
    IsMyAssocGroupId (
        IN unsigned long PossibleAssocGroupId,
        IN RPC_CLIENT_PROCESS_IDENTIFIER * ClientProcess
        );

    virtual RPC_STATUS CreateThread(void);
};


inline int
OSF_ASSOCIATION::IsMyAssocGroupId (
    IN unsigned long PossibleAssocGroupId,
    IN RPC_CLIENT_PROCESS_IDENTIFIER * ClientProcess
    )
/*++

Routine Description:

    We compare the supplied possible association group id against my
    association group id in this routine.

Arguments:

    PossibleAssocGroupId - Supplies a possible association group id to
        compare against mine.

    ClientProcess - Supplies the identifier for the client process at the
        other end of the connection requesting this association.

Return Value:

    Non-zero will be returned if the possible association group id is the
    same as my association group id.

--*/
{
    if (PossibleAssocGroupId == AssociationGroupId)
        {
        if (this->ClientProcess.Compare(ClientProcess))
            {
            RpcpErrorAddRecord(EEInfoGCRuntime, 
                RPC_S_ENTRY_NOT_FOUND, 
                EEInfoDLOSF_ASSOCIATION__IsMyAssocGroupId10,
                this->ClientProcess.GetDebugULongLong1(),
                this->ClientProcess.GetDebugULongLong2(),
                ClientProcess->GetDebugULongLong1(),
                ClientProcess->GetDebugULongLong2()
                );
            return 0;
            }
        else
            {
            return 1;
            }
        }
    else
        return 0;
}

inline void
OSF_ASSOCIATION::AddConnection (
    )
{
    int HashBucketNumber;

    // get the hashed bucket
    HashBucketNumber = Address->GetHashBucketForAssociation(AssociationGroupId);
    // verify the bucket is locked
    Address->GetAssociationBucketMutex(HashBucketNumber)->VerifyOwned();
    
    ConnectionCount ++;
}


inline void
OSF_SCONNECTION::RemoveFromAssociation (
    )
/*++

Routine Description:

    This connection will be removed from the association.  We need to do
    this so that context rundown will occur, even though the connection
    has not been deleted yet.

--*/
{
    if ( Association != 0 )
        {
        Association->RemoveConnection();
        Association = 0;
        }
}

extern RPC_TRANSPORT_INTERFACE_HEADER *
LoadableTransportServerInfo (
    IN RPC_CHAR * DllName,
    IN RPC_CHAR * RpcProtocolSequence,
    OUT RPC_STATUS * Status
    );


#endif // __OSFSVR_HXX__