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

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

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

                      Microsoft OS/2 LAN Manager
                   Copyright(c) Microsoft Corp., 1990

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

File : hndlsvr.hxx

Description :

The classes in the handle management layer which are specific to the
server runtime live in this file.  Classes common to both the client
and server runtimes are in handle.hxx.  The classes described here
are independent of specific RPC protocol as well as transport.

The class GENERIC_OBJECT is defined in handle.hxx.

A pointer to a SERVER_HANDLE object is returned by the
RpcCreateServer API.

The INTERFACE_HANDLE class represents an interface and each
INTERFACE_HANDLE object hangs from a SERVER_HANDLE object.

An ADDRESS_HANDLE object is a transport address.  When the
ADDRESS_HANDLE object is added to a SERVER_HANDLE object, a manager
will be started for the ADDRESS_HANDLE object.

The SCONNECTION class represents a call handle on the server side.

The ASSOCIATION_HANDLE class represents a client from the servers
perspective.

GENERIC_OBJECT
    SERVER_HANDLE
    INTERFACE_HANDLE
    ADDRESS_HANDLE
    MESSAGE_OBJECT
        SCONNECTION
    ASSOCIATION_HANDLE

History :

mikemon    ??-??-??    Beginning of recorded history.
mikemon    10-15-90    Changed the shutdown functionality to PauseExecution
                       rather than suspending and resuming a thread.
mikemon    12-28-90    Updated the comments to match reality.
davidst    ??          Add DG_SCALL as friend of RPC_SERVER
connieh    8-2-93      Remove DG_SCALL as friend of RPC_SERVER
tonychan   7-15-95     change RPC_ADDRESS class to have a list of NetAddr

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

// Each association handle has a set of rundown routines associated with
// it.

#ifndef __HNDLSVR_HXX__
#define __HNDLSVR_HXX__

//typedef RPC_STATUS RPC_FORWARD_FUNCTION(
//                       IN RPC_UUID        InterfaceId,
//                       IN RPC_VERSION   * InterfaceVersion,
//                       IN RPC_UUID        ObjectId,
//                       IN RPC_CHAR PAPI * RpcProtocolSequence,
//                       IN void * *        ppDestEndpoint);

#define MAX_IF_CALLS 0xFFFFFFFF


#define EP_REGISTER_NOREPLACE       0x00L
#define EP_REGISTER_REPLACE         0x01L


class RPC_SERVER;

class SCONNECTION;
class SCALL;

RPC_STATUS
RegisterEntries(
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_VECTOR * BindingVector,
    IN UUID_VECTOR * ObjUuidVector,
    IN unsigned char * Annotation,
    IN unsigned long ReplaceNoReplace
    );



class RPC_INTERFACE_MANAGER
/*++

Class Description:

    An instance of this class is the manager for a particular type UUID
    for a particular interface.  Each RPC_INTERFACE instance will contain
    a dictionary of these objects.  Rather than keep a count of the calls
    using each manager, we just never delete these objects.


Fields:

    TypeUuid - Contains the type of this interface manager.  This is the
        key which we will use to find the correct interface manager in
        dictionary of interface managers maintained by each rpc interface.

    ManagerEpv - Contains a pointer to the manager entry point vector
        for this interface manager.

    ValidManagerFlag - Contains a flag indicating whether or not this
        manager is valid (that it has been registered more recently that
        it has been unregistered).  The flag is zero if the the manager
        is not valid, and non-zero otherwise.

    ActiveCallCount - Contains a count of the number of calls which are
        active on this type manager.

--*/
{
private:

    RPC_UUID TypeUuid;
    RPC_MGR_EPV PAPI * ManagerEpv;
    unsigned int ValidManagerFlag;
    INTERLOCKED_INTEGER ActiveCallCount;

public:

    RPC_INTERFACE_MANAGER (
        IN RPC_UUID PAPI * TypeUuid,
        IN RPC_MGR_EPV PAPI * ManagerEpv
        );

    unsigned int
    ValidManager (
        );

    void
    SetManagerEpv (
        IN RPC_MGR_EPV PAPI * ManagerEpv
        );

    int
    MatchTypeUuid (
        IN RPC_UUID PAPI * TypeUuid
        );

    void
    InvalidateManager (
        );

    RPC_MGR_EPV PAPI *
    QueryManagerEpv (
        );

    void
    CallBeginning (
        );

    void
    CallEnding (
        );

    unsigned int
    InquireActiveCallCount (
        );

};


inline
RPC_INTERFACE_MANAGER::RPC_INTERFACE_MANAGER (
    IN RPC_UUID PAPI * TypeUuid,
    IN RPC_MGR_EPV PAPI * ManagerEpv
    ) : ActiveCallCount(0)
/*++

Routine Description:

    An RPC_INTERFACE_MANAGER instance starts out being valid, so
    we make sure of that here.  We also need make the type UUID of
    this be the same as the specified type UUID.

--*/
{
    ValidManagerFlag = 1;
    this->TypeUuid.CopyUuid(TypeUuid);
    this->ManagerEpv = ManagerEpv;
}


inline unsigned int
RPC_INTERFACE_MANAGER::ValidManager (
    )
/*++

Routine Description:

    An indication of whether this manager is valid manager or not is
    returned.

Return Value:

    Zero will be returned if this manager is not a valid manager;
    otherwise, non-zero will be returned.

--*/
{
    return(ValidManagerFlag);
}


inline void
RPC_INTERFACE_MANAGER::SetManagerEpv (
    IN RPC_MGR_EPV PAPI * ManagerEpv
    )
/*++

Routine Description:

    This writer is used to set the manager entry point vector for
    this interface manager.

Arguments:

    ManagerEpv - Supplies the new manager entry point vector for this.

--*/
{
    this->ManagerEpv = ManagerEpv;
    ValidManagerFlag = 1;
}


inline int
RPC_INTERFACE_MANAGER::MatchTypeUuid (
    IN RPC_UUID PAPI * TypeUuid
    )
/*++

Routine Description:

    This method compares the supplied type UUID against the type UUID
    contained in this rpc interface manager.


Arguments:

    TypeUuid - Supplies the type UUID.

Return Value:

    Zero will be returned if the supplied type UUID is the same as the
    type UUID contained in this.

--*/
{
    return(this->TypeUuid.MatchUuid(TypeUuid));
}


inline void
RPC_INTERFACE_MANAGER::InvalidateManager (
    )
/*++

Routine Description:

    This method is used to invalidate a manager

--*/
{
    ValidManagerFlag = 0;
}


inline RPC_MGR_EPV PAPI *
RPC_INTERFACE_MANAGER::QueryManagerEpv (
    )
/*++

Routine Description:

    This method is called to obtain the manager entry point vector
    for this interface manager.

Return Value:

    The manager entry point vector for this interface manager is returned.

--*/
{
    return(ManagerEpv);
}


inline void
RPC_INTERFACE_MANAGER::CallBeginning (
    )
/*++

Routine Description:

    This method is used to indicate that a remote procedure call using this
    type manager is beginning.

--*/
{
    ActiveCallCount.Increment();
}


inline void
RPC_INTERFACE_MANAGER::CallEnding (
    )
/*++

Routine Description:

    We are being notified that a remote procedure call using this type
    manager is done.

--*/
{
    ActiveCallCount.Decrement();
}


inline unsigned int
RPC_INTERFACE_MANAGER::InquireActiveCallCount (
    )
/*++

Return Value:

    The number of remote procedure calls actively using this type manager
    will be returned.

--*/
{
    return((unsigned int) ActiveCallCount.GetInteger());
}



class RPC_INTERFACE;

#if !defined(NO_LOCATOR_CODE)
class NS_ENTRY
{
friend class RPC_INTERFACE;
public:
    int Key;

private:
    unsigned long EntryNameSyntax;
    RPC_CHAR *EntryName;

public:
    NS_ENTRY(
        IN unsigned long MyEntryNameSyntax,
        RPC_CHAR *MyEntryName,
        OUT RPC_STATUS *Status
        );

    ~NS_ENTRY(
        );

    BOOL
    Match (
       IN unsigned long MyEntryNameSyntax,
       IN RPC_CHAR *MyEntryName
       );
};

inline
NS_ENTRY::NS_ENTRY(
    IN unsigned long MyEntryNameSyntax,
    IN RPC_CHAR *MyEntryName,
    IN RPC_STATUS *Status
    )
{
    int Length = (RpcpStringLength(MyEntryName)+1) * sizeof(RPC_CHAR);
    EntryNameSyntax = MyEntryNameSyntax;
    Key = -1;

    EntryName = (RPC_CHAR *) RpcpFarAllocate(Length);
    if (EntryName == 0)
        {
        *Status = RPC_S_OUT_OF_MEMORY;
        return;
        }

    RpcpStringCopy(EntryName, MyEntryName);
    *Status = RPC_S_OK;
}

inline
NS_ENTRY::~NS_ENTRY(
    )
{
    if (EntryName)
        {
        RpcpFarFree(EntryName);
        }
}

inline
BOOL
NS_ENTRY::Match (
    IN unsigned long MyEntryNameSyntax,
    IN RPC_CHAR *MyEntryName
    )
{
    if (MyEntryNameSyntax == EntryNameSyntax
        && RpcpStringCompare(MyEntryName, EntryName) == 0)
        {
        return TRUE;
        }

    return FALSE;
}

NEW_SDICT(NS_ENTRY);
#endif

NEW_SDICT(RPC_INTERFACE_MANAGER);

#if DBG
typedef enum tagInterfaceUsesStrictContextHandles
{
    iuschNo,
    iuschDontKnow,
    iuschYes
} InterfaceUsesStrictContextHandles;
#endif


class RPC_INTERFACE
/*++

Class Description:

    This class represents an RPC interface.  Rather than keep a count
    of the number of calls active (and bindings in the connection
    oriented runtimes), we never delete instances of this class.  Hence,
    we need a flag indicating whether this interface is active or not.
    What we do is to keep a count of the number of managers for this
    interface.

    Once an interface is loaded, it can not be unloaded.  The application
    has no way of knowing when all calls using stubs for the interface
    have completed.

Fields:

    RpcInterfaceInformation - Contains a description of this interface.
        The interface UUID and version, as well as transfer syntax, live
        in this field.  In addition, the stub dispatch table can be
        found here as well.

    InterfaceManagerDictionary - Contains the dictionary of interface
        managers for this interface.

    NullManagerEpv - Contains the manager entry point vector for the
        NULL type UUID.  This is an optimization for the case in which
        object UUIDs are not used.

    NullManagerFlag - Contains a flag indictating whether or not this
        interface has a manager for the NULL type UUID.  A non-zero value
        indicates there is a manager for the NULL type UUID.

    ManagerCount - Contains a count of the number of managers for this
        interface.

    Server - Contains a pointer to the rpc server which owns this
        interface.

    NullManagerActiveCallCount - Contains a count of the number of calls
        which are active on this interface using the manager for the NULL
        type UUID.

--*/
{
private:
    RPC_SERVER * Server;
    unsigned int Flags ;
    unsigned int NullManagerFlag;
    RPC_MGR_EPV PAPI * NullManagerEpv;
    RPC_IF_CALLBACK_FN PAPI *CallbackFn ;
    RPC_SERVER_INTERFACE RpcInterfaceInformation;
    MIDL_SYNTAX_INFO *TransferSyntaxesArray;
    // the count of elements in the TransferSyntaxesArray. If this is 0,
    // the server supports only one transfer syntax and this is the transfer
    // syntax in the RpcInterfaceInformation->TransferSyntax
    ULONG NumberOfSupportedTransferSyntaxes;
    // the index of the transfer syntax preferred by the server
    ULONG PreferredTransferSyntax;
    int PipeInterfaceFlag ; // if 1, the interface contains methods that use pipes
    unsigned int ManagerCount;
    unsigned int MaxCalls ;
    BOOL fReplace;
    UUID_VECTOR *UuidVector;
    RPC_INTERFACE_MANAGER_DICT InterfaceManagerDictionary;
    unsigned char Annotation[64];
#if !defined(NO_LOCATOR_CODE)
    NS_ENTRY_DICT NsEntries;
#endif
    unsigned int MaxRpcSize;
    BOOL fBindingsExported;

    // These are call reference counts.  They do not correspond to the number of active calls.
    // Every sync call takes 1 CallCount and every async call take up to 2 CallsCounts.
    // These values are used when unregistering an interface to wait for call completion.
    INTERLOCKED_INTEGER NullManagerActiveCallCount;
    INTERLOCKED_INTEGER AutoListenCallCount;

    // This is the actual number of auto listen calls in progress.
    INTERLOCKED_INTEGER AutoListenCallNumber;

#if DBG
    InterfaceUsesStrictContextHandles Strict;
#endif

    RPC_STATUS
    DispatchToStubWorker (
        IN OUT PRPC_MESSAGE Message,
        IN unsigned int CallbackFlag,
        IN PRPC_DISPATCH_TABLE DispatchTableToUse,
        OUT RPC_STATUS PAPI * ExceptionCode
        );

public:
    unsigned long SequenceNumber ;

    RPC_INTERFACE (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN RPC_SERVER * Server,
        IN unsigned int Flags,
        IN unsigned int MaxCalls,
        IN unsigned int MaxRpcSize,
        IN RPC_IF_CALLBACK_FN PAPI *IfCallbackFn,
        OUT RPC_STATUS *Status
        );

    ~RPC_INTERFACE (
        );


    int
    MatchRpcInterfaceInformation (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation
        );

    RPC_STATUS
    RegisterTypeManager (
        IN RPC_UUID PAPI * ManagerTypeUuid OPTIONAL,
        IN RPC_MGR_EPV PAPI * ManagerEpv OPTIONAL
        );

    RPC_INTERFACE_MANAGER *
    FindInterfaceManager (
        IN RPC_UUID PAPI * ManagerTypeUuid
        );

    RPC_STATUS
    DispatchToStub (
        IN OUT PRPC_MESSAGE Message,
        IN unsigned int CallbackFlag,
        IN PRPC_DISPATCH_TABLE DispatchTableToUse,
        OUT RPC_STATUS PAPI * ExceptionCode
        );

    RPC_STATUS
    DispatchToStubWithObject (
        IN OUT PRPC_MESSAGE Message,
        IN RPC_UUID * ObjectUuid,
        IN unsigned int CallbackFlag,
        IN PRPC_DISPATCH_TABLE DispatchTableToUse,
        OUT RPC_STATUS PAPI * ExceptionCode
        );

    unsigned int
    MatchInterfaceIdentifier (
        IN PRPC_SYNTAX_IDENTIFIER InterfaceIdentifier
        );

    unsigned int
    SelectTransferSyntax (
        IN PRPC_SYNTAX_IDENTIFIER ProposedTransferSyntaxes,
        IN unsigned int NumberOfTransferSyntaxes,
        OUT PRPC_SYNTAX_IDENTIFIER AcceptedTransferSyntax,
        OUT BOOL *fIsInterfaceTransferPreferred,
        OUT int *ProposedTransferSyntaxIndex,
        OUT int *AvailableTransferSyntaxIndex
        );

    RPC_STATUS
    UnregisterManagerEpv (
        IN RPC_UUID PAPI * ManagerTypeUuid, OPTIONAL
        IN unsigned int WaitForCallsToComplete
        );

    RPC_STATUS
    InquireManagerEpv (
        IN RPC_UUID PAPI * ManagerTypeUuid, OPTIONAL
        OUT RPC_MGR_EPV PAPI * PAPI * ManagerEpv
        );

    RPC_STATUS
    UpdateRpcInterfaceInformation (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN unsigned int Flags,
        IN unsigned int MaxCalls,
        IN unsigned int MaxRpcSize,
        IN RPC_IF_CALLBACK_FN PAPI *IfCallbackFn
        );

    RPC_IF_ID __RPC_FAR *
    InquireInterfaceId (
        );

    inline int
    IsAutoListenInterface(
        ) ;

    inline BOOL
    IsUnknownAuthorityAllowed();

    inline BOOL
    IsAllowingUnsecureCallbacks();

    void
    BeginAutoListenCall (
        BOOL fIncCallNumber
        ) ;

    void
    EndAutoListenCall (
        BOOL fDecCallNumber
        ) ;

    long
    InqAutoListenCallCount(
        );

    RPC_SERVER_INTERFACE *
    InqInterfaceInformation (
        );

    RPC_STATUS
    CheckSecurityIfNecessary(
        IN void * Context
        );

    inline int
    IsSecurityCallbackReqd(
        );

    inline int
    IsSecure(
       );

    inline int
    IsOle(
       );

    inline int
    IsPipeInterface(
        ) ;

    BOOL
    IsObjectSupported (
        IN RPC_UUID * ObjectUuid
        );

    void
    BeginNullManagerCall (
        void
        )
    {
        NullManagerActiveCallCount.Increment();
        LogEvent(SU_IF, EV_INC, this, 0, NullManagerActiveCallCount.GetInteger(), 1, 0);
    }

    void
    EndNullManagerCall (
        void
        )
    {
        ASSERT(NullManagerActiveCallCount.GetInteger());
        NullManagerActiveCallCount.Decrement();
        LogEvent(SU_IF, EV_DEC, this, 0, NullManagerActiveCallCount.GetInteger(), 1, 0);
    }

    void
    EndCall(
        IN unsigned int CallbackFlag,
        IN BOOL fAsync = 0
        ) ;

    RPC_STATUS
    UpdateBindings(
        IN RPC_BINDING_VECTOR *BindingVector
        );

    inline BOOL
    NeedToUpdateBindings(
        void
        );

    RPC_STATUS
    InterfaceExported (
        IN UUID_VECTOR *MyObjectUuidVector,
        IN unsigned char *MyAnnotation,
        IN BOOL MyfReplace
        );

    void
    WaitForCalls(
        void
    );

#if !defined(NO_LOCATOR_CODE)
    RPC_STATUS
    NsInterfaceExported (
        IN unsigned long EntryNameSyntax,
        IN RPC_CHAR *EntryName
        );

    RPC_STATUS
    NsInterfaceUnexported (
        IN unsigned long EntryNameSyntax,
        IN RPC_CHAR *EntryName
        );

    NS_ENTRY *
    FindEntry (
        IN unsigned long EntryNameSyntax,
        IN RPC_CHAR *EntryName
        );
#endif

    BOOL
    CallSizeLimitReached (
        IN DWORD CurrentCallSize
        )
    {
        return (CurrentCallSize > MaxRpcSize);
    }

    DWORD GetInterfaceFirstDWORD(void)
    {
        return RpcInterfaceInformation.InterfaceId.SyntaxGUID.Data1;
    }

    PRPC_DISPATCH_TABLE GetDefaultDispatchTable(void)
    {
        return RpcInterfaceInformation.DispatchTable;
    }

    void GetSelectedTransferSyntaxAndDispatchTable(IN int SelectedTransferSyntaxIndex,
        OUT RPC_SYNTAX_IDENTIFIER **SelectedTransferSyntax,
        OUT PRPC_DISPATCH_TABLE *SelectedDispatchTable);

#if DBG
    inline void
    InterfaceDoesNotUseStrict (
        void
        )
    {
        // it can go from No to No and from DontKnow to No,
        // but not from Yes to No
        ASSERT(Strict != iuschYes);

        if (Strict != iuschNo)
            Strict = iuschNo;
    }

    inline BOOL 
    DoesInterfaceUseNonStrict (
        void
        )
    {
        // in this interface using non-strict?
        return (Strict == iuschNo);
    }
#endif

private:
    inline BOOL AreMultipleTransferSyntaxesSupported(void)
    {
        return NumberOfSupportedTransferSyntaxes;
    }
};

inline
RPC_INTERFACE::~RPC_INTERFACE (
    )
{
#if !defined(NO_LOCATOR_CODE)
    NS_ENTRY *NsEntry;
#endif
    unsigned int Length;
    DictionaryCursor cursor;

    if (fBindingsExported)
        {
        RpcpFarFree(UuidVector);
        }

#if !defined(NO_LOCATOR_CODE)
    NsEntries.Reset(cursor);
    while (NsEntry = NsEntries.Next(cursor))
        {
        delete NsEntry;
        }
#endif
}

// check if the interface has methods that use pipes
inline int
RPC_INTERFACE::IsPipeInterface (
    )
{
    return (PipeInterfaceFlag) ;
}

inline int
RPC_INTERFACE::IsSecurityCallbackReqd(
       )
{
    if (CallbackFn)
        {
        return TRUE;
        }

    return FALSE;
}

inline int
RPC_INTERFACE::IsSecure(
       )
{
    if (CallbackFn || Flags & RPC_IF_ALLOW_SECURE_ONLY)
        {
        return TRUE;
        }

    return FALSE;
}

inline int
RPC_INTERFACE::IsOle(
       )
{
    if (Flags & RPC_IF_OLE)
        {
        return TRUE;
        }

    return FALSE;
}

inline void
RPC_INTERFACE::BeginAutoListenCall (
    BOOL fIncCallNumber = FALSE
    )
{
    int Number, Count;

    if (fIncCallNumber)
        {
        Number = AutoListenCallNumber.Increment();
        }

    Count = AutoListenCallCount.Increment() ;

    LogEvent(SU_HANDLE, EV_INC, this, UlongToPtr(Number), Count, 1);
}

inline void
RPC_INTERFACE::EndAutoListenCall (
    BOOL fDecCallNumber = FALSE
    )
{
    int Number, Count;

    if (fDecCallNumber)
        {
        ASSERT(AutoListenCallNumber.GetInteger() >= 1);
        Number = AutoListenCallNumber.Decrement();
        }

    ASSERT(AutoListenCallCount.GetInteger() >= 1);
    Count = AutoListenCallCount.Decrement() ;

    // As soon as we decrement AutoListenCallCount the interface may be unregistered and
    // freed since the count may drop to 0.  Don't touch the object after this point.

    LogEvent(SU_HANDLE, EV_DEC, this, UlongToPtr(Number), Count, 1);
}

inline long
RPC_INTERFACE::InqAutoListenCallCount (
    )
{
    return AutoListenCallCount.GetInteger() ;
}

inline RPC_SERVER_INTERFACE *
RPC_INTERFACE::InqInterfaceInformation (
    )
{
    return &RpcInterfaceInformation;
}

inline int
RPC_INTERFACE::IsAutoListenInterface (
    )
{
    return (Flags & RPC_IF_AUTOLISTEN) ;
}


inline BOOL
RPC_INTERFACE::IsUnknownAuthorityAllowed()
{
    return ((Flags & RPC_IF_ALLOW_UNKNOWN_AUTHORITY) != 0);
}

inline BOOL
RPC_INTERFACE::IsAllowingUnsecureCallbacks()
{
    return ((Flags & RPC_IF_ALLOW_CALLBACKS_WITH_NO_AUTH) != 0);
}


inline int
RPC_INTERFACE::MatchRpcInterfaceInformation (
    IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation
    )
/*++

Routine Description:

    This method compares the supplied rpc interface information against
    that contained in this rpc interface.

Arguments:

    RpcInterfaceInformation - Supplies the rpc interface information.

Return Value:

    Zero will be returned if the supplied rpc interface information
    (interface and transfer syntaxes) is the same as in this rpc interface;
    otherwise, non-zero will be returned.

--*/
{
    return(RpcpMemoryCompare(&(this->RpcInterfaceInformation),
            RpcInterfaceInformation, sizeof(RPC_SYNTAX_IDENTIFIER) * 2));
}

inline BOOL
RPC_INTERFACE::NeedToUpdateBindings(
    void
    )
/*++
Function Name:NeedToUpdateBindings

Parameters:

Description:
    Returns TRUE if this interface has been exported to the epmapper
    or the name service. In this case, we need to update the
    bindings via UpdateBindings

Returns:
    TRUE - the bindings need updating
    FALSE - the bindings don't need updating
--*/
{
#if defined(NO_LOCATOR_CODE)
    return (fBindingsExported);
#else
    return (fBindingsExported || (NsEntries.Size() > 0));
#endif
}

extern RPC_INTERFACE *GlobalManagementInterface;


class RPC_ADDRESS : public GENERIC_OBJECT
/*++

Class Description:

    This class represents an address (or protocol sequence in the DCE
    lingo).  An address is responsible for receiving calls, dispatching
    them to an interface, and then returning the reply.

Fields:

    StaticEndpointFlag - This field specifies whether this address has
        a static endpoint or a dynamic endpoint.  This information is
        necessary so that when we create a binding handle from this
        address we know whether or not to specify an endpoint.  See
        the InquireBinding method of this class.  A value of zero
        indicates a dynamic endpoint, and a value of non-zero indicates
        a static endpoint.

--*/
{
protected:
    TRANS_INFO *TransInfo;
private:
    RPC_CHAR PAPI * Endpoint;
    RPC_CHAR PAPI * RpcProtocolSequence;
    RPC_CHAR PAPI * NetworkAddress;
    unsigned int StaticEndpointFlag;

protected:
    int ActiveCallCount;
    unsigned int PendingQueueSize;
    void PAPI *SecurityDescriptor;
    unsigned long NICFlags;
    unsigned long EndpointFlags;

    RPC_ADDRESS (
        IN OUT RPC_STATUS PAPI * RpcStatus
        );

public:

    RPC_SERVER * Server;
    MUTEX AddressMutex;
    int DictKey;

    virtual ~RPC_ADDRESS (
        );

    virtual  RPC_STATUS
    ServerSetupAddress (
        IN RPC_CHAR PAPI * NetworkAddress,
        IN RPC_CHAR PAPI * PAPI *Endpoint,
        IN unsigned int PendingQueueSize,
        IN void PAPI * SecurityDescriptor, OPTIONAL
        IN unsigned long EndpointFlags,
        IN unsigned long NICFlags
        ) = 0;

    virtual void
    PnpNotify (
        ) {};

    virtual void
    EncourageCallCleanup(
        RPC_INTERFACE * Interface
        );

    RPC_CHAR *
    GetListNetworkAddress (IN unsigned int Index
                          );

    unsigned int
    InqNumNetworkAddress();

    RPC_STATUS
    SetEndpointAndStuff (
        IN RPC_CHAR PAPI * NetworkAddress,
        IN RPC_CHAR PAPI * Endpoint,
        IN RPC_CHAR PAPI * RpcProtocolSequence,
        IN RPC_SERVER * Server,
        IN unsigned int StaticEndpointFlag,
        IN unsigned int PendingQueueSize,
        IN void PAPI *SecurityDescriptor,
        IN unsigned long EndpointFlags,
        IN unsigned long NICFlags
        );

    RPC_STATUS
    FindInterfaceTransfer (
        IN PRPC_SYNTAX_IDENTIFIER InterfaceIdentifier,
        IN PRPC_SYNTAX_IDENTIFIER ProposedTransferSyntaxes,
        IN unsigned int NumberOfTransferSyntaxes,
        OUT PRPC_SYNTAX_IDENTIFIER AcceptedTransferSyntax,
        OUT RPC_INTERFACE ** RpcInterface,
        OUT BOOL *fIsInterfaceTransferPreferred,
        OUT int *ProposedTransferSyntaxIndex,
        OUT int *AvailableTransferSyntaxIndex
        );

    virtual RPC_STATUS
    CompleteListen (
        ) ;

    BINDING_HANDLE *
    InquireBinding (RPC_CHAR * LocalNetworkAddress = 0
        );

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

    virtual void
    ServerStoppedListening (
        );

    int
    SameEndpointAndProtocolSequence (
        IN RPC_CHAR PAPI * NetworkAddress,
        IN RPC_CHAR PAPI * RpcProtocolSequence,
        IN RPC_CHAR PAPI * Endpoint
        );

    RPC_STATUS
    SameProtocolSequenceAndSD (
        IN RPC_CHAR PAPI * NetworkAddress,
        IN RPC_CHAR PAPI * RpcProtocolSequence,
        IN SECURITY_DESCRIPTOR *SecurityDescriptor OPTIONAL,
        OUT BOOL *IsEqual
        );

    virtual long
    InqNumberOfActiveCalls (
        );

    RPC_CHAR *
    InqEndpoint (
        )
    {
    return(Endpoint);
    }

    RPC_CHAR *
    InqRpcProtocolSequence (
        );

    virtual void
    WaitForCalls(
        ) ;

    RPC_STATUS
    RestartAddress (
        IN unsigned int MinThreads,
        IN unsigned int MaxCalls
        );

    RPC_STATUS
    CopyDescriptor (
       IN void *SecurityDescriptor,
       OUT void **OutDescriptor
       );

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

    virtual void
    CleanupIdleSContexts (
        void
        );

    virtual NETWORK_ADDRESS_VECTOR *
    GetNetworkAddressVector (
        void
        );
};


inline void
RPC_ADDRESS::EncourageCallCleanup(
    RPC_INTERFACE * Interface
    )
{
}

inline void
RPC_ADDRESS::WaitForCalls(
    )
{
}

inline RPC_STATUS
RPC_ADDRESS::CompleteListen (
    )
{
    return RPC_S_OK ;
}


inline int
RPC_ADDRESS::SameEndpointAndProtocolSequence (
    IN RPC_CHAR PAPI * NetworkAddress,
    IN RPC_CHAR PAPI * ProtocolSequence,
    IN RPC_CHAR PAPI * Endpoint
    )
/*++

Routine Description:

    This routine is used to determine if the rpc address has the same
    endpoint and protocol sequence as the endpoint and protocol sequence
    supplied as arguments.

Arguments:

    ProtocolSequence - Supplies the protocol sequence to compare against
        the protocol sequence of this address.

    Endpoint - Supplies the endpoint to compare against the endpoint in this
        address.

Return Value:

    Non-zero will be returned if this address and the supplied endpoint and
    protocol sequence are the same, otherwise, zero will be returned.

--*/
{
    if (NetworkAddress == NULL && this->NetworkAddress == NULL)
        {
        return(( RpcpStringCompare(this->Endpoint, Endpoint) == 0 )
                 && ( RpcpStringCompare(this->RpcProtocolSequence,
                             ProtocolSequence) == 0 ));
        }
    else if (NetworkAddress == NULL || this->NetworkAddress == NULL)
        {
        return 0;
        }
        
    return(( RpcpStringCompare(this->Endpoint, Endpoint) == 0 )
            && ( RpcpStringCompare(this->RpcProtocolSequence, ProtocolSequence) == 0 )
            && ( RpcpStringCompare(this->NetworkAddress, NetworkAddress) == 0 ));
}


inline RPC_CHAR *
RPC_ADDRESS::InqRpcProtocolSequence (
    )
{
    return(RpcProtocolSequence);
}

inline unsigned int
RPC_ADDRESS::InqNumNetworkAddress (
    )
{
    return(GetNetworkAddressVector()->Count);
}


NEW_SDICT(RPC_INTERFACE);

NEW_SDICT(RPC_ADDRESS);

class RPC_AUTHENTICATION
{
public:

    RPC_CHAR __RPC_FAR * ServerPrincipalName;
    unsigned long AuthenticationService;
    RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFunction;
    void __RPC_FAR * Argument;
};

NEW_SDICT(RPC_AUTHENTICATION);


class TIMER
{
private:
    HANDLE hThread;

public:
    TIMER(RPC_STATUS *Status, int fManualReset)
    {
        hThread = 0;
        *Status = RPC_S_OK;

        ASSERT(fManualReset == 0);
    }

    BOOL Wait(
         IN DWORD Milliseconds
        )
    {
        NTSTATUS NtStatus;
        LARGE_INTEGER Timeout;
        Timeout.QuadPart = Int32x32To64(Milliseconds, -10000);

        rewait:
            {
            NtStatus = NtDelayExecution(TRUE, &Timeout);

            if (NtStatus == STATUS_USER_APC)
                goto rewait;
            }

        if (NtStatus == STATUS_ALERTED)
            {
            return 0;
            }

        return 1;
    }

    void Raise()
    {
        NTSTATUS NtStatus;

        ASSERT(hThread);

        NtStatus = NtAlertThread(hThread);

        ASSERT(NT_SUCCESS(NtStatus));
    }

    void SetThread(THREAD *pThread)
    {
        hThread = pThread->ThreadHandle();

        ASSERT(hThread);
    }
};

typedef enum CachedThreadWorkAvailableTag
{
    WorkIsNotAvailable = 0,
    WorkIsAvailable
} CachedThreadWorkAvailable;


class CACHED_THREAD
/*++

Class Description:

    This class is used to implement a thread cache.  Each thread which
    has been cached is represented by an object of this class.  All of the
    fields of this class are protected by the server mutex of the owning
    rpc server.

Fields:

    Next - Forward link pointer of cached thread list.

    Previous - Backward link pointer of cached thread list.

    Procedure - The procedure which the thread should execute will be
        placed here before the event gets kicked.

    Parameter - The parameter which the thread should pass to the procedure
        will be placed here.

    OwningRpcServer - Contains a pointer to the rpc server which owns this
        cached thread.  This is necessary so that we can put this cached
        thread into the cache.

    WaitForWorkEvent - Contains the event which this cached thread will
        wait on for more work to do.

    WorkAvailableFlag - A non-zero value of this flag indicates that there
        is work available for this thread.  This is necessary to close a
        race condition between the thread timing out waiting for work, and
        the server requesting this thread to do work.

--*/
{
    friend class RPC_SERVER;

    friend void
    BaseCachedThreadRoutine (
        IN CACHED_THREAD * CachedThread
        );

private:

    CACHED_THREAD * Next;
    CACHED_THREAD * Previous;
    THREAD_PROC Procedure;
    PVOID Parameter;
    RPC_SERVER * OwningRpcServer;
    CachedThreadWorkAvailable WorkAvailableFlag;
    TIMER WaitForWorkEvent;

public:

    CACHED_THREAD (
        IN THREAD_PROC Procedure,
        IN void * Parameter,
        IN RPC_SERVER * RpcServer,
        IN RPC_STATUS * RpcStatus
        ) : WaitForWorkEvent(RpcStatus, 0),
            Procedure(Procedure),
            Parameter(Parameter),
            OwningRpcServer(RpcServer),
            WorkAvailableFlag(WorkIsNotAvailable),
            Next(0),
            Previous(0)
        {
        }

    BOOL
    CallProcedure (
        )
        {
        // by convention, IOCP worker threads will return non-zero,
        // while LRPC worker threads will return 0.
        return((*Procedure)(Parameter));
        }

    void SetThread(THREAD *p)
        {
        WaitForWorkEvent.SetThread(p);
        }

    void SetWakeUpThreadParams(THREAD_PROC Procedure, PVOID Parameter)
    {
        this->Procedure = Procedure;
        this->Parameter = Parameter;
        WorkAvailableFlag = WorkIsAvailable;
    }

    void WakeUpThread(void)
    {
        WaitForWorkEvent.Raise();
    }

    inline void *GetParameter(void)
    {
        return Parameter;
    }
};

typedef (*NS_EXPORT_FUNC) (
                IN unsigned long EntryNameSyntax,
                IN RPC_CHAR *EntryName,
                IN RPC_IF_HANDLE RpcInterfaceInformation,
                IN RPC_BINDING_VECTOR * BindingVector,
                IN UUID_VECTOR *UuidVector
                );

typedef (*NS_UNEXPORT_FUNC) (
                IN unsigned long EntryNameSyntax,
                IN RPC_CHAR *EntryName,
                IN RPC_IF_HANDLE RpcInterfaceInformation,
                IN UUID_VECTOR *UuidVector
                );



class RPC_SERVER
/*++

Class Description:

    This class represents an RPC server.  Interfaces and addresses get
    hung from an rpc server object.

Fields:

    RpcInterfaceDictionary - Contains a dictionary of rpc interfaces
        which have been registered with this server.

    ServerMutex - Contains a mutex used to serialize access to this
        data structure.

    AvailableCallCount - Contains a count of the number of available calls
        on all rpc interfaces owned by this server.

    ServerListeningFlag - Contains an indication of whether or not
        this rpc server is listening for remote procedure calls.  If
        this flag is zero, the server is not listening; otherwise, if
        the flag is non-zero, the server is listening.

    RpcAddressDictionary - Contains a dictionary of rpc addresses which
        have been registered with this server.

    ListeningThreadFlag - Contains a flag which indicates whether or
        not there is a thread in the ServerListen method.  The
        ServerListeningFlag can not be used because it will be zero
        will the listening thread is waiting for all active calls to
        complete.

    StopListeningEvent - Contains an event which the thread which called
        ServerListen will wait on.  When StopServerListening is called,
        this event will get kicked.  If a non-recoverable error occurs,
        the event will also get kicked.

    ListenStatusCode - Contains the status code which ServerListen will
        return.

    MaximumConcurrentCalls - Contains the maximum number of concurrent
        remote procedure calls allowed for this rpc server.

    MinimumCallThreads - Contains the minimum number of call threads
        which should be available to service remote procedure calls on
        each protocol sequence.

    IncomingRpcCount - This field keeps track of the number of incoming
        remote procedure calls (or callbacks) which this server has
        received.

    OutgoingRpcCount - This field keeps track of the number of outgoing
        remote procedure callbacks initiated by this server.

    ReceivedPacketCount - Contains the number of network packets received
        by this server.

    SentPacketCount - Contains the number of network packets sent by this
        server.

    AuthenticationDictionary - Contains the set of authentication services
        supported by this server.

    WaitingThreadFlag - Contains a flag indicating whether or not there
        is a thread waiting for StopServerListening to be called and then
        for all calls to complete.

    ThreadCache - This field points to the top of the stack of CACHED_THREAD
        objects which forms the thread cache.  This field is protected by the
        thread cache mutex rather than the server mutex.

    ThreadCacheMutex - This field is used to serialize access to the thread
        cache.  We need to do this to prevent deadlocks between the server
        mutex and an address mutex.

    pEpmapperForwardFunction - Function to determine if and where a
        packet is to be forwarded to.

--*/
{
    friend void
    BaseCachedThreadRoutine (
        IN CACHED_THREAD * CachedThread
        );

public:
    // accessed by all threads independently - put in separate cache line
    MUTEX ServerMutex;

private:
#if !defined(NO_LOCATOR_CODE)
    NS_EXPORT_FUNC pNsBindingExport;
#endif
    RPC_STATUS ListenStatusCode;
    unsigned int ListeningThreadFlag;
public:
    unsigned int MinimumCallThreads;
private:
    unsigned int WaitingThreadFlag;
    unsigned long OutgoingRpcCount;
    long padding0;
    // accessed by all threads independently - put in separate cache line
    unsigned long IncomingRpcCount;
    RPC_ADDRESS_DICT RpcAddressDictionary;
    // accessed by all threads independently - put in separate cache line
    INTERLOCKED_INTEGER AvailableCallCount;
    QUEUE RpcDormantAddresses;
    // accessed by all threads independently - put in separate cache line
    unsigned long SentPacketCount;
    CACHED_THREAD *ThreadCache;
    MUTEX ThreadCacheMutex;
    // accessed by all threads independently - put in separate cache line
    unsigned int MaximumConcurrentCalls;
    EVENT StopListeningEvent;
    INTERLOCKED_INTEGER NumAutoListenInterfaces ;
#if !defined(NO_LOCATOR_CODE)
    NS_UNEXPORT_FUNC pNsBindingUnexport;
#endif
    long padding1[4];
    // accessed by all threads independently - put in separate cache line
    RPC_INTERFACE_DICT RpcInterfaceDictionary;
public:
    // accessed by all threads independently - put in separate cache line
    unsigned int ServerListeningFlag;
    BOOL fAccountForMaxCalls;
    long padding2[6];
    // accessed by all threads independently - put in separate cache line
    unsigned long ReceivedPacketCount;
public:
    RPC_FORWARD_FUNCTION *    pRpcForwardFunction;
private:
    long padding3[6];
    // accessed by all threads independently - put in separate cache line
    RPC_AUTHENTICATION_DICT AuthenticationDictionary;
public:

    RPC_SERVER (
        IN OUT RPC_STATUS PAPI * RpcStatus
        );

    RPC_INTERFACE *
    FindInterface (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation
        );

    int
    AddInterface (
        IN RPC_INTERFACE * RpcInterface
        );

    unsigned int
    IsServerListening (
        );

    long InqNumAutoListenInterfaces (
        ) ;

    unsigned int
    CallBeginning (
        );

    void
    CallEnding (
        );

    RPC_STATUS
    FindInterfaceTransfer (
        IN PRPC_SYNTAX_IDENTIFIER InterfaceIdentifier,
        IN PRPC_SYNTAX_IDENTIFIER ProposedTransferSyntaxes,
        IN unsigned int NumberOfTransferSyntaxes,
        OUT PRPC_SYNTAX_IDENTIFIER AcceptedTransferSyntax,
        OUT RPC_INTERFACE ** RpcInterface,
        OUT BOOL *fInterfaceTransferIsPreferred,
        OUT int *ProposedTransferSyntaxIndex,
        OUT int *AvailableTransferSyntaxIndex
        );

    RPC_INTERFACE *
    FindInterface (
        IN PRPC_SYNTAX_IDENTIFIER InterfaceIdentifier
        );

    RPC_STATUS
    ServerListen (
        IN unsigned int MinimumCallThreads,
        IN unsigned int MaximumConcurrentCalls,
        IN unsigned int DontWait
        );

    RPC_STATUS
    WaitForStopServerListening (
        );

    RPC_STATUS
    WaitServerListen (
        );

    void
    InquireStatistics (
        OUT RPC_STATS_VECTOR * Statistics
        );

    RPC_STATUS
    StopServerListening (
        );

    RPC_STATUS
    UseRpcProtocolSequence (
        IN RPC_CHAR PAPI * NetworkAddress,
        IN RPC_CHAR PAPI * RpcProtocolSequence,
        IN unsigned int PendingQueueSize,
        IN RPC_CHAR PAPI *Endpoint,
        IN void PAPI * SecurityDescriptor,
        IN unsigned long EndpointFlags,
        IN unsigned long NICFlags,
        IN RPC_CHAR PAPI **pEndpointListenedOn = NULL, OPTIONAL
        IN BOOL fUseDuplicateEndpoints = FALSE OPTIONAL
        );

    RPC_STATUS
    UnregisterEndpoint (
        IN RPC_CHAR __RPC_FAR * RpcProtocolSequence,
        IN RPC_CHAR __RPC_FAR * Endpoint
        );

    int
    AddAddress (
        IN RPC_ADDRESS * RpcAddress
        );

    RPC_STATUS
    UnregisterIf (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN RPC_UUID PAPI * ManagerTypeUuid OPTIONAL,
        IN unsigned int WaitForCallsToComplete
        );

    RPC_STATUS
    InquireManagerEpv (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN RPC_UUID PAPI * ManagerTypeUuid, OPTIONAL
        OUT RPC_MGR_EPV PAPI * PAPI * ManagerEpv
        );

    RPC_STATUS
    InquireBindings (
        OUT RPC_BINDING_VECTOR PAPI * PAPI * BindingVector
        );

    RPC_STATUS
    AutoRegisterAuthSvc(
        IN RPC_CHAR * ServerPrincipalName,
        IN unsigned long AuthenticationService
        );

    RPC_STATUS
    RegisterAuthInfoHelper (
        IN RPC_CHAR PAPI * ServerPrincipalName,
        IN unsigned long AuthenticationService,
        IN RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFunction, OPTIONAL
        IN void PAPI * Argument OPTIONAL
        );

    RPC_STATUS
    RegisterAuthInformation (
        IN RPC_CHAR PAPI * ServerPrincipalName,
        IN unsigned long AuthenticationService,
        IN RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFunction, OPTIONAL
        IN void PAPI * Argument OPTIONAL
        );

    RPC_STATUS
    AcquireCredentials (
        IN unsigned long AuthenticationService,
        IN unsigned long AuthenticationLevel,
        OUT SECURITY_CREDENTIALS ** SecurityCredentials
        );

    void
    FreeCredentials (
        IN SECURITY_CREDENTIALS * SecurityCredentials
        );

    RPC_STATUS
    RegisterInterface (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN RPC_UUID PAPI * ManagerTypeUuid,
        IN RPC_MGR_EPV PAPI * ManagerEpv,
        IN unsigned int Flags,
        IN unsigned int MaxCalls,
        IN unsigned int MaxRpcSize,
        IN RPC_IF_CALLBACK_FN PAPI *IfCallbackFn
        );

    void IncomingCall(void);
    void OutgoingCallback(void);
    void PacketReceived(void);
    void PacketSent(void);

    RPC_STATUS
    CreateThread (
        IN THREAD_PROC Procedure,
        IN void * Parameter);

    RPC_STATUS
    InquireInterfaceIds (
        OUT RPC_IF_ID_VECTOR __RPC_FAR * __RPC_FAR * InterfaceIdVector
        );

    RPC_STATUS
    InquirePrincipalName (
        IN unsigned long AuthenticationService,
        OUT RPC_CHAR __RPC_FAR * __RPC_FAR * ServerPrincipalName
        );

    unsigned int
    InquireInterfaceCount (
        );

    void
    RegisterRpcForwardFunction(
        RPC_FORWARD_FUNCTION * pForwardFunction
        );

    void
    IncrementAutoListenInterfaceCount (
        ) ;

    void
    DecrementAutoListenInterfaceCount (
        ) ;

    void
    InsertIntoFreeList(
        CACHED_THREAD *CachedThread
        );

    void
    RemoveFromFreeList(
        CACHED_THREAD *CachedThread
        );

    CACHED_THREAD *RemoveHeadFromFreeList(void);

    void CreateOrUpdateAddresses (void);

    RPC_INTERFACE *
    FindOrCreateInterface (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        OUT RPC_STATUS *Status
        );

    RPC_STATUS
    InterfaceExported (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN UUID_VECTOR *MyObjectUuidVector,
        IN unsigned char *MyAnnotation,
        IN BOOL MyfReplace
        );

#if !defined(NO_LOCATOR_CODE)
    RPC_STATUS
    NsInterfaceExported (
        IN unsigned long EntryNameSyntax,
        IN RPC_CHAR *EntryName,
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN BOOL fUnexport
        );

    RPC_STATUS
    NsBindingUnexport (
        IN unsigned long EntryNameSyntax,
        IN RPC_CHAR *EntryName,
        IN RPC_IF_HANDLE IfSpec
        );

    RPC_STATUS
    NsBindingExport(
        IN unsigned long EntryNameSyntax,
        IN RPC_CHAR *EntryName,
        IN RPC_IF_HANDLE IfSpec,
        IN RPC_BINDING_VECTOR *BindingVector
        );
#endif

    typedef enum
    {
        actDestroyContextHandle = 0,
        actCleanupIdleSContext
    } AddressCallbackType;

    RPC_STATUS
    EnumerateAndCallEachAddress (
        IN AddressCallbackType actType,
        IN OUT void *Context OPTIONAL
        );

private:
    RPC_INTERFACE *
    RPC_SERVER::FindOrCreateInterfaceInternal (
        IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
        IN unsigned int Flags,
        IN unsigned int MaxCalls,
        IN unsigned int MaxRpcSize,
        IN RPC_IF_CALLBACK_FN PAPI *IfCallbackFn,
        OUT RPC_STATUS *Status,
        OUT BOOL *fInterfaceFound
        );
};

#if !defined(NO_LOCATOR_CODE)
inline RPC_STATUS
RPC_SERVER::NsBindingUnexport (
    IN unsigned long EntryNameSyntax,
    IN RPC_CHAR *EntryName,
    IN RPC_IF_HANDLE IfSpec
    )
{
     return (*pNsBindingUnexport)
            (EntryNameSyntax, EntryName, IfSpec, NULL);
}

inline RPC_STATUS
RPC_SERVER::NsBindingExport (
    IN unsigned long EntryNameSyntax,
    IN RPC_CHAR *EntryName,
    IN RPC_IF_HANDLE IfSpec,
    IN RPC_BINDING_VECTOR *BindingVector
    )
{
     return (*pNsBindingExport)
            (EntryNameSyntax, EntryName, IfSpec, BindingVector, NULL);
}
#endif

inline void
RPC_SERVER::IncrementAutoListenInterfaceCount (
    )
{
    NumAutoListenInterfaces.Increment() ;
}

inline void
RPC_SERVER::DecrementAutoListenInterfaceCount (
    )
{
    NumAutoListenInterfaces.Decrement() ;
}

inline long
RPC_SERVER::InqNumAutoListenInterfaces (
    )
{
    return (NumAutoListenInterfaces.GetInteger()) ;
}


inline unsigned int
RPC_SERVER::InquireInterfaceCount (
    )
{
    return RpcInterfaceDictionary.Size();
}


inline unsigned int
RPC_SERVER::IsServerListening (
    )
/*++

Routine Description:

    This method returns an indication of whether or not this rpc server
    is listening for remote procedure calls.

Return Value:

    Zero will be returned if this rpc server is not listening for
    remote procedure calls; otherwise, non-zero will be returned.

--*/
{
    return(ServerListeningFlag);
}


inline unsigned int
RPC_SERVER::CallBeginning (
    )
/*++

Routine Description:

    Before dispatching a new remote procedure call to a stub, this method
    will get called.  It checks to see if this call will cause there to
    be too many concurrent remote procedure calls.  If the call is allowed
    the call count is updated so we can tell when all calls have
    completed.

    Zero will be returned if another concurrent remote procedure call
    is not allowed; otherwise, non-zero will be returned.
--*/
{
    if (AvailableCallCount.Decrement() >= 0)
        return TRUE;
    else
        {
        AvailableCallCount.Increment();
        return FALSE;
        }
}


inline void
RPC_SERVER::CallEnding (
    )
/*++

Routine Description:

    This method is the mirror image of RPC_SERVER::CallBeginning; it
    is used to notify this rpc server that a call using an rpc
    interface owned by this rpc server is ending.

--*/
{
    long Temp;

    Temp = AvailableCallCount.Increment();
    ASSERT(Temp <= (long)MaximumConcurrentCalls);
}


inline void RPC_SERVER::IncomingCall (void)
/*++

Routine Description:

    RPC_INTERFACE::DispatchToStub calls this method so that the server
    can keep track of the number of incoming remote procedure calls (and
    callbacks).

--*/
{
    IncomingRpcCount += 1;
}


inline void RPC_SERVER::OutgoingCallback (void)
/*++

Routine Description:

    Each protocol module must call this method when it sends a callback
    from the server to the client; we need to do this so that the server
    can keep track of the number of outgoing remote procedure callbacks.

--*/
{
    OutgoingRpcCount += 1;
}


inline void RPC_SERVER::PacketReceived (void)
/*++

Routine Description:

    In order for the server to keep track of the number of incoming
    packets, each protocol module must call this method each time a
    packet is received from the network.

--*/
{
    ReceivedPacketCount += 1;
}


inline void RPC_SERVER::PacketSent (void)
/*++

Routine Description:

    This method is the same as RPC_SERVER::PacketReceived, except that
    it should be called for each packet sent rather than received.

--*/
{
    SentPacketCount += 1;
}

inline CACHED_THREAD *RPC_SERVER::RemoveHeadFromFreeList(void)
/*++

Routine Description:

    Removes a cached thread object for the ThreadCache list.

    Note: ThreadCachedMutex() should be held when called.

--*/
{
    CACHED_THREAD *pFirst = ThreadCache;

#if DBG
    ThreadCacheMutex.VerifyOwned();
#endif

    if (pFirst)
        {
        ThreadCache = pFirst->Next;
        if (ThreadCache)
            ThreadCache->Previous = NULL;
        }
    return pFirst;
}


inline void
RPC_SERVER::RemoveFromFreeList(
    IN CACHED_THREAD *CachedThread)
/*++

Routine Description:

    Removes a cached thread object for the ThreadCache list.

    Note: ThreadCachedMutex() should be held when called.

--*/
{
    if (CachedThread->Previous)
        {
        ASSERT(CachedThread->Previous->Next == CachedThread);
        CachedThread->Previous->Next = CachedThread->Next;
        }

    if (CachedThread->Next)
        {
        ASSERT(CachedThread->Next->Previous == CachedThread);
        CachedThread->Next->Previous = CachedThread->Previous;
        }

    if (ThreadCache == CachedThread)
        {
        ASSERT(CachedThread->Previous == NULL);
        ASSERT(   (CachedThread->Next == 0)
               || (CachedThread->Next->Previous == NULL));

        ThreadCache = CachedThread->Next;
        }
}


inline void
RPC_SERVER::InsertIntoFreeList(
    IN CACHED_THREAD *CachedThread
    )
/*++

Routine Description:

    Inserts a cached thread object into ThreadCache list.

    Note: ThreadCachedMutex() should be held when called.

--*/
{
    CachedThread->Next = ThreadCache;
    if (ThreadCache)
        {
        ASSERT(ThreadCache->Previous == 0);
        ThreadCache->Previous = CachedThread;
        }
    CachedThread->Previous = 0;
    ThreadCache = CachedThread;
}

NEW_SDICT(ServerContextHandle);


class NO_VTABLE SCALL : public CALL
/*++

Class Description:
--*/
{
public:
    inline
    SCALL (
        IN CLIENT_AUTH_INFO * myAuthInfo,
        OUT RPC_STATUS * pStatus
        )
    {
    }

    inline SCALL (
        void
        )
    {
        IsMultiContextHandleCall = FALSE;
    }

    inline
    ~SCALL (
        )
    {
    }

    virtual RPC_STATUS
    NegotiateTransferSyntax (
        IN OUT PRPC_MESSAGE Message
        )
    {
        // we shouldn't be here at all
        ASSERT(!"Negotiating a transfer syntax is not supported on the server side");
        return RPC_S_CANNOT_SUPPORT;
    }
    
    RPC_STATUS
    AddToActiveContextHandles (
        IN ServerContextHandle *ContextHandle
        );

    ServerContextHandle *
    RemoveFromActiveContextHandles (
        IN ServerContextHandle *ContextHandle
        );

    void
    DoPreDispatchProcessing (
        IN PRPC_MESSAGE Message,
        IN BOOL CallbackFlag
        ) ;

    void
    DoPostDispatchProcessing (
        void
        ) ;


    virtual void
    InquireObjectUuid (
        OUT RPC_UUID PAPI * ObjectUuid
        ) = 0;

    virtual RPC_STATUS
    InquireAuthClient (
        OUT RPC_AUTHZ_HANDLE PAPI * Privileges,
        OUT RPC_CHAR PAPI * PAPI * ServerPrincipalName, OPTIONAL
        OUT unsigned long PAPI * AuthenticationLevel,
        OUT unsigned long PAPI * AuthenticationService,
        OUT unsigned long PAPI * AuthorizationService,
        IN  unsigned long Flags
        ) = 0;

    virtual RPC_STATUS
    InquireCallAttributes (
        IN OUT void *
        )
    {
        return RPC_S_CANNOT_SUPPORT;
    }

    virtual RPC_STATUS // Value to be returned by RpcImpersonateClient.
    ImpersonateClient ( // Impersonate the client represented (at the other
        );// end of) by this connection.

    virtual RPC_STATUS // Value to be returned by RpcRevertToSelf.
    RevertToSelf ( // Stop impersonating a client, if the server thread
        );// is impersonating a client.

    virtual RPC_STATUS
    GetAssociationContextCollection (
        OUT ContextCollection **CtxCollection
        ) = 0;

    virtual RPC_STATUS
    ToStringBinding (
        OUT RPC_CHAR PAPI * PAPI * StringBinding
        ) = 0;

    virtual RPC_STATUS
    IsClientLocal (
        OUT unsigned int PAPI * ClientLocalFlag
        ) = 0;

    virtual void 
    IsClientDisconnected (
        OUT BOOL *ClientIsDisconnected
        ) = 0;

    virtual RPC_STATUS
    ConvertToServerBinding (
        OUT RPC_BINDING_HANDLE __RPC_FAR * ServerBinding
        ) = 0;

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

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

#if DBG
    virtual void
    InterfaceForCallDoesNotUseStrict (
        void
        )
    {
    }
#endif

    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
        )
    {
        // we shouldn't be here at all
        ASSERT(!"Get authz context should have landed in a derived class method");
        return RPC_S_CANNOT_SUPPORT;
    }

    virtual RPC_STATUS
    TurnOnOffKeepAlives (
        IN BOOL TurnOn,
        IN ULONG Timeout,
        IN ULONG Interval
        )
    {
        // we shouldn't be here at all
        ASSERT(!"TurnOnOffKeepAlives called in an unsupporting class.");
        return RPC_S_CANNOT_SUPPORT;
    }


protected:

    static RPC_STATUS
    CreateAndSaveAuthzContextFromToken (
        IN OUT PAUTHZ_CLIENT_CONTEXT_HANDLE pAuthzClientContextPlaceholder OPTIONAL,
        IN HANDLE ImpersonationToken,
        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
        );

    static RPC_STATUS
    DuplicateAuthzContext (
        IN AUTHZ_CLIENT_CONTEXT_HANDLE AuthzClientContext,
        IN PLARGE_INTEGER pExpirationTime OPTIONAL,
        IN LUID Identifier,
        IN DWORD Flags,
        IN PVOID DynamicGroupArgs OPTIONAL,
        OUT PAUTHZ_CLIENT_CONTEXT_HANDLE pAuthzClientContext
        );

    void __RPC_FAR * DispatchBuffer ;

    // This flag is set to indicate that this call
    // is using more than one [in] or [in,out] context
    // handles.  It is set when AddToActiveContextHandles is
    // called for the second handle in the call.
    BOOL IsMultiContextHandleCall;
        
public:
    static const int DictionaryEntryIsBuffer = 1;

    ServerContextHandle_DICT ActiveContextHandles;
};

inline void
SCALL::DoPreDispatchProcessing (
    IN PRPC_MESSAGE Message,
    IN BOOL CallbackFlag
    )
{
    if (CallbackFlag == 0)
        {
        ASSERT(ActiveContextHandles.Size() == 0);
        }

    DispatchBuffer = Message->Buffer ;
}


class NO_VTABLE SCONNECTION : public REFERENCED_OBJECT
/*++

Class Description:

    This class represents a call on the server side.  The name of the
    class, SCONNECTION, is slightly misleading; this is a historical
    artifact due to the connection oriented protocol module being
    implemented first.  We add some more methods to this class to
    be implemented by each protocol module.

--*/
{
public:
    inline
    SCONNECTION(
        )
        {
        }

    inline
    ~SCONNECTION(
        )
        {
        }

    virtual RPC_STATUS
    IsClientLocal (
        OUT unsigned int PAPI * ClientLocalFlag
        );

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



/* ====================================================================
ASSOCIATION_HANDLE :

An association represents a client.  We need to take care of the
rundown routines here as well as the association context and
association id.  This is all independent of RPC protocol and
transport (well except for datagrams).
====================================================================
*/

class NO_VTABLE ASSOCIATION_HANDLE : public REFERENCED_OBJECT
{
protected:

    unsigned long AssociationID;

    ASSOCIATION_HANDLE ( // Constructor.
        void
        );

public:

    ContextCollection *CtxCollection;

    virtual ~ASSOCIATION_HANDLE ( // Destructor.
        );

    // Returns the context handle collection for this association.
    RPC_STATUS 
    GetAssociationContextCollection (
        ContextCollection **CtxCollectionPlaceholder
        ) ;

    void 
    FireRundown (
        void
        );

    virtual RPC_STATUS 
    CreateThread (
        void
        );

    virtual void 
    RundownNotificationCompleted(
        void
        );

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

extern int
InitializeServerDLL ( // This routine will be called at DLL load time.
    );

extern int
InitializeRpcServer (
    );

extern void PAPI *
OsfServerMapRpcProtocolSequence (
    IN RPC_CHAR * RpcProtocolSequence,
    OUT RPC_STATUS PAPI * Status
     );

extern int
InitializeRpcProtocolLrpc (
    ) ;

extern RPC_ADDRESS *
LrpcCreateRpcAddress (
    ) ;

extern RPC_ADDRESS *
OsfCreateRpcAddress (
    IN TRANS_INFO PAPI * TransportInfo
    );

extern RPC_ADDRESS *
DgCreateRpcAddress (
    IN TRANS_INFO PAPI * TransportInfo
    );

RPC_STATUS
SetThreadSecurityContext(
    SECURITY_CONTEXT * Context
    );

SECURITY_CONTEXT *
QueryThreadSecurityContext(
    );

SECURITY_CONTEXT *
ClearThreadSecurityContext(
   );

typedef AUTHZAPI
BOOL
(WINAPI *AuthzInitializeContextFromTokenFnType)(
    IN DWORD Flags,
    IN HANDLE TokenHandle,
    IN AUTHZ_RESOURCE_MANAGER_HANDLE AuthzResourceManager,
    IN PLARGE_INTEGER pExpirationTime OPTIONAL,
    IN LUID Identifier,
    IN PVOID DynamicGroupArgs OPTIONAL,
    OUT PAUTHZ_CLIENT_CONTEXT_HANDLE pAuthzClientContext
    );

typedef AUTHZAPI
BOOL
(WINAPI *AuthzInitializeContextFromSidFnType)(
    IN  DWORD                         Flags,
    IN  PSID                          UserSid,
    IN  AUTHZ_RESOURCE_MANAGER_HANDLE hAuthzResourceManager,
    IN  PLARGE_INTEGER                pExpirationTime        OPTIONAL,
    IN  LUID                          Identifier,
    IN  PVOID                         DynamicGroupArgs       OPTIONAL,
    OUT PAUTHZ_CLIENT_CONTEXT_HANDLE  phAuthzClientContext
    );

typedef AUTHZAPI
BOOL
(WINAPI *AuthzInitializeContextFromAuthzContextFnType)(
    IN DWORD Flags OPTIONAL,
    IN AUTHZ_CLIENT_CONTEXT_HANDLE hAuthzClientContext,
    IN PLARGE_INTEGER pExpirationTime OPTIONAL,
    IN LUID Identifier OPTIONAL,
    IN PVOID DynamicGroupArgs OPTIONAL,
    OUT PAUTHZ_CLIENT_CONTEXT_HANDLE phNewAuthzClientContext
    );

typedef AUTHZAPI
BOOL
(WINAPI *AuthzFreeContextFnType)(
    IN OUT AUTHZ_CLIENT_CONTEXT_HANDLE AuthzClientContext
    );

extern AuthzInitializeContextFromTokenFnType AuthzInitializeContextFromTokenFn;
extern AuthzInitializeContextFromSidFnType AuthzInitializeContextFromSidFn;
extern AuthzInitializeContextFromAuthzContextFnType AuthzInitializeContextFromAuthzContextFn;
extern AuthzFreeContextFnType AuthzFreeContextFn;

#define MO(_Message) ((MESSAGE_OBJECT *) _Message->Handle)
#define SCALL(_Message) ((SCALL *) _Message->Handle)

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

typedef struct tagDestroyContextHandleCallbackContext
{
    RPC_SERVER_INTERFACE *RpcInterfaceInformation;
    BOOL RundownContextHandles;
} DestroyContextHandleCallbackContext;

#endif // __HNDLSVR_HXX__