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

5405 lines
144 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (C) Microsoft Corporation, 1990 - 1999
//
// File: hndlsvr.cxx
//
//--------------------------------------------------------------------------
/* --------------------------------------------------------------------
Microsoft OS/2 LAN Manager
Copyright(c) Microsoft Corp., 1990
-------------------------------------------------------------------- */
/* --------------------------------------------------------------------
File : hndlsvr.cxx
Description :
This file contains the implementations of the classes defined in hndlsvr.hxx.
These routines are independent of the actual RPC protocol / transport layer.
In addition, these routines are also independent of the specific operating
system in use.
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.
connieh 17-Feb-94 Created RPC_SERVER::RegisterRpcForwardFunction
Kamen Moutafov (KamenM) Dec 99 - Feb 2000 - Support for cell debugging stuff
-------------------------------------------------------------------- */
#include <precomp.hxx>
#include <queue.hxx>
#include <hndlsvr.hxx>
#include <svrbind.hxx>
#include <thrdctx.hxx>
#include <rpcobj.hxx>
#include <rpccfg.h>
#include <sdict2.hxx>
#include <dispatch.h>
#include <queue.hxx>
#include <lpcpack.hxx>
#include <lpcsvr.hxx>
extern LRPC_SERVER *GlobalLrpcServer ;
#include <ProtBind.hxx>
#include <osfpcket.hxx>
#include <bitset.hxx>
#include <osfclnt.hxx>
#include <secsvr.hxx>
#include <osfsvr.hxx>
#include <dgpkt.hxx>
#include <dgsvr.hxx>
RPC_STATUS RPC_ENTRY
DefaultCallbackFn (
IN RPC_IF_HANDLE InterfaceUuid,
IN void *Context
)
/*++
Function Name:DefaultCallbackFn
Parameters:
Description:
Returns:
RPC_S_OK: Access is allowed
other failures: Access is denied
--*/
{
RPC_CALL_ATTRIBUTES CallAttributes;
RPC_STATUS Status;
CallAttributes.Version = RPC_CALL_ATTRIBUTES_VERSION;
CallAttributes.Flags = 0;
Status = RpcServerInqCallAttributesW(Context,
&CallAttributes);
if (Status != RPC_S_OK)
return Status;
if ((CallAttributes.AuthenticationService == RPC_C_AUTHN_NONE)
|| (CallAttributes.AuthenticationLevel == RPC_C_AUTHN_LEVEL_NONE)
|| (CallAttributes.NullSession)
)
{
return RPC_S_ACCESS_DENIED;
}
return RPC_S_OK;
}
RPC_INTERFACE::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
) : NullManagerActiveCallCount(0), AutoListenCallCount(0)
/*++
Routine Description:
This method will get called to construct an instance of the
RPC_INTERFACE class. We have got to make a copy of the rpc interface
information supplied. The copy is necessary because we do not delete
interfaces when they are unregistered. We just mark them as being
inactive. In addition, we need to set the NullManagerFlag
to zero, since this is used as the flag indicating whether we have
got a manager for the NULL type UUID.
Arguments:
RpcInterfaceInformation - Supplies the rpc interface information
which describes this interface.
Server - Supplies the rpc server which owns this rpc interface.
--*/
{
ALLOCATE_THIS(RPC_INTERFACE);
unsigned int Length;
PipeInterfaceFlag = 0;
SequenceNumber = 1;
#if DBG
Strict = iuschDontKnow;
#endif
if (RpcInterfaceInformation->Length > sizeof(RPC_SERVER_INTERFACE) )
{
Length = sizeof(RPC_SERVER_INTERFACE);
}
else
{
Length = RpcInterfaceInformation->Length;
}
if ((RpcInterfaceInformation->Length > NT351_INTERFACE_SIZE)
&& (RpcInterfaceInformation->Flags & RPC_INTERFACE_HAS_PIPES))
{
PipeInterfaceFlag = 1;
}
RpcpMemoryCopy(&(this->RpcInterfaceInformation), RpcInterfaceInformation, Length);
NullManagerFlag = 0;
ManagerCount = 0;
this->Server = Server;
this->Flags = Flags ;
this->MaxCalls = MaxCalls ;
this->MaxRpcSize = MaxRpcSize;
fBindingsExported = 0;
UuidVector = NULL;
if (Flags & RPC_IF_ALLOW_SECURE_ONLY
&& IfCallbackFn == NULL)
{
this->CallbackFn = DefaultCallbackFn;
}
else
{
this->CallbackFn = IfCallbackFn ;
}
if (DoesInterfaceSupportMultipleTransferSyntaxes(RpcInterfaceInformation))
{
*Status = NdrServerGetSupportedSyntaxes(RpcInterfaceInformation,
&NumberOfSupportedTransferSyntaxes,
&TransferSyntaxesArray, &PreferredTransferSyntax);
if (*Status != RPC_S_OK)
return;
}
else
{
NumberOfSupportedTransferSyntaxes = 0;
}
*Status = RPC_S_OK;
}
RPC_STATUS
RPC_INTERFACE::RegisterTypeManager (
IN RPC_UUID PAPI * ManagerTypeUuid OPTIONAL,
IN RPC_MGR_EPV PAPI * ManagerEpv OPTIONAL
)
/*++
Routine Description:
This method is used to register a type manager with this interface.
If no type UUID is specified, or it is the NULL type UUID, we
stick the manager entry point vector right in this instance (assuming
that there is not already one), otherwise, we put it into the
dictionary of interface manager objects.
Arguments:
ManagerTypeUuid - Optionally supplies the type UUID for the manager
we want to register with this rpc interface. If no type UUID
is supplied then the NULL type UUID is assumed.
ManagerEpv - Supplies then entry point vector for this manager. This
vector is used to dispatch from the stub to the application
code.
Return Values:
RPC_S_OK - The type manager has been successfully added to this
rpc interface.
RPC_S_OUT_OF_MEMORY - Insufficient memory is availabe to add the
type manager to the rpc interface.
RPC_S_TYPE_ALREADY_REGISTERED - A manager entry point vector has
already been registered for the this interface under the
specified manager type UUID.
--*/
{
RPC_INTERFACE_MANAGER * InterfaceManager;
// First we need to check if the null UUID is being specified as
// the type UUID; either, explicit or implicit by not specifying
// a type UUID argument.
RequestGlobalMutex();
if ( (ARGUMENT_PRESENT(ManagerTypeUuid) == 0)
|| ( (ARGUMENT_PRESENT(ManagerTypeUuid) != 0)
&& (ManagerTypeUuid->IsNullUuid() != 0)))
{
if (NullManagerFlag != 0)
{
ClearGlobalMutex();
return(RPC_S_TYPE_ALREADY_REGISTERED);
}
NullManagerEpv = ManagerEpv;
NullManagerFlag = 1;
ManagerCount += 1;
ClearGlobalMutex();
return(RPC_S_OK);
}
// If we reach here, a non-NULL type UUID is specified.
InterfaceManager = FindInterfaceManager(ManagerTypeUuid);
if (InterfaceManager == 0)
{
InterfaceManager = new RPC_INTERFACE_MANAGER(ManagerTypeUuid,
ManagerEpv);
if (InterfaceManager == 0)
{
ClearGlobalMutex();
return(RPC_S_OUT_OF_MEMORY);
}
if (InterfaceManagerDictionary.Insert(InterfaceManager) == -1)
{
ClearGlobalMutex();
delete InterfaceManager;
return(RPC_S_OUT_OF_MEMORY);
}
ManagerCount += 1;
ClearGlobalMutex();
return(RPC_S_OK);
}
if (InterfaceManager->ValidManager() == 0)
{
InterfaceManager->SetManagerEpv(ManagerEpv);
ManagerCount += 1;
ClearGlobalMutex();
return(RPC_S_OK);
}
ClearGlobalMutex();
return(RPC_S_TYPE_ALREADY_REGISTERED);
}
RPC_INTERFACE_MANAGER *
RPC_INTERFACE::FindInterfaceManager (
IN RPC_UUID PAPI * ManagerTypeUuid
)
/*++
Routine Description:
This method is used to obtain the interface manager corresponding to
the specified type UUID. The type UUID must not be the null UUID.
Arguments:
ManagerTypeUuid - Supplies the type UUID for which we are trying to
find the interface manager.
Return Value:
If a interface manager for this type UUID is found, a pointer to it
will be returned; otherwise, zero will be returned.
--*/
{
RPC_INTERFACE_MANAGER * InterfaceManager;
DictionaryCursor cursor;
InterfaceManagerDictionary.Reset(cursor);
while ((InterfaceManager = InterfaceManagerDictionary.Next(cursor)) != 0)
{
if (InterfaceManager->MatchTypeUuid(ManagerTypeUuid) == 0)
return(InterfaceManager);
}
return(0);
}
RPC_STATUS
RPC_INTERFACE::DispatchToStub (
IN OUT PRPC_MESSAGE Message,
IN unsigned int CallbackFlag,
IN PRPC_DISPATCH_TABLE DispatchTableToUse,
OUT RPC_STATUS PAPI * ExceptionCode
)
/*++
Routine Description:
This method is used to dispatch remote procedure calls to the
appropriate stub and hence to the appropriate manager entry point.
This routine is used for calls having a null UUID (implicit or
explicit). We go to great pains to insure that we do not grab
a mutex.
Arguments:
Message - Supplies the response message and returns the reply
message.
CallbackFlag - Supplies a flag indicating whether this is a callback
or not. The argument will be zero if this is an original call,
and non-zero if it is a callback.
ExceptionCode - Returns the exact exception code if an exception
occurs.
Return Value:
RPC_S_OK - This value will be returned if the operation completed
successfully.
RPC_S_PROCNUM_OUT_OF_RANGE - If the procedure number for this call is
too large, this value will be returned.
RPC_S_UNKNOWN_IF - If this interface does not exist, you will get this
value back.
RPC_S_NOT_LISTENING - The rpc server which owns this rpc interface
is not listening for remote procedure calls right now.
RPC_S_SERVER_TOO_BUSY - This call will cause there to be too many
concurrent remote procedure calls for the rpc server which owns
this interface.
RPC_P_EXCEPTION_OCCURED - A fault occured, and we need to remote it. The
ExceptionCode argument will contain the exception code for the
fault.
RPC_S_UNSUPPORTED_TYPE - This interface exists, but does not have a manager
for the null type.
--*/
{
RPC_STATUS RpcStatus = RPC_S_OK;
if ( CallbackFlag == 0 )
{
NullManagerActiveCallCount.Increment();
if ( NullManagerFlag == 0 )
{
NullManagerActiveCallCount.Decrement();
RpcStatus = RPC_S_UNSUPPORTED_TYPE;
RpcpErrorAddRecord(EEInfoGCRuntime,
RpcStatus,
EEInfoDLDispatchToStub10);
if ( ManagerCount == 0 )
{
RpcStatus = RPC_S_UNKNOWN_IF;
RpcpErrorAddRecord(EEInfoGCRuntime,
RpcStatus,
EEInfoDLDispatchToStub20);
}
}
}
if (RpcStatus != RPC_S_OK)
{
((MESSAGE_OBJECT *) Message->Handle)->FreeBuffer(Message);
return RpcStatus;
}
Message->ManagerEpv = NullManagerEpv;
RpcStatus = DispatchToStubWorker(Message, CallbackFlag, DispatchTableToUse, ExceptionCode);
if ( RpcStatus != RPC_S_OK
|| (((MESSAGE_OBJECT *) Message->Handle)->IsSyncCall()
&& CallbackFlag == 0 ))
{
NullManagerActiveCallCount.Decrement();
}
//
// DispatchToStubWorker freed Message.Buffer if an error occurred.
//
return(RpcStatus);
}
RPC_STATUS
RPC_INTERFACE::DispatchToStubWorker (
IN OUT PRPC_MESSAGE Message,
IN unsigned int CallbackFlag,
IN PRPC_DISPATCH_TABLE DispatchTableToUse,
OUT RPC_STATUS PAPI * ExceptionCode
)
/*++
Routine Description:
This method is used to dispatch remote procedure calls to the
appropriate stub and hence to the appropriate manager entry point.
It will be used for calls with and without objects specified.
We go to great pains to insure that we do not grab a mutex.
Arguments:
Message - Supplies the response message and returns the reply
message. If this routine returns anything other than RPC_S_OK
Message->Buffer has already been freed.
CallbackFlag - Supplies a flag indicating whether this is a callback
or not. The argument will be zero if this is an original call,
and non-zero if it is a callback.
DispatchTableToUse - a pointer to the dispatch table to use. This is
used to select b/n stubs for NDR20 and NDR64 transfer syntaxes
ExceptionCode - Returns the exact exception code if an exception
occurs.
Return Value:
RPC_S_OK - This value will be returned if the operation completed
successfully.
RPC_S_PROCNUM_OUT_OF_RANGE - If the procedure number for this call is
too large, this value will be returned.
RPC_S_NOT_LISTENING - The rpc server which owns this rpc interface
is not listening for remote procedure calls right now.
RPC_S_SERVER_TOO_BUSY - This call will cause there to be too many
concurrent remote procedure calls for the rpc server which owns
this interface.
RPC_P_EXCEPTION_OCCURED - A fault occured, and we need to remote it. The
ExceptionCode argument will contain the exception code for the
fault.
--*/
{
RPC_STATUS RpcStatus = RPC_S_OK;
void * OldServerContextList;
unsigned int procnum ;
THREAD *Self = RpcpGetThreadPointer() ;
ASSERT(Self);
if (Flags & RPC_IF_OLE)
{
procnum = 0 ;
}
else
{
procnum = Message->ProcNum ;
}
if (CallbackFlag == 0)
{
if (IsAutoListenInterface())
{
if (AutoListenCallCount.GetInteger() >= (long) MaxCalls)
{
RpcStatus = RPC_S_SERVER_TOO_BUSY ;
RpcpErrorAddRecord(EEInfoGCRuntime,
RpcStatus,
EEInfoDLDispatchToStubWorker10,
(ULONG)AutoListenCallCount.GetInteger(),
(ULONG)MaxCalls);
}
}
else
{
if (Server->IsServerListening() == 0)
{
RpcStatus = RPC_S_NOT_LISTENING;
RpcpErrorAddRecord(EEInfoGCRuntime,
RpcStatus,
EEInfoDLDispatchToStubWorker20);
}
else if (Server->fAccountForMaxCalls && Server->CallBeginning() == 0)
{
RpcStatus = RPC_S_SERVER_TOO_BUSY;
RpcpErrorAddRecord(EEInfoGCRuntime,
RpcStatus,
EEInfoDLDispatchToStubWorker30);
}
}
}
if (procnum >=
DispatchTableToUse->DispatchTableCount)
{
if (RpcStatus != RPC_S_SERVER_TOO_BUSY)
{
EndCall(CallbackFlag) ;
}
RpcStatus = RPC_S_PROCNUM_OUT_OF_RANGE;
RpcpErrorAddRecord(EEInfoGCRuntime,
RpcStatus,
EEInfoDLDispatchToStubWorker40);
}
if (RpcStatus != RPC_S_OK)
{
MO(Message)->FreeBuffer(Message);
return RpcStatus;
}
Server->IncomingCall();
((PRPC_RUNTIME_INFO) Message->ReservedForRuntime)->OldBuffer =
Message->Buffer ;
Message->RpcInterfaceInformation = &RpcInterfaceInformation;
SCALL(Message)->DoPreDispatchProcessing(Message, CallbackFlag);
if ( DispatchToStubInC(DispatchTableToUse->DispatchTable[procnum], Message, ExceptionCode) != 0 )
{
LogEvent(SU_EXCEPT, EV_STATUS, LongToPtr(*ExceptionCode),
DispatchTableToUse->DispatchTable[procnum], (ULONG_PTR)Message, 1, 1);
#if defined(DBG) && defined(i386)
#if 1
RtlCheckForOrphanedCriticalSections(NtCurrentThread());
#endif
#endif
RpcStatus = RPC_P_EXCEPTION_OCCURED;
RpcpErrorAddRecord(EEInfoGCApplication,
*ExceptionCode,
EEInfoDLRaiseExc,
GetInterfaceFirstDWORD(),
(short)procnum,
Message->RpcFlags,
GetCurrentThreadId());
}
RPC_MESSAGE OriginalMessage ;
OriginalMessage.ReservedForRuntime = 0;
OriginalMessage.Buffer =
((PRPC_RUNTIME_INFO) Message->ReservedForRuntime)->OldBuffer;
Self->ResetYield();
if (Self->IsSyncCall())
{
//
// Since this is a sync call, we know that it has
// not been freed yet. So we can safely touch it.
//
SCALL(Message)->DoPostDispatchProcessing();
//
// The dispatched call was a sync call
//
if (RPC_S_OK == RpcStatus)
{
//
// If the stub didn't allocate an output buffer, do so now.
//
if (OriginalMessage.Buffer == Message->Buffer)
{
Message->RpcFlags = 0;
Message->BufferLength = 0;
MO(Message)->GetBuffer(Message, 0);
}
//
// Free the [in] buffer that we saved.
//
MO(Message)->FreeBuffer(&OriginalMessage);
EndCall(CallbackFlag) ;
}
else
{
ASSERT(RpcStatus == RPC_P_EXCEPTION_OCCURED) ;
//
// Free the buffer in the caller's message; this can be either
// the [in] buffer or the [out] buffer, depending upon which
// line of the stub caused the error.
//
// If the exception occurred after allocating the [out] buffer,
// also free the [in] buffer.
//
if (OriginalMessage.Buffer != Message->Buffer)
{
MO(Message)->FreeBuffer(&OriginalMessage);
}
if (Message->Buffer)
{
MO(Message)->FreeBuffer(Message);
}
EndCall(CallbackFlag) ;
}
}
else
{
//
// The dispatched call was an async call
//
if (RpcStatus != RPC_S_OK
&& OriginalMessage.Buffer != Message->Buffer)
{
//
// The dispatch buffer will be freed during cleanup
// of the async call
//
MO(Message)->FreeBuffer(Message);
}
}
return(RpcStatus);
}
void
RPC_INTERFACE::EndCall(
IN unsigned int CallbackFlag,
BOOL fAsync
)
{
if (fAsync)
{
NullManagerActiveCallCount.Decrement();
}
if (CallbackFlag == 0)
{
if (!(Flags & RPC_IF_AUTOLISTEN) && Server->fAccountForMaxCalls)
{
Server->CallEnding();
}
}
}
RPC_STATUS
RPC_INTERFACE::DispatchToStubWithObject (
IN OUT PRPC_MESSAGE Message,
IN RPC_UUID * ObjectUuid,
IN unsigned int CallbackFlag,
IN PRPC_DISPATCH_TABLE DispatchTableToUse,
OUT RPC_STATUS PAPI * ExceptionCode
)
/*++
Routine Description:
This method is used to dispatch remote procedure calls to the
appropriate stub and hence to the appropriate manager entry point.
This routine is used for calls which have an associated object.
Arguments:
Message - Supplies the response message and returns the reply
message.
ObjectUuid - Supplies the object uuid to map into the manager entry
point for this call.
CallbackFlag - Supplies a flag indicating whether this is a callback
or not. The argument will be zero if this is an original call,
and non-zero if it is a callback.
ExceptionCode - Returns the exact exception code if an exception
occurs.
Return Value:
RPC_S_OK - The operation completed successfully.
RPC_S_PROCNUM_OUT_OF_RANGE - If the procedure number for this call is
too large, this value will be returned.
RPC_S_UNKNOWN_IF - If the specified manager is no longer
valid, you will get this value back.
RPC_S_NOT_LISTENING - The rpc server which owns this rpc interface
is not listening for remote procedure calls right now.
RPC_S_SERVER_TOO_BUSY - This call will cause there to be too many
concurrent remote procedure calls for the rpc server which owns
this interface.
RPC_P_EXCEPTION_OCCURED - A fault occured, and we need to remote it. The
ExceptionCode argument will contain the exception code for the
fault.
RPC_S_UNSUPPORTED_TYPE - There is no type manager for the object's type
for this interface.
--*/
{
RPC_UUID TypeUuid;
RPC_STATUS RpcStatus;
RPC_INTERFACE_MANAGER * RpcInterfaceManager;
RpcStatus = ObjectInqType(ObjectUuid, &TypeUuid);
VALIDATE(RpcStatus)
{
RPC_S_OK,
RPC_S_OBJECT_NOT_FOUND
} END_VALIDATE;
if ( RpcStatus == RPC_S_OK )
{
RpcInterfaceManager = FindInterfaceManager(&TypeUuid);
if ( ( RpcInterfaceManager != 0 )
&& ( ( CallbackFlag != 0 )
|| ( RpcInterfaceManager->ValidManager() != 0 ) ) )
{
Message->ManagerEpv = RpcInterfaceManager->QueryManagerEpv();
if ( CallbackFlag == 0 )
{
RpcInterfaceManager->CallBeginning();
}
RpcStatus = DispatchToStubWorker(Message, CallbackFlag, DispatchTableToUse,
ExceptionCode);
if ( CallbackFlag == 0 )
{
RpcInterfaceManager->CallEnding();
}
return(RpcStatus);
}
if (this != GlobalManagementInterface)
{
// There is a type for this object, but no type manager for
// this interface.
RpcStatus = RPC_S_UNSUPPORTED_TYPE;
if ( ManagerCount == 0 )
{
RpcStatus = RPC_S_UNKNOWN_IF;
}
((MESSAGE_OBJECT *) Message->Handle)->FreeBuffer(Message);
return RpcStatus;
}
}
// There has not been a type registered for this object, so we will
// just go ahead and try and use the NULL type manager.
return(DispatchToStub(Message, CallbackFlag, DispatchTableToUse, ExceptionCode));
}
BOOL
RPC_INTERFACE::IsObjectSupported (
IN RPC_UUID * ObjectUuid
)
/*++
Routine Description:
Determines whether the manager for the given object UUID is registered.
Arguments:
ObjectUuid - the client's object UUID
Return Value:
RPC_S_OK if it is OK to dispatch
RPC_S_UNKNOWN_IF if the interface is not registered
RPC_S_UNSUPPORTED_TYPE if this particular object's type is not registered
--*/
{
RPC_STATUS Status = RPC_S_OK;
if (ObjectUuid->IsNullUuid() )
{
if ( NullManagerFlag == 0 )
{
Status = RPC_S_UNSUPPORTED_TYPE;
if ( ManagerCount == 0 )
{
Status = RPC_S_UNKNOWN_IF;
}
}
}
else
{
RPC_UUID TypeUuid;
Status = ObjectInqType(ObjectUuid, &TypeUuid);
if ( Status == RPC_S_OK )
{
RPC_INTERFACE_MANAGER * RpcInterfaceManager = 0;
RpcInterfaceManager = FindInterfaceManager(&TypeUuid);
if (!RpcInterfaceManager ||
!RpcInterfaceManager->ValidManager())
{
Status = RPC_S_UNSUPPORTED_TYPE;
if ( ManagerCount == 0 )
{
Status = RPC_S_UNKNOWN_IF;
}
}
}
else
{
Status = RPC_S_OK;
if ( NullManagerFlag == 0 )
{
Status = RPC_S_UNSUPPORTED_TYPE;
if ( ManagerCount == 0 )
{
Status = RPC_S_UNKNOWN_IF;
}
}
}
}
return Status;
}
RPC_STATUS
RPC_INTERFACE::UpdateBindings (
IN RPC_BINDING_VECTOR *BindingVector
)
/*++
Function Name:UpdateEpMapperBindings
Parameters:
Description:
Returns:
--*/
{
RPC_STATUS Status;
unsigned int Length;
#if !defined(NO_LOCATOR_CODE)
NS_ENTRY *NsEntry;
#endif
DictionaryCursor cursor;
if (fBindingsExported)
{
Status = RegisterEntries(&RpcInterfaceInformation,
BindingVector,
UuidVector,
(unsigned char *) Annotation,
fReplace);
if (Status != RPC_S_OK)
{
return Status;
}
}
#if !defined(NO_LOCATOR_CODE)
// shortcut the common path and avoid taking and holding
// unnecessarily the high contention global mutex
if (NsEntries.Size() == 0)
return RPC_S_OK;
RequestGlobalMutex();
NsEntries.Reset(cursor);
while ((NsEntry = NsEntries.Next(cursor)) != 0)
{
//
// Actually update the locator bindings
//
Status = GlobalRpcServer->NsBindingUnexport(
NsEntry->EntryNameSyntax,
NsEntry->EntryName,
&RpcInterfaceInformation);
if (Status == RPC_S_OK)
{
Status = GlobalRpcServer->NsBindingExport(
NsEntry->EntryNameSyntax,
NsEntry->EntryName,
&RpcInterfaceInformation,
BindingVector);
#if DBG
if (Status != RPC_S_OK)
{
PrintToDebugger("RPC: Bindings were unexported, but could not re-export\n");
}
#endif
}
}
ClearGlobalMutex();
#endif
return RPC_S_OK;
}
RPC_STATUS
RPC_INTERFACE::InterfaceExported (
IN UUID_VECTOR *MyObjectUuidVector,
IN unsigned char *MyAnnotation,
IN BOOL MyfReplace
)
/*++
Function Name:InterfaceExported
Parameters:
Description:
RpcEpRegister was called on this interface. We need to keep track
of the parameters, so that if we get a PNP notification, we can update
the bindings using there params
Returns:
RPC_S_OK: things went fine
RPC_S_OUT_OF_MEMORY: ran out of memory
--*/
{
RequestGlobalMutex();
if (UuidVector
&& UuidVector != MyObjectUuidVector)
{
RpcpFarFree(UuidVector);
UuidVector = 0;
}
if (MyObjectUuidVector)
{
if (UuidVector != MyObjectUuidVector)
{
int Size = MyObjectUuidVector->Count*(sizeof(UUID)+sizeof(UUID *))
+sizeof(unsigned long);
UUID *Uuids;
unsigned i;
UuidVector = (UUID_VECTOR *) RpcpFarAllocate(Size);
if (UuidVector == 0)
{
ClearGlobalMutex();
return RPC_S_OUT_OF_MEMORY;
}
Uuids = (UUID *) ((char *) UuidVector + sizeof(unsigned long)
+(sizeof(UUID *) * MyObjectUuidVector->Count));
UuidVector->Count = MyObjectUuidVector->Count;
for (i = 0; i < UuidVector->Count; i++)
{
Uuids[i] = *(MyObjectUuidVector->Uuid[i]);
UuidVector->Uuid[i] = &Uuids[i];
}
}
}
else
{
UuidVector = 0;
}
if (MyAnnotation)
{
strncpy((char *) Annotation, (char *) MyAnnotation, 63);
Annotation[63]=0;
}
else
{
Annotation[0] = 0;
}
fReplace = MyfReplace;
fBindingsExported = 1;
ClearGlobalMutex();
return RPC_S_OK;
}
#if !defined(NO_LOCATOR_CODE)
NS_ENTRY *
RPC_INTERFACE::FindEntry (
IN unsigned long EntryNameSyntax,
IN RPC_CHAR *EntryName
)
{
NS_ENTRY *NsEntry;
DictionaryCursor cursor;
//
// This function will always be called with the mutex held
//
NsEntries.Reset(cursor);
while ((NsEntry = NsEntries.Next(cursor)) != 0)
{
if (NsEntry->Match(EntryNameSyntax, EntryName))
{
return NsEntry;
}
}
return 0;
}
RPC_STATUS
RPC_INTERFACE::NsInterfaceUnexported (
IN unsigned long EntryNameSyntax,
IN RPC_CHAR *EntryName
)
{
NS_ENTRY *NsEntry;
RequestGlobalMutex();
NsEntry = FindEntry(EntryNameSyntax, EntryName);
if (NsEntry == 0)
{
ClearGlobalMutex();
#if DBG
PrintToDebugger("RPC: No corresponding exported entry\n");
#endif
return RPC_S_ENTRY_NOT_FOUND;
}
NsEntries.Delete(NsEntry->Key);
ClearGlobalMutex();
return RPC_S_OK;
}
RPC_STATUS
RPC_INTERFACE::NsInterfaceExported (
IN unsigned long EntryNameSyntax,
IN RPC_CHAR *EntryName
)
{
RPC_STATUS Status = RPC_S_OK;
NS_ENTRY *NsEntry;
int retval;
RequestGlobalMutex();
NsEntry = FindEntry(EntryNameSyntax, EntryName);
ClearGlobalMutex();
if (NsEntry)
{
return RPC_S_OK;
}
NsEntry = new NS_ENTRY(
EntryNameSyntax,
EntryName,
&Status);
if (NsEntry == 0)
{
return RPC_S_OUT_OF_MEMORY;
}
if (Status != RPC_S_OK)
{
delete NsEntry;
return Status;
}
RequestGlobalMutex();
NsEntry->Key = NsEntries.Insert(NsEntry);
ClearGlobalMutex();
if (NsEntry->Key == -1)
{
delete NsEntry;
return RPC_S_OUT_OF_MEMORY;
}
return RPC_S_OK;
}
#endif
static unsigned int
MatchSyntaxIdentifiers (
IN PRPC_SYNTAX_IDENTIFIER ServerSyntax,
IN PRPC_SYNTAX_IDENTIFIER ClientSyntax
)
/*++
Routine Description:
This method compares two syntax identifiers (which consist of a
uuid, a major version number, and a minor version number). In
order for the syntax identifiers to match, the uuids must be the
same, the major version numbers must be the same, and the client
minor version number must be less than or equal to the server
minor version number.
Arguments:
ServerSyntax - Supplies the server syntax identifier.
ClientSyntax - Supplies the client syntax identifer.
Return Value:
Zero will be returned if the client syntax identifier matches the
server syntax identifier; otherwise, non-zero will be returned.
--*/
{
if (RpcpMemoryCompare(&(ServerSyntax->SyntaxGUID),
&(ClientSyntax->SyntaxGUID), sizeof(UUID)) != 0)
return(1);
if (ServerSyntax->SyntaxVersion.MajorVersion
!= ClientSyntax->SyntaxVersion.MajorVersion)
return(1);
if (ServerSyntax->SyntaxVersion.MinorVersion
< ClientSyntax->SyntaxVersion.MinorVersion)
return(1);
return(0);
}
unsigned int
RPC_INTERFACE::MatchInterfaceIdentifier (
IN PRPC_SYNTAX_IDENTIFIER InterfaceIdentifier
)
/*++
Routine Description:
This method compares the supplied interface identifier (which consists
of the interface uuid and interface version) against that contained
in this rpc interface. In order for this rpc interface to match,
the interface uuids must be the same, the interface major versions
must be the same, and the supplied interface minor version must be
less than or equal to the interface minor version contained in this
rpc interface.
Arguments:
InterfaceIdentifier - Supplies the interface identifier to compare
against that contained in this rpc interface.
Return Value:
Zero will be returned if the supplied interface identifer matches
(according to the rules described above) the interface identifier
contained in this rpc interface; otherwise, non-zero will be returned.
--*/
{
if (ManagerCount == 0)
return(1);
return(MatchSyntaxIdentifiers(&(RpcInterfaceInformation.InterfaceId),
InterfaceIdentifier));
}
unsigned int
RPC_INTERFACE::SelectTransferSyntax (
IN PRPC_SYNTAX_IDENTIFIER ProposedTransferSyntaxes,
IN unsigned int NumberOfTransferSyntaxes,
OUT PRPC_SYNTAX_IDENTIFIER AcceptedTransferSyntax,
OUT BOOL *fIsInterfaceTransferPreferred,
OUT int *ProposedTransferSyntaxIndex,
OUT int *AvailableTransferSyntaxIndex
)
/*++
Routine Description:
This method is used to select a transfer syntax from a list of one
or more transfer syntaxes. If a transfer syntax is selected, then
it will be returned in one of the arguments.
Arguments:
ProposedTransferSyntaxes - Supplies a list of one or more transfer
syntaxes from which this interface should select one which it
supports if possible.
NumberOfTransferSyntaxes - Supplies the number of transfer syntaxes
in the proposed transfer syntaxes argument.
AcceptedTransferSyntax - Returns the selected transfer syntax, if
one is selected.
fIsInterfaceTransferPreferred - true if the selected transfer syntax
is preferred by the server
ProposedTransferSyntaxIndex - the index of the transfer syntax that is
chosen from the proposed transfer syntaxes array. Zero based.
AvailableTransferSyntaxIndex - the index of the transfer syntax that is
chosen from the available transfer syntaxes in the interface. This
value must be stored in the binding and retrieved when asking for the
transfer syntax and dispatch table. Zero based.
Return Value:
Zero will be returned if a transfer syntax is selected; otherwise,
non-zero will be returned.
--*/
{
unsigned int ProposedIndex;
unsigned int AvailableIndex;
unsigned int NumberOfAvailableSyntaxes;
BOOL fMultipleTranfserSyntaxesSelected;
RPC_SYNTAX_IDENTIFIER *CurrentTransferSyntax;
RPC_SYNTAX_IDENTIFIER *BackupTransferSyntax = NULL;
int BackupProposedTransferSyntaxIndex;
int BackupAvailableTransferSyntaxIndex;
fMultipleTranfserSyntaxesSelected = AreMultipleTransferSyntaxesSupported();
if (fMultipleTranfserSyntaxesSelected)
NumberOfAvailableSyntaxes = NumberOfSupportedTransferSyntaxes;
else
NumberOfAvailableSyntaxes = 1;
for (AvailableIndex = 0; AvailableIndex < NumberOfAvailableSyntaxes; AvailableIndex ++)
{
if (fMultipleTranfserSyntaxesSelected)
CurrentTransferSyntax = &(TransferSyntaxesArray[AvailableIndex].TransferSyntax);
else
CurrentTransferSyntax = &RpcInterfaceInformation.TransferSyntax;
for (ProposedIndex = 0; ProposedIndex < NumberOfTransferSyntaxes;
ProposedIndex++)
{
if (MatchSyntaxIdentifiers(CurrentTransferSyntax,
&(ProposedTransferSyntaxes[ProposedIndex])) == 0)
{
// is this the preferred transfer syntax for the server?
if (AvailableIndex == PreferredTransferSyntax)
{
// this is the preferred transfer syntax - just
// copy it and return
RpcpMemoryCopy(AcceptedTransferSyntax,
&(ProposedTransferSyntaxes[ProposedIndex]),
sizeof(RPC_SYNTAX_IDENTIFIER));
*fIsInterfaceTransferPreferred = TRUE;
*ProposedTransferSyntaxIndex = ProposedIndex;
*AvailableTransferSyntaxIndex = AvailableIndex;
return(0);
}
else
{
// this is not the preferred syntax - just remeber this
// one (if no previous match was found) and continue
if (BackupTransferSyntax == NULL)
{
BackupTransferSyntax = &(ProposedTransferSyntaxes[ProposedIndex]);
BackupProposedTransferSyntaxIndex = ProposedIndex;
BackupAvailableTransferSyntaxIndex = AvailableIndex;
}
}
}
}
}
// if we're here, this means we didn't find the preferred transfer syntax
// check whether there is a backup syntax
if (BackupTransferSyntax)
{
RpcpMemoryCopy(AcceptedTransferSyntax, BackupTransferSyntax,
sizeof(RPC_SYNTAX_IDENTIFIER));
*fIsInterfaceTransferPreferred = FALSE;
*ProposedTransferSyntaxIndex = BackupProposedTransferSyntaxIndex;
*AvailableTransferSyntaxIndex = BackupAvailableTransferSyntaxIndex;
return(0);
}
// nada - no transfer syntax matches
return(1);
}
void RPC_INTERFACE::GetSelectedTransferSyntaxAndDispatchTable(IN int SelectedTransferSyntaxIndex,
OUT RPC_SYNTAX_IDENTIFIER **SelectedTransferSyntax,
OUT PRPC_DISPATCH_TABLE *SelectedDispatchTable)
{
MIDL_SYNTAX_INFO *SelectedSyntaxInfo;
if (DoesInterfaceSupportMultipleTransferSyntaxes(&RpcInterfaceInformation))
{
ASSERT((unsigned int)SelectedTransferSyntaxIndex <= NumberOfSupportedTransferSyntaxes);
SelectedSyntaxInfo = &TransferSyntaxesArray[SelectedTransferSyntaxIndex];
*SelectedTransferSyntax = &SelectedSyntaxInfo->TransferSyntax;
// DCOM has only one dispatch table - they change the dispatch target
// internally. They will define only the dispatch table in the
// interface
if (SelectedSyntaxInfo->DispatchTable)
*SelectedDispatchTable = SelectedSyntaxInfo->DispatchTable;
else
*SelectedDispatchTable = GetDefaultDispatchTable();
}
else
{
*SelectedTransferSyntax = &RpcInterfaceInformation.TransferSyntax;
*SelectedDispatchTable = GetDefaultDispatchTable();
}
}
RPC_STATUS
RPC_INTERFACE::UnregisterManagerEpv (
IN RPC_UUID PAPI * ManagerTypeUuid, OPTIONAL
IN unsigned int WaitForCallsToComplete
)
/*++
Routine Description:
In this method, we unregister one or all of the manager entry point
vectors for this interface, depending on what, if anything, is
specified for the manager type uuid argument.
Arguments:
ManagerTypeUuid - Optionally supplies the type uuid of the manager
entry point vector to be removed. If this argument is not supplied,
then all manager entry point vectors for this interface will
be removed.
WaitForCallsToComplete - Supplies a flag indicating whether or not
this routine should wait for all calls to complete using the
interface and manager being unregistered. A non-zero value
indicates to wait.
Return Value:
RPC_S_OK - The manager entry point vector(s) are(were) successfully
removed from the this interface.
RPC_S_UNKNOWN_MGR_TYPE - The specified type uuid is not registered
with this interface.
RPC_S_UNKNOWN_IF - The specified interface is not registered with
the rpc server.
--*/
{
RPC_INTERFACE_MANAGER * InterfaceManager;
DictionaryCursor cursor;
RequestGlobalMutex();
if (ManagerCount == 0)
{
ClearGlobalMutex();
return(RPC_S_UNKNOWN_MGR_TYPE);
}
if (ARGUMENT_PRESENT(ManagerTypeUuid) == 0)
{
InterfaceManagerDictionary.Reset(cursor);
while ((InterfaceManager = InterfaceManagerDictionary.Next(cursor)) != 0)
{
InterfaceManager->InvalidateManager();
}
ManagerCount = 0;
NullManagerFlag = 0;
ClearGlobalMutex();
if ( WaitForCallsToComplete != 0 )
{
while ( NullManagerActiveCallCount.GetInteger() > 0 )
{
PauseExecution(500L);
}
InterfaceManagerDictionary.Reset(cursor);
while ((InterfaceManager = InterfaceManagerDictionary.Next(cursor)) != 0)
{
while ( InterfaceManager->InquireActiveCallCount() > 0 )
{
PauseExecution(500L);
}
}
}
return(RPC_S_OK);
}
if (ManagerTypeUuid->IsNullUuid() != 0)
{
if (NullManagerFlag == 0)
{
ClearGlobalMutex();
return(RPC_S_UNKNOWN_MGR_TYPE);
}
ManagerCount -= 1;
NullManagerFlag = 0;
ClearGlobalMutex();
if ( WaitForCallsToComplete != 0 )
{
while ( NullManagerActiveCallCount.GetInteger() > 0 )
{
PauseExecution(500L);
}
}
return(RPC_S_OK);
}
InterfaceManager = FindInterfaceManager(ManagerTypeUuid);
if ( (InterfaceManager == 0)
|| (InterfaceManager->ValidManager() == 0))
{
ClearGlobalMutex();
return(RPC_S_UNKNOWN_MGR_TYPE);
}
InterfaceManager->InvalidateManager();
ManagerCount -= 1;
ClearGlobalMutex();
if ( WaitForCallsToComplete != 0 )
{
while ( InterfaceManager->InquireActiveCallCount() > 0 )
{
PauseExecution(500L);
}
}
return(RPC_S_OK);
}
RPC_STATUS
RPC_INTERFACE::InquireManagerEpv (
IN RPC_UUID PAPI * ManagerTypeUuid, OPTIONAL
OUT RPC_MGR_EPV PAPI * PAPI * ManagerEpv
)
/*++
Routine Description:
This method is used to obtain the manager entry point vector
with the specified type uuid supported by this interface.
Arguments:
ManagerTypeUuid - Optionally supplies the type uuid of the manager
entry point vector we want returned. If no manager type uuid
is specified, then the null uuid is assumed.
ManagerEpv - Returns the manager entry point vector.
Return Value:
RPC_S_OK - The manager entry point vector has successfully been
returned.
RPC_S_UNKNOWN_MGR_TYPE - The specified type uuid is not registered
with the interface.
RPC_S_UNKNOWN_IF - The specified interface is not registered with
the rpc server.
--*/
{
RPC_INTERFACE_MANAGER * InterfaceManager;
RequestGlobalMutex();
if (ManagerCount == 0)
{
ClearGlobalMutex();
return(RPC_S_UNKNOWN_IF);
}
if ( (ARGUMENT_PRESENT(ManagerTypeUuid) == 0)
|| (ManagerTypeUuid->IsNullUuid() != 0))
{
if (NullManagerFlag == 0)
{
ClearGlobalMutex();
return(RPC_S_UNKNOWN_MGR_TYPE);
}
*ManagerEpv = NullManagerEpv;
ClearGlobalMutex();
return(RPC_S_OK);
}
InterfaceManager = FindInterfaceManager(ManagerTypeUuid);
if ( (InterfaceManager == 0)
|| (InterfaceManager->ValidManager() == 0))
{
ClearGlobalMutex();
return(RPC_S_UNKNOWN_MGR_TYPE);
}
*ManagerEpv = InterfaceManager->QueryManagerEpv();
ClearGlobalMutex();
return(RPC_S_OK);
}
RPC_STATUS
RPC_INTERFACE::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
)
/*++
Routine Description:
We never delete the interface objects from a server; we just invalidate
them. This means that if an interface has been complete unregistered
(ie. it has no managers), we need to update the interface information
again.
Arguments:
RpcInterfaceInformation - Supplies the interface information which this
interface should be using.
--*/
{
unsigned int Length;
RPC_STATUS Status;
Length = RpcInterfaceInformation->Length;
ASSERT((Length == sizeof(RPC_SERVER_INTERFACE)) ||
(Length == NT351_INTERFACE_SIZE));
// make it stick on free builds as well
if ((Length != sizeof(RPC_SERVER_INTERFACE)) &&
(Length != NT351_INTERFACE_SIZE))
return RPC_S_UNKNOWN_IF;
if ( ManagerCount == 0 )
{
if (DoesInterfaceSupportMultipleTransferSyntaxes(RpcInterfaceInformation))
{
Status = NdrServerGetSupportedSyntaxes(RpcInterfaceInformation,
&NumberOfSupportedTransferSyntaxes,
&TransferSyntaxesArray, &PreferredTransferSyntax);
if (Status != RPC_S_OK)
return Status;
}
else
{
NumberOfSupportedTransferSyntaxes = 0;
}
RpcpMemoryCopy(&(this->RpcInterfaceInformation),
RpcInterfaceInformation, Length);
}
if (Flags & RPC_IF_AUTOLISTEN
&& (this->Flags & RPC_IF_AUTOLISTEN) == 0)
{
GlobalRpcServer->IncrementAutoListenInterfaceCount() ;
}
this->Flags = Flags ;
this->MaxCalls = MaxCalls ;
this->MaxRpcSize = MaxRpcSize;
SequenceNumber++ ;
if (Flags & RPC_IF_ALLOW_SECURE_ONLY
&& IfCallbackFn == NULL)
{
this->CallbackFn = DefaultCallbackFn;
}
else
{
this->CallbackFn = IfCallbackFn ;
}
return RPC_S_OK;
}
RPC_IF_ID __RPC_FAR *
RPC_INTERFACE::InquireInterfaceId (
)
/*++
Return Value:
If this interface is active, its interface id will be returned in a
newly allocated chunk of memory; otherwise, zero will be returned.
--*/
{
RPC_IF_ID __RPC_FAR * RpcIfId;
if ( ManagerCount == 0 )
{
return(0);
}
RpcIfId = (RPC_IF_ID __RPC_FAR *) RpcpFarAllocate(sizeof(RPC_IF_ID));
if ( RpcIfId == 0 )
{
return(0);
}
RpcIfId->Uuid = RpcInterfaceInformation.InterfaceId.SyntaxGUID;
RpcIfId->VersMajor =
RpcInterfaceInformation.InterfaceId.SyntaxVersion.MajorVersion;
RpcIfId->VersMinor =
RpcInterfaceInformation.InterfaceId.SyntaxVersion.MinorVersion;
return(RpcIfId);
}
RPC_STATUS
RPC_INTERFACE::CheckSecurityIfNecessary(
IN void * Context
)
{
//
// If manager count in non-zero, this interface is still registered
// If it has been registered with a call back function, invoke the callback
// function, else return success....
RPC_IF_ID RpcIfId;
RPC_STATUS RpcStatus = RPC_S_OK;
if (CallbackFn != 0)
{
RpcIfId.Uuid = RpcInterfaceInformation.InterfaceId.SyntaxGUID;
RpcIfId.VersMajor =
RpcInterfaceInformation.InterfaceId.SyntaxVersion.MajorVersion;
RpcIfId.VersMinor =
RpcInterfaceInformation.InterfaceId.SyntaxVersion.MinorVersion;
BeginAutoListenCall();
if (ManagerCount == 0)
{
EndAutoListenCall();
return (RPC_S_UNKNOWN_IF);
}
RpcTryExcept
{
RpcStatus = CallbackFn(&RpcIfId, Context);
}
RpcExcept(I_RpcExceptionFilter(RpcExceptionCode()))
{
RpcStatus = RPC_S_ACCESS_DENIED;
}
RpcEndExcept
EndAutoListenCall();
}
return(RpcStatus);
}
void
RPC_INTERFACE::WaitForCalls(
)
/*++
Routine Description:
Waits for the completion of all the calls on a given interface.
--*/
{
DictionaryCursor cursor;
RPC_INTERFACE_MANAGER * InterfaceManager;
while ( NullManagerActiveCallCount.GetInteger() > 0 )
{
PauseExecution(500L);
}
InterfaceManagerDictionary.Reset(cursor);
while ((InterfaceManager = InterfaceManagerDictionary.Next(cursor)) != 0)
{
while ( InterfaceManager->InquireActiveCallCount() > 0 )
{
PauseExecution(500L);
}
}
}
RPC_SERVER::RPC_SERVER (
IN OUT RPC_STATUS PAPI * RpcStatus
) : AvailableCallCount(0),
ServerMutex(RpcStatus,
TRUE // pre-allocate semaphore
),
StopListeningEvent(RpcStatus),
ThreadCacheMutex(RpcStatus,
TRUE, // pre-allocate semaphore
100
),
NumAutoListenInterfaces(0)
/*++
Routine Description:
This routine will get called to construct an instance of the
RPC_SERVER class.
--*/
{
ALLOCATE_THIS(RPC_SERVER);
ServerListeningFlag = 0;
ListeningThreadFlag = 0;
WaitingThreadFlag = 0;
MinimumCallThreads = 1;
MaximumConcurrentCalls = 1;
IncomingRpcCount = 0;
OutgoingRpcCount = 0;
ReceivedPacketCount = 0;
SentPacketCount = 0;
ThreadCache = 0;
ListenStatusCode = RPC_S_OK;
fAccountForMaxCalls = TRUE;
pRpcForwardFunction = (RPC_FORWARD_FUNCTION *)0;
#if !defined(NO_LOCATOR_CODE)
pNsBindingExport = 0;
pNsBindingUnexport = 0;
#endif
}
RPC_INTERFACE *
RPC_SERVER::FindInterface (
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation
)
/*++
Routine Description:
This method is used to find the rpc interface registered with this
server which matches the supplied rpc interface information.
Arguments:
RpcInterfaceInformation - Supplies the rpc interface information
identifying the rpc interface we are looking for.
Return Value:
The rpc interface matching the supplied rpc interface information
will be returned if it is found; otherwise, zero will be returned.
--*/
{
RPC_INTERFACE * RpcInterface;
DictionaryCursor cursor;
ServerMutex.VerifyOwned();
RpcInterfaceDictionary.Reset(cursor);
while ((RpcInterface = RpcInterfaceDictionary.Next(cursor)) != 0)
{
if (RpcInterface->MatchRpcInterfaceInformation(
RpcInterfaceInformation) == 0)
{
return(RpcInterface);
}
}
// The management interface is implicitly registered in all servers.
if ( (GlobalManagementInterface)
&& (GlobalManagementInterface->MatchRpcInterfaceInformation(
RpcInterfaceInformation) == 0) )
{
return(GlobalManagementInterface);
}
return(0);
}
int
RPC_SERVER::AddInterface (
IN RPC_INTERFACE * RpcInterface
)
/*++
Routine Description:
This method will be used to all an rpc interface to the set of
interfaces known about by this server.
Arguments:
RpcInterface - Supplies the rpc interface to add to the set of
interfaces.
Return Value:
Zero will be returned if the interface is successfully added to
the set; otherwise, non-zero will be returned indicating that
insufficient memory is available to complete the operation.
--*/
{
if (RpcInterfaceDictionary.Insert(RpcInterface) == -1)
{
ServerMutex.Clear();
return(-1);
}
return(0);
}
RPC_STATUS
RPC_SERVER::FindInterfaceTransfer (
IN PRPC_SYNTAX_IDENTIFIER InterfaceIdentifier,
IN PRPC_SYNTAX_IDENTIFIER ProposedTransferSyntaxes,
IN unsigned int NumberOfTransferSyntaxes,
OUT PRPC_SYNTAX_IDENTIFIER AcceptedTransferSyntax,
OUT RPC_INTERFACE ** AcceptingRpcInterface,
OUT BOOL *fInterfaceTransferIsPreferred,
OUT int *ProposedTransferSyntaxIndex,
OUT int *AvailableTransferSyntaxIndex
)
/*++
Routine Description:
This method is used to determine if a client bind request can be
accepted or not. All we have got to do here is hand off to the
server which owns this address.
Arguments:
InterfaceIdentifier - Supplies the syntax identifier for the
interface; this is the interface uuid and version.
ProposedTransferSyntaxes - Supplies a list of one or more transfer
syntaxes which the client initiating the binding supports. The
server should pick one of these which is supported by the
interface.
NumberOfTransferSyntaxes - Supplies the number of transfer syntaxes
specified in the proposed transfer syntaxes argument.
AcceptedTransferSyntax - Returns the transfer syntax which the
server accepted.
AcceptingRpcInterface - Returns a pointer to the rpc interface found
which supports the requested interface and one of the requested
transfer syntaxes.
fInterfaceTransferIsPreferred - non zero if the interface transfer
returned is preferred.
TransferSyntaxIndex - the index of the chosen transfer syntax in the
ProposedTransferSyntaxesArray
Return Value:
RPC_S_OK - The requested interface exists and it supports at least
one of the proposed transfer syntaxes. We are all set, now we
can make remote procedure calls.
RPC_S_UNSUPPORTED_TRANSFER_SYNTAX - The requested interface exists,
but it does not support any of the proposed transfer syntaxes.
RPC_S_UNKNOWN_IF - The requested interface is not supported
by this rpc server.
--*/
{
RPC_INTERFACE * RpcInterface;
unsigned int InterfaceFound = 0;
DictionaryCursor cursor;
ServerMutex.Request();
RpcInterfaceDictionary.Reset(cursor);
while ((RpcInterface = RpcInterfaceDictionary.Next(cursor)) != 0)
{
if (RpcInterface->MatchInterfaceIdentifier(InterfaceIdentifier) == 0)
{
InterfaceFound = 1;
if (RpcInterface->SelectTransferSyntax(ProposedTransferSyntaxes,
NumberOfTransferSyntaxes, AcceptedTransferSyntax,
fInterfaceTransferIsPreferred, ProposedTransferSyntaxIndex,
AvailableTransferSyntaxIndex) == 0)
{
ServerMutex.Clear();
*AcceptingRpcInterface = RpcInterface;
return(RPC_S_OK);
}
}
}
ServerMutex.Clear();
// The management interface is implicitly registered in all servers.
if ( (GlobalManagementInterface)
&& (GlobalManagementInterface->MatchInterfaceIdentifier(
InterfaceIdentifier) == 0 ) )
{
InterfaceFound = 1;
if (GlobalManagementInterface->SelectTransferSyntax(
ProposedTransferSyntaxes, NumberOfTransferSyntaxes,
AcceptedTransferSyntax, fInterfaceTransferIsPreferred,
ProposedTransferSyntaxIndex, AvailableTransferSyntaxIndex) == 0)
{
*AcceptingRpcInterface = GlobalManagementInterface;
return(RPC_S_OK);
}
}
if (InterfaceFound == 0)
return(RPC_S_UNKNOWN_IF);
return(RPC_S_UNSUPPORTED_TRANS_SYN);
}
RPC_INTERFACE *
RPC_SERVER::FindInterface (
IN PRPC_SYNTAX_IDENTIFIER InterfaceIdentifier
)
/*++
Routine Description:
The datagram protocol module will use this routine to find the interface
with out worrying about the transfer syntax. Datagram RPC does not support
more than a single transfer syntax.
Arguments:
InterfaceIdentifier - Supplies the identifier (UUID and version) of the
interface we are trying to find.
Return Value:
If the interface is found it will be returned; otherwise, zero will be
returned.
--*/
{
RPC_INTERFACE * RpcInterface;
DictionaryCursor cursor;
ServerMutex.Request();
RpcInterfaceDictionary.Reset(cursor);
while ( (RpcInterface = RpcInterfaceDictionary.Next(cursor)) != 0)
{
if ( RpcInterface->MatchInterfaceIdentifier(InterfaceIdentifier)
== 0 )
{
ServerMutex.Clear();
return(RpcInterface);
}
}
ServerMutex.Clear();
// The management interface is implicitly registered in all servers.
if ( (GlobalManagementInterface)
&& (GlobalManagementInterface->MatchInterfaceIdentifier(
InterfaceIdentifier) == 0) )
{
return(GlobalManagementInterface);
}
return(0);
}
RPC_STATUS
RPC_SERVER::ServerListen (
IN unsigned int MinimumCallThreads,
IN unsigned int MaximumConcurrentCalls,
IN unsigned int DontWait
)
/*++
Routine Description:
This method is called to start this rpc server listening for remote
procedure calls. We do not return until after StopServerListening
has been called and all active calls complete, or an error occurs.
Arguments:
MinimumCallThreads - Supplies the minimum number of call threads
which should be created to service remote procedure calls.
MaximumConcurrentCalls - Supplies the maximum concurrent calls this
rpc server is willing to accept at one time.
DontWait - Supplies a flag indicating whether or not to wait until
RpcMgmtStopServerListening has been called and all calls have
completed. A non-zero value indicates not to wait.
Return Value:
RPC_S_OK - Everything worked out in the end. All active calls
completed successfully after RPC_SERVER::StopServerListening
was called. No errors occured in the transports.
RPC_S_ALREADY_LISTENING - This rpc server is already listening.
RPC_S_NO_PROTSEQS_REGISTERED - No protocol sequences have been
registered with this rpc server. As a consequence it is
impossible for this rpc server to receive any remote procedure
calls, hence, the error code.
RPC_S_MAX_CALLS_TOO_SMALL - MaximumConcurrentCalls is smaller than
MinimumCallThreads or MaximumConcurrentCalls is zero.
--*/
{
RPC_ADDRESS * RpcAddress;
RPC_STATUS Status;
DictionaryCursor cursor;
if ( ( MaximumConcurrentCalls < MinimumCallThreads )
|| ( MaximumConcurrentCalls == 0 ) )
{
return(RPC_S_MAX_CALLS_TOO_SMALL);
}
if ( MaximumConcurrentCalls > 0x7FFFFFFF )
{
MaximumConcurrentCalls = 0x7FFFFFFF;
}
ServerMutex.Request();
if ( ListeningThreadFlag != 0 )
{
ServerMutex.Clear();
return(RPC_S_ALREADY_LISTENING);
}
if ( RpcAddressDictionary.Size() == 0
&& RpcDormantAddresses.IsQueueEmpty())
{
ServerMutex.Clear();
return(RPC_S_NO_PROTSEQS_REGISTERED);
}
this->MaximumConcurrentCalls = MaximumConcurrentCalls;
// if we are provided the default number, then we don't really care -
// play for optimal performance
if (MaximumConcurrentCalls == RPC_C_LISTEN_MAX_CALLS_DEFAULT)
fAccountForMaxCalls = FALSE;
this->MinimumCallThreads = MinimumCallThreads;
AvailableCallCount.SetInteger( MaximumConcurrentCalls );
RpcAddressDictionary.Reset(cursor);
while ( (RpcAddress = RpcAddressDictionary.Next(cursor)) != 0 )
{
Status = RpcAddress->ServerStartingToListen(
MinimumCallThreads,
MaximumConcurrentCalls);
if (Status)
{
ServerMutex.Clear();
return(Status);
}
}
StopListeningEvent.Lower();
ServerListeningFlag = 1;
ListeningThreadFlag = 1;
if ( DontWait != 0 )
{
ServerMutex.Clear();
return(RPC_S_OK);
}
WaitingThreadFlag = 1;
ServerMutex.Clear();
return(WaitForStopServerListening());
}
RPC_STATUS
RPC_SERVER::WaitForStopServerListening (
)
/*++
Routine Description:
We wait for StopServerListening to be called and then for all active
remote procedure calls to complete before returning.
Return Value:
RPC_S_OK - Everything worked out in the end. All active calls
completed successfully after RPC_SERVER::StopServerListening
was called. No errors occured in the transports.
--*/
{
RPC_ADDRESS * RpcAddress;
DictionaryCursor cursor;
RPC_INTERFACE * RpcInterface;
StopListeningEvent.Wait();
if ( ListenStatusCode != RPC_S_OK )
{
ListeningThreadFlag = 0;
return(ListenStatusCode);
}
RpcAddressDictionary.Reset(cursor);
while ( (RpcAddress = RpcAddressDictionary.Next(cursor)) != 0 )
{
RpcAddress->ServerStoppedListening();
}
RpcAddressDictionary.Reset(cursor);
while ( (RpcAddress = RpcAddressDictionary.Next(cursor)) != 0 )
{
RpcAddress->WaitForCalls();
}
// Wait for calls on all interfaces to complete
RpcInterfaceDictionary.Reset(cursor);
while ((RpcInterface = RpcInterfaceDictionary.Next(cursor)) != 0)
{
RpcInterface->WaitForCalls();
}
ServerMutex.Request();
WaitingThreadFlag = 0;
ListeningThreadFlag = 0;
ServerMutex.Clear();
return(RPC_S_OK);
}
RPC_STATUS
RPC_SERVER::WaitServerListen (
)
/*++
Routine Description:
This routine performs the wait that ServerListen normally performs
when the DontWait flag is not set. An application must call this
routine only after RpcServerListen has been called with the DontWait
flag set. We do not return until RpcMgmtStopServerListening is called
and all active remote procedure calls complete, or a fatal error occurs
in the runtime.
Return Value:
RPC_S_OK - Everything worked as expected. All active remote procedure
calls have completed. It is now safe to exit this process.
RPC_S_ALREADY_LISTENING - Another thread has already called
WaitServerListen and has not yet returned.
RPC_S_NOT_LISTENING - ServerListen has not yet been called.
--*/
{
ServerMutex.Request();
if ( ListeningThreadFlag == 0 )
{
ServerMutex.Clear();
return(RPC_S_NOT_LISTENING);
}
if ( WaitingThreadFlag != 0 )
{
ServerMutex.Clear();
return(RPC_S_ALREADY_LISTENING);
}
WaitingThreadFlag = 1;
ServerMutex.Clear();
return(WaitForStopServerListening());
}
void
RPC_SERVER::InquireStatistics (
OUT RPC_STATS_VECTOR * Statistics
)
/*++
Routine Description:
This method is used to obtain the statistics for this rpc server.
Arguments:
Statistics - Returns the statistics for this rpc server.
--*/
{
Statistics->Stats[RPC_C_STATS_CALLS_IN] = IncomingRpcCount;
Statistics->Stats[RPC_C_STATS_CALLS_OUT] = OutgoingRpcCount;
Statistics->Stats[RPC_C_STATS_PKTS_IN] = ReceivedPacketCount;
Statistics->Stats[RPC_C_STATS_PKTS_OUT] = SentPacketCount;
}
RPC_STATUS
RPC_SERVER::StopServerListening (
)
/*++
Routine Description:
This method is called to stop this rpc server from listening for
more remote procedure calls. Active calls are allowed to complete
(including callbacks). The thread which called ServerListen will
return when all active calls complete.
Return Value:
RPC_S_OK - The thread that called ServerListen has successfully been
notified that it should shutdown.
RPC_S_NOT_LISTENING - There is no thread currently listening.
--*/
{
if (ListeningThreadFlag == 0)
return(RPC_S_NOT_LISTENING);
ListenStatusCode = RPC_S_OK;
ServerListeningFlag = 0;
StopListeningEvent.Raise();
return(RPC_S_OK);
}
RPC_STATUS
RPC_SERVER::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
)
/*++
Routine Description:
This method is who does the work of creating new address (they
are called protocol sequences in the DCE lingo) and adding them to
this rpc server.
Arguments:
RpcProtocolSequence - Supplies the rpc protocol sequence we wish
to add to this rpc server.
PendingQueueSize - Supplies the size of the queue of pending
requests which should be created by the transport. Some transports
will not be able to make use of this value, while others will.
Endpoint - Optionally supplies an endpoint to be used for the new
address. If an endpoint is not specified, then we will let
the transport specify the endpoint.
SecurityDescriptor - Optionally supplies a security descriptor to
be placed on the rpc protocol sequence (address) we are adding
to this rpc server.
Return Value:
RPC_S_OK - The requested rpc protocol sequence has been added to
this rpc server.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to add the
requested rpc protocol sequence to this rpc server.
RPC_S_PROTSEQ_NOT_SUPPORTED - The specified rpc protocol sequence
is not supported (but it appears to be valid).
RPC_S_INVALID_RPC_PROTSEQ - The specified rpc protocol sequence is
syntactically invalid.
RPC_S_DUPLICATE_ENDPOINT - The supplied endpoint has already been
added to this rpc server.
RPC_S_INVALID_SECURITY_DESC - The supplied security descriptor is
invalid.
--*/
{
TRANS_INFO *ServerTransInfo ;
RPC_STATUS Status;
RPC_ADDRESS * RpcAddress;
RPC_ADDRESS * Address;
NETWORK_ADDRESS_VECTOR *pNetworkAddressVector;
unsigned int StaticEndpointFlag;
int Key;
DictionaryCursor cursor;
THREAD *ThisThread;
ThisThread = ThreadSelf();
if (ThisThread == NULL)
return RPC_S_OUT_OF_MEMORY;
// remove old EEInfo
RpcpPurgeEEInfo();
if (IsServerSideDebugInfoEnabled())
{
Status = InitializeServerSideCellHeapIfNecessary();
if (Status != RPC_S_OK)
return Status;
}
if ( RpcpStringCompare(RpcProtocolSequence,
RPC_CONST_STRING("ncalrpc")) == 0 )
{
RpcAddress = LrpcCreateRpcAddress();
}
else if ( RpcpStringNCompare(
RPC_CONST_STRING("ncadg_"),
RpcProtocolSequence,
6) == 0)
{
//
// Just use the osf mapping...it simply calls the
// protocol-independent ones.
//
Status = OsfMapRpcProtocolSequence(1,
RpcProtocolSequence,
&ServerTransInfo);
if (Status != RPC_S_OK)
{
return Status;
}
RpcAddress = DgCreateRpcAddress(ServerTransInfo);
}
else if ( RpcpStringNCompare(
RPC_CONST_STRING("ncacn_"),
RpcProtocolSequence,
6) == 0)
{
Status = OsfMapRpcProtocolSequence(1,
RpcProtocolSequence,
&ServerTransInfo);
if (Status != RPC_S_OK)
{
return(Status);
}
RpcAddress = OsfCreateRpcAddress(ServerTransInfo);
}
else
{
return(RPC_S_PROTSEQ_NOT_SUPPORTED);
}
if (RpcAddress == 0)
{
return(RPC_S_OUT_OF_MEMORY);
}
if (ARGUMENT_PRESENT(Endpoint))
{
ServerMutex.Request();
RpcAddressDictionary.Reset(cursor);
while ((Address = RpcAddressDictionary.Next(cursor)) != 0)
{
if ( Address->SameEndpointAndProtocolSequence(
NetworkAddress,
RpcProtocolSequence,
Endpoint) != 0 )
{
ServerMutex.Clear();
delete RpcAddress;
return(RPC_S_DUPLICATE_ENDPOINT);
}
}
ServerMutex.Clear();
Endpoint = DuplicateString(Endpoint);
if (Endpoint == 0)
{
delete RpcAddress;
return(RPC_S_OUT_OF_MEMORY);
}
StaticEndpointFlag = 1;
}
else
{
//
// MACBUG:
// We need to include this for Macintosh/Win95 also...
//
ServerMutex.Request() ;
RpcAddressDictionary.Reset(cursor) ;
while ((Address = RpcAddressDictionary.Next(cursor)) != 0)
{
if ( Address->SameProtocolSequence(NetworkAddress,
RpcProtocolSequence) != 0 )
{
ServerMutex.Clear();
delete RpcAddress;
return(RPC_S_OK);
}
}
ServerMutex.Clear();
StaticEndpointFlag = 0;
} // else
if (EndpointFlags & RPC_C_DONT_FAIL)
{
RpcAddress->PnpNotify();
}
Status = RpcAddress->ServerSetupAddress(
NetworkAddress,
&Endpoint,
PendingQueueSize,
SecurityDescriptor,
EndpointFlags,
NICFlags,
&pNetworkAddressVector);
if (Status == RPC_S_OK)
{
RPC_CHAR *MyNetworkAddress = NULL;
RpcProtocolSequence = DuplicateString(RpcProtocolSequence);
if (RpcProtocolSequence == 0)
{
delete Endpoint;
delete RpcAddress;
return(RPC_S_OUT_OF_MEMORY);
}
if (ARGUMENT_PRESENT(NetworkAddress))
{
MyNetworkAddress = DuplicateString(NetworkAddress);
if (MyNetworkAddress == 0)
{
delete Endpoint;
delete RpcAddress;
delete RpcProtocolSequence;
return(RPC_S_OUT_OF_MEMORY);
}
}
Status = RpcAddress->SetEndpointAndStuff(
MyNetworkAddress,
Endpoint,
RpcProtocolSequence,
this,
StaticEndpointFlag,
PendingQueueSize,
SecurityDescriptor,
EndpointFlags,
NICFlags,
pNetworkAddressVector);
if (Status != RPC_S_OK)
{
delete RpcAddress;
return Status;
}
}
else
{
if (EndpointFlags & RPC_C_DONT_FAIL)
{
int retval;
RPC_CHAR *MyNetworkAddress = NULL;
RpcProtocolSequence = DuplicateString(RpcProtocolSequence);
if (RpcProtocolSequence == 0)
{
delete Endpoint;
delete RpcAddress;
return(RPC_S_OUT_OF_MEMORY);
}
if (ARGUMENT_PRESENT(NetworkAddress))
{
MyNetworkAddress = DuplicateString(NetworkAddress);
if (MyNetworkAddress == 0)
{
delete Endpoint;
delete RpcAddress;
delete RpcProtocolSequence;
return(RPC_S_OUT_OF_MEMORY);
}
}
Status = RpcAddress->SetEndpointAndStuff(
MyNetworkAddress,
Endpoint,
RpcProtocolSequence,
this,
StaticEndpointFlag,
PendingQueueSize,
SecurityDescriptor,
EndpointFlags,
NICFlags,
NULL);
if (Status != RPC_S_OK)
{
delete Endpoint;
delete RpcAddress;
return Status;
}
ServerMutex.Request();
retval = RpcDormantAddresses.PutOnQueue(RpcAddress, 0);
ServerMutex.Clear();
if (retval == 1)
{
delete Endpoint;
delete RpcAddress;
return RPC_S_OUT_OF_MEMORY;
}
ServerMutex.Request();
Status = RpcAddress->ServerStartingToListen(
MinimumCallThreads,
MaximumConcurrentCalls);
ServerMutex.Clear();
if (Status)
{
return(Status);
}
return RPC_S_OK;
}
else
{
delete RpcAddress;
return(Status);
}
}
Key = AddAddress(RpcAddress);
if (Key == -1)
{
delete RpcAddress;
return(RPC_S_OUT_OF_MEMORY);
}
RpcAddress->DictKey = Key;
ServerMutex.Request();
Status = RpcAddress->ServerStartingToListen(
MinimumCallThreads,
MaximumConcurrentCalls);
ServerMutex.Clear();
if (Status)
{
return(Status);
}
//
// Inform the transport that it can start.
//
RpcAddress->CompleteListen() ;
return(RPC_S_OK);
}
int
RPC_SERVER::AddAddress (
IN RPC_ADDRESS * RpcAddress
)
/*++
Routine Description:
This method is used to add an rpc address to the dictionary of
rpc addresses know about by this rpc server.
Arguments:
RpcAddress - Supplies the rpc address to be inserted into the
dictionary of rpc addresses.
Return Value:
RPC_S_OK - The supplied rpc address has been successfully added
to the dictionary.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to insert
the rpc address into the dictionary.
--*/
{
int Key;
ServerMutex.Request();
Key = RpcAddressDictionary.Insert(RpcAddress);
ServerMutex.Clear();
return(Key);
}
RPC_STATUS
RPC_SERVER::UnregisterIf (
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation OPTIONAL,
IN RPC_UUID PAPI * ManagerTypeUuid OPTIONAL,
IN unsigned int WaitForCallsToComplete
)
/*++
Routine Description:
This method does the work of unregistering an interface from this
rpc server. We actually do not remove the interface; what we do
is to one or all of the manager entry point vector depending upon
the type uuid argument supplied.
Arguments:
RpcInterfaceInformation - Supplies a description of the interface
for which we want to unregister one or all manager entry point
vectors.
ManagerTypeUuid - Optionally supplies the type uuid of the manager
entry point vector to be removed. If this argument is not supplied,
then all manager entry point vectors for this interface will
be removed.
WaitForCallsToComplete - Supplies a flag indicating whether or not
this routine should wait for all calls to complete using the
interface and manager being unregistered. A non-zero value
indicates to wait.
Return Value:
RPC_S_OK - The manager entry point vector(s) are(were) successfully
removed from the specified interface.
RPC_S_UNKNOWN_MGR_TYPE - The specified type uuid is not registered
with the interface.
RPC_S_UNKNOWN_IF - The specified interface is not registered with
the rpc server.
--*/
{
RPC_INTERFACE * RpcInterface;
RPC_STATUS RpcStatus;
RPC_STATUS Status;
int i;
DictionaryCursor cursor;
UNUSED(WaitForCallsToComplete);
if (ARGUMENT_PRESENT(RpcInterfaceInformation))
{
ServerMutex.Request();
RpcInterface = FindInterface(RpcInterfaceInformation);
ServerMutex.Clear();
if (RpcInterface == 0)
return(RPC_S_UNKNOWN_IF);
if (RpcInterface->IsAutoListenInterface())
{
GlobalRpcServer->DecrementAutoListenInterfaceCount() ;
while ( RpcInterface->InqAutoListenCallCount() )
{
RPC_ADDRESS * Address;
ServerMutex.Request();
RpcAddressDictionary.Reset(cursor);
while (0 != (Address = RpcAddressDictionary.Next(cursor)))
{
Address->EncourageCallCleanup(RpcInterface);
}
ServerMutex.Clear();
PauseExecution(500);
}
}
return(RpcInterface->UnregisterManagerEpv(ManagerTypeUuid,
WaitForCallsToComplete));
}
Status = RPC_S_UNKNOWN_MGR_TYPE;
ServerMutex.Request();
RpcInterfaceDictionary.Reset(cursor);
while ((RpcInterface = RpcInterfaceDictionary.Next(cursor)) != 0)
{
// auto-listen intefaces have to be individually unregistered
if (RpcInterface->IsAutoListenInterface())
{
continue;
}
RpcStatus = RpcInterface->UnregisterManagerEpv(ManagerTypeUuid,
WaitForCallsToComplete);
if (RpcStatus == RPC_S_OK)
{
Status = RPC_S_OK;
}
}
ServerMutex.Clear();
return(Status);
}
RPC_STATUS
RPC_SERVER::InquireManagerEpv (
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
IN RPC_UUID PAPI * ManagerTypeUuid, OPTIONAL
OUT RPC_MGR_EPV PAPI * PAPI * ManagerEpv
)
/*++
Routine Description:
This method is used to obtain the manager entry point vector for
an interface supported by this rpc server. A type uuid argument
specifies which manager entry point vector is to be obtained.
Arguments:
RpcInterfaceInformation - Supplies a description of the interface.
ManagerTypeUuid - Optionally supplies the type uuid of the manager
entry point vector we want returned. If no manager type uuid
is specified, then the null uuid is assumed.
ManagerEpv - Returns the manager entry point vector.
Return Value:
RPC_S_OK - The manager entry point vector has successfully been
returned.
RPC_S_UNKNOWN_MGR_TYPE - The specified type uuid is not registered
with the interface.
RPC_S_UNKNOWN_IF - The specified interface is not registered with
the rpc server.
--*/
{
RPC_INTERFACE * RpcInterface;
ServerMutex.Request();
RpcInterface = FindInterface(RpcInterfaceInformation);
ServerMutex.Clear();
if (RpcInterface == 0)
return(RPC_S_UNKNOWN_IF);
return(RpcInterface->InquireManagerEpv(ManagerTypeUuid, ManagerEpv));
}
RPC_STATUS
RPC_SERVER::InquireBindings (
OUT RPC_BINDING_VECTOR PAPI * PAPI * BindingVector
)
/*++
Routine Description:
For each rpc protocol sequence registered with this rpc server
we want to create a binding handle which can be used to make
remote procedure calls using the registered rpc protocol sequence.
We return a vector of these binding handles.
Arguments:
BindingVector - Returns the vector of binding handles.
Return Value:
RPC_S_OK - At least one rpc protocol sequence has been registered
with this rpc server, and the operation completed successfully.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to complete
the operation.
RPC_S_NO_BINDINGS - No rpc protocol sequences have been successfully
registered with this rpc server.
--*/
{
RPC_BINDING_VECTOR PAPI * RpcBindingVector;
unsigned int Index, RpcAddressIndex;
RPC_ADDRESS * RpcAddress;
BINDING_HANDLE * BindingHandle;
int i ;
RPC_CHAR PAPI * LocalNetworkAddress;
int count = 0 ;
DictionaryCursor cursor;
ServerMutex.Request();
if (RpcAddressDictionary.Size() == 0
&& RpcDormantAddresses.IsQueueEmpty())
{
ServerMutex.Clear();
return(RPC_S_NO_BINDINGS);
}
RpcAddressDictionary.Reset(cursor);
while ((RpcAddress = RpcAddressDictionary.Next(cursor)) != 0)
{
count += RpcAddress->InqNumNetworkAddress();
}
RpcBindingVector = (RPC_BINDING_VECTOR PAPI *) RpcpFarAllocate(
sizeof(RPC_BINDING_VECTOR) + (count -1 )
* sizeof(RPC_BINDING_HANDLE) );
if (RpcBindingVector == 0)
{
ServerMutex.Clear();
return(RPC_S_OUT_OF_MEMORY);
}
RpcBindingVector->Count = count;
for (Index = 0; Index < RpcBindingVector->Count; Index++)
RpcBindingVector->BindingH[Index] = 0;
Index = 0;
RpcAddressDictionary.Reset(cursor);
while ((RpcAddress = RpcAddressDictionary.Next(cursor)) != 0)
{
RpcAddressIndex = 0;
LocalNetworkAddress = RpcAddress->
GetListNetworkAddress(RpcAddressIndex) ;
while(LocalNetworkAddress != NULL)
{
BindingHandle = RpcAddress->
InquireBinding(LocalNetworkAddress);
if (BindingHandle == 0)
{
ServerMutex.Clear();
RpcBindingVectorFree(&RpcBindingVector);
return(RPC_S_OUT_OF_MEMORY);
}
RpcBindingVector->BindingH[Index] = BindingHandle;
Index += 1;
RpcAddressIndex += 1;
LocalNetworkAddress = RpcAddress->
GetListNetworkAddress(RpcAddressIndex) ;
}
}
ServerMutex.Clear();
ASSERT(Index == RpcBindingVector->Count);
*BindingVector = RpcBindingVector;
return(RPC_S_OK);
}
RPC_STATUS
RPC_SERVER::RegisterAuthInfoHelper (
IN RPC_CHAR PAPI * ServerPrincipalName,
IN unsigned long AuthenticationService,
IN RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFunction, OPTIONAL
IN void PAPI * Argument OPTIONAL
)
{
RPC_AUTHENTICATION * Service;
RPC_STATUS RpcStatus;
RPC_CHAR __RPC_FAR * PrincipalName;
DictionaryCursor cursor;
if (ServerPrincipalName == NULL)
{
ServerPrincipalName = new RPC_CHAR[1];
if (ServerPrincipalName == NULL)
{
return (RPC_S_OUT_OF_MEMORY);
}
ServerPrincipalName[0] = '\0';
}
if ( AuthenticationService == 0 )
{
return(RPC_S_UNKNOWN_AUTHN_SERVICE);
}
if (AuthenticationService == RPC_C_AUTHN_DEFAULT)
{
RpcpGetDefaultSecurityProviderInfo();
AuthenticationService = DefaultProviderId;
}
ServerMutex.Request();
AuthenticationDictionary.Reset(cursor);
while ( (Service = AuthenticationDictionary.Next(cursor)) != 0 )
{
if ( Service->AuthenticationService == AuthenticationService &&
0 == RpcpStringCompare(Service->ServerPrincipalName, ServerPrincipalName))
{
Service->GetKeyFunction = GetKeyFunction;
Service->Argument = Argument;
ServerMutex.Clear();
// Flush the server-credentials cache
RpcStatus = RemoveCredentialsFromCache(AuthenticationService);
return (RpcStatus);
}
}
RpcStatus = IsAuthenticationServiceSupported(AuthenticationService);
if ( RpcStatus != RPC_S_OK )
{
ServerMutex.Clear();
if ( (RpcStatus == RPC_S_UNKNOWN_AUTHN_SERVICE) ||
(RpcStatus == RPC_S_UNKNOWN_AUTHN_LEVEL) )
{
return (RPC_S_UNKNOWN_AUTHN_SERVICE);
}
else
{
return (RPC_S_OUT_OF_MEMORY);
}
}
Service = new RPC_AUTHENTICATION;
if ( Service == 0 )
{
ServerMutex.Clear();
return(RPC_S_OUT_OF_MEMORY);
}
Service->AuthenticationService = AuthenticationService;
Service->ServerPrincipalName = DuplicateString(ServerPrincipalName);
Service->GetKeyFunction = GetKeyFunction;
Service->Argument = Argument;
if ( Service->ServerPrincipalName == 0 )
{
ServerMutex.Clear();
delete Service;
return(RPC_S_OUT_OF_MEMORY);
}
if ( AuthenticationDictionary.Insert(Service) == -1 )
{
ServerMutex.Clear();
delete Service;
return(RPC_S_OUT_OF_MEMORY);
}
ServerMutex.Clear();
return(RPC_S_OK);
}
RPC_STATUS
RPC_SERVER::AutoRegisterAuthSvc(
IN RPC_CHAR * ServerPrincipalName,
IN unsigned long AuthenticationService
)
{
RPC_STATUS Status;
DictionaryCursor cursor;
RPC_AUTHENTICATION * Service;
//
// Don't need to auto-register the provider if it is already registered
//
ServerMutex.Request();
AuthenticationDictionary.Reset(cursor);
while ( (Service = AuthenticationDictionary.Next(cursor)) != 0 )
{
if ( Service->AuthenticationService == AuthenticationService)
{
ServerMutex.Clear();
return (RPC_S_OK);
}
}
ServerMutex.Clear();
Status = RegisterAuthInfoHelper(ServerPrincipalName,
AuthenticationService,
NULL,
NULL);
if (Status == RPC_S_UNKNOWN_AUTHN_SERVICE)
{
//
// Ok to not register provider if it is disabled
//
return RPC_S_OK;
}
return Status;
}
RPC_STATUS
RPC_SERVER::RegisterAuthInformation (
IN RPC_CHAR PAPI * ServerPrincipalName,
IN unsigned long AuthenticationService,
IN RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFunction, OPTIONAL
IN void PAPI * Argument OPTIONAL
)
/*++
Routine Description:
This method is used to register authentication, authorization, and
a server principal name to be used for security for this server. We
will use this information to authenticate remote procedure calls.
Arguments:
ServerPrincipalName - Supplies the principal name for the server.
AuthenticationService - Supplies an authentication service to use when
the server receives a remote procedure call.
GetKeyFunction - Optionally supplies a routine to be used when the runtime
needs an encryption key.
Argument - Optionally supplies an argument to be passed to the routine used
to get keys each time it is called.
Return Value:
RPC_S_OK - The authentication service and server principal name have
been registered with this RPC server.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to complete the
operation.
RPC_S_UNKNOWN_AUTHN_SERVICE - The specified authentication service is
not supported.
--*/
{
RPC_STATUS Status;
RPC_CHAR *PrincName;
Status = RegisterAuthInfoHelper(ServerPrincipalName,
AuthenticationService,
GetKeyFunction,
Argument);
if (Status != RPC_S_OK)
{
return Status;
}
if (AuthenticationService != RPC_C_AUTHN_GSS_NEGOTIATE)
{
return RPC_S_OK;
}
Status = AutoRegisterAuthSvc(ServerPrincipalName, RPC_C_AUTHN_WINNT);
if (Status != RPC_S_OK)
{
return Status;
}
Status = AutoRegisterAuthSvc(ServerPrincipalName, RPC_C_AUTHN_GSS_KERBEROS);
return Status;
}
RPC_STATUS
RPC_SERVER::AcquireCredentials (
IN unsigned long AuthenticationService,
IN unsigned long AuthenticationLevel,
OUT SECURITY_CREDENTIALS ** SecurityCredentials
)
/*++
Routine Description:
The protocol modules will use this to obtain a set of credentials
for the specified authentication service, assuming that the server
supports them.
Arguments:
AuthenticationService - Supplies the authentication service for which
we hope to obtain credentials.
AuthenticationLevel - Supplies the authentication level to be used.
SecurityCredentials - Returns the security credentials.
Return Value:
RPC_S_OK - You have been given some security credentials, which you need
to free using RPC_SERVER::FreeCredentials when you are done with
them.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to complete the
operation.
RPC_S_UNKNOWN_AUTHN_SERVICE - The specified authentication service is
not supported by the current configuration.
--*/
{
RPC_AUTHENTICATION * Service;
RPC_STATUS RpcStatus = RPC_S_OK;
DictionaryCursor cursor;
ServerMutex.Request();
AuthenticationDictionary.Reset(cursor);
while ( (Service = AuthenticationDictionary.Next(cursor)) != 0 )
{
if ( Service->AuthenticationService == AuthenticationService )
{
ServerMutex.Clear();
RpcStatus = FindServerCredentials(
Service->GetKeyFunction,
Service->Argument,
AuthenticationService,
AuthenticationLevel,
Service->ServerPrincipalName,
SecurityCredentials
);
VALIDATE(RpcStatus)
{
RPC_S_OK,
RPC_S_SEC_PKG_ERROR,
RPC_S_OUT_OF_MEMORY,
RPC_S_INVALID_AUTH_IDENTITY,
ERROR_SHUTDOWN_IN_PROGRESS,
RPC_S_UNKNOWN_AUTHN_SERVICE
} END_VALIDATE;
return(RpcStatus);
}
}
ServerMutex.Clear();
return(RPC_S_UNKNOWN_AUTHN_SERVICE);
}
void
RPC_SERVER::FreeCredentials (
IN SECURITY_CREDENTIALS * SecurityCredentials
)
/*++
Routine Description:
A protocol module will indicate that it is through using a set of
security credentials, obtained from RPC_SERVER::AcquireCredentials,
using this routine.
Arguments:
SecurityCredentials - Supplies the security credentials to be freed.
--*/
{
SecurityCredentials->FreeCredentials();
delete SecurityCredentials;
}
RPC_STATUS
RPC_SERVER::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
)
/*++
Routine Description:
This routine is used by server application to register a manager
entry point vector and optionally an interface. If the interface
has not been registered, then it will be registered. If it has
already been registered, the manager entry point vector will be
added to it under the specified type uuid.
Arguments:
RpcInterfaceInformation - Supplies a description of the interface to
be registered. We will make a copy of this information.
ManagerTypeUuid - Optionally supplies the type uuid for the specified
manager entry point vector. If no type uuid is supplied, then
the null uuid will be used as the type uuid.
ManagerEpv - Optionally supplies a manager entry point vector corresponding
to the type uuid. If a manager entry point vector is not supplied,
then the manager entry point vector in the interface will be
used.
Return Value:
RPC_S_OK - The specified rpc interface has been successfully
registered with the rpc server. It is now ready to accept
remote procedure calls.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to register
the rpc interface with the rpc server.
RPC_S_TYPE_ALREADY_REGISTERED - A manager entry point vector has
already been registered for the supplied rpc interface and
manager type UUID.
--*/
{
RPC_STATUS RpcStatus;
RPC_INTERFACE * RpcInterface;
RPC_ADDRESS *RpcAddress ;
DictionaryCursor cursor;
BOOL fInterfaceFound;
if ( ManagerEpv == 0 )
{
ManagerEpv = RpcInterfaceInformation->DefaultManagerEpv;
if ( (PtrToUlong(ManagerEpv)) == 0xFFFFFFFF)
{
// Stub compiled with -no_default_epv.
return (RPC_S_INVALID_ARG);
}
}
ServerMutex.Request();
RpcInterface = FindOrCreateInterfaceInternal(RpcInterfaceInformation, Flags, MaxCalls,
MaxRpcSize, IfCallbackFn, &RpcStatus, &fInterfaceFound);
if (RpcInterface == NULL)
{
ServerMutex.Clear();
return RpcStatus;
}
if (fInterfaceFound)
{
// if it was found, update the information
RpcStatus = RpcInterface->UpdateRpcInterfaceInformation(RpcInterfaceInformation,
Flags, MaxCalls, MaxRpcSize, IfCallbackFn);
if (RpcStatus != RPC_S_OK)
{
ServerMutex.Clear();
return RpcStatus;
}
}
RpcStatus = RpcInterface->RegisterTypeManager(ManagerTypeUuid, ManagerEpv);
if (Flags & RPC_IF_AUTOLISTEN)
{
RpcAddressDictionary.Reset(cursor);
while ( (RpcAddress = RpcAddressDictionary.Next(cursor)) != 0 )
{
RpcStatus = RpcAddress->ServerStartingToListen(
this->MinimumCallThreads,
MaxCalls);
if (RpcStatus != RPC_S_OK)
{
break;
}
}
}
ServerMutex.Clear();
return(RpcStatus);
}
void RPC_SERVER::CreateOrUpdateAddresses (void)
/*++
Function Name: CreateOrUpdateAddresses
Parameters:
Description:
The runtime just received a notification that a new protocol was loaded. We need
to create an ADDRESS object, listen on it and update the RPCSS bindings
appropriately.
Returns:
--*/
{
RPC_STATUS Status;
RPC_BINDING_VECTOR *BindingVector = 0;
RPC_INTERFACE * RpcInterface;
BOOL fChanged = 0;
RPC_ADDRESS *Address;
QUEUE tempQueue;
BOOL fTempQueueHasContents = FALSE;
int i;
DictionaryCursor cursor;
while (1)
{
unsigned int Length;
ServerMutex.Request();
Address = (RPC_ADDRESS *) RpcDormantAddresses.TakeOffQueue(&Length);
ServerMutex.Clear();
if (Address == 0)
{
break;
}
ASSERT(Length == 0);
if (Address->RestartAddress(MinimumCallThreads,
MaximumConcurrentCalls) != RPC_S_OK)
{
fTempQueueHasContents = TRUE;
if (tempQueue.PutOnQueue(Address, 0) != 0)
{
// putting on the temporary queue failed - out of memory
// in this case we'd rather cut the PnP process for now, and we'll
// go with what we have
// return the address
ServerMutex.Request();
// guaranteed to succeed
RpcDormantAddresses.PutOnQueue(Address, 0);
ServerMutex.Clear();
// break into merging the temp queue with the permanent one
break;
}
}
else
{
fChanged = 1;
}
}
if (fTempQueueHasContents)
{
ServerMutex.Request();
// merge back the queues - this should succeed if we have only added protocols. If we have
// removed protocols, this will fail, and we'll have a bug. Nothing we can do about it here.
RpcDormantAddresses.MergeWithQueue(&tempQueue);
ServerMutex.Clear();
}
if (fChanged)
{
ServerMutex.Request();
//
// Inquire the new bindings, and update them in the endpoint mapper
//
Status = InquireBindings(&BindingVector);
if (Status != RPC_S_OK)
{
goto Cleanup;
}
RpcInterfaceDictionary.Reset(cursor);
while ((RpcInterface = RpcInterfaceDictionary.Next(cursor)) != 0)
{
if (RpcInterface->NeedToUpdateBindings())
{
// we know an interface never gets deleted, only marked as
// unregistered. Therefore, it is safe to release the mutex
// and do the slow UpdateBindings outside the mutex
ServerMutex.Clear();
if ((Status = RpcInterface->UpdateBindings(BindingVector))
!= RPC_S_OK)
{
goto Cleanup;
}
ServerMutex.Request();
}
}
ServerMutex.Clear();
Status = RpcBindingVectorFree(&BindingVector);
ASSERT(Status == RPC_S_OK);
}
return;
Cleanup:
if (BindingVector)
{
Status = RpcBindingVectorFree(&BindingVector);
ASSERT(Status == RPC_S_OK);
}
}
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
)
/*++
Function Name: FindOrCreateInterfaceInternal
Parameters:
RpcInterfaceInformation
Flags
MaxCalls
MaxRpcSize
IfCallbackFn
Status - meaningless if the return value is not NULL.
fInterfaceFound - TRUE if the interface was found, FALSE if it was created
Description:
Find or creates an interface with the appropriate parameters
Returns:
--*/
{
RPC_INTERFACE * RpcInterface;
ServerMutex.VerifyOwned();
RpcInterface = FindInterface(RpcInterfaceInformation);
if ( RpcInterface == 0 )
{
RpcInterface = new RPC_INTERFACE(RpcInterfaceInformation,
this, Flags, MaxCalls, MaxRpcSize, IfCallbackFn, Status);
if ( RpcInterface == 0 )
{
*Status = RPC_S_OUT_OF_MEMORY;
return NULL;
}
if ( AddInterface(RpcInterface) != 0 )
{
delete RpcInterface;
*Status = RPC_S_OUT_OF_MEMORY;
return NULL;
}
if (Flags & RPC_IF_AUTOLISTEN)
{
GlobalRpcServer->IncrementAutoListenInterfaceCount() ;
}
*fInterfaceFound = FALSE;
}
else
{
*fInterfaceFound = TRUE;
}
*Status = RPC_S_OK;
return RpcInterface;
}
RPC_INTERFACE *
RPC_SERVER::FindOrCreateInterface (
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
OUT RPC_STATUS *Status
)
{
RPC_INTERFACE * RpcInterface;
BOOL fIgnored;
ServerMutex.Request();
RpcInterface = FindOrCreateInterfaceInternal(RpcInterfaceInformation,
RPC_IF_ALLOW_SECURE_ONLY, 0, gMaxRpcSize, NULL, Status, &fIgnored);
ServerMutex.Clear();
return RpcInterface;
}
RPC_STATUS
RPC_SERVER::InterfaceExported (
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
IN UUID_VECTOR *MyObjectUuidVector,
IN unsigned char *MyAnnotation,
IN BOOL MyfReplace
)
/*++
Function Name:InterfaceExported
Parameters:
Description:
RpcEpRegister was called on this interface. We need to keep track
of the parameters, so that if we get a PNP notification, we can update
the bindings using there params
Returns:
--*/
{
RPC_INTERFACE * RpcInterface;
RPC_STATUS Status;
RpcInterface = FindOrCreateInterface (RpcInterfaceInformation, &Status);
if (RpcInterface == NULL)
{
return Status;
}
return RpcInterface->InterfaceExported(
MyObjectUuidVector,
MyAnnotation,
MyfReplace);
}
#if !defined(NO_LOCATOR_CODE)
RPC_STATUS
RPC_SERVER::NsInterfaceExported (
IN unsigned long EntryNameSyntax,
IN RPC_CHAR *EntryName,
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
IN BOOL fUnexport
)
{
RPC_INTERFACE * RpcInterface;
RPC_STATUS Status;
HMODULE hLocator;
if (pNsBindingExport == 0)
{
hLocator = LoadLibrary ((const RPC_SCHAR *)RPC_CONST_STRING("rpcns4.dll"));
if (hLocator == 0)
{
return RPC_S_OUT_OF_MEMORY;
}
pNsBindingExport = (NS_EXPORT_FUNC) GetProcAddress(hLocator,
"RpcNsBindingExportW");
if (pNsBindingExport == 0)
{
return RPC_S_OUT_OF_MEMORY;
}
pNsBindingUnexport = (NS_UNEXPORT_FUNC) GetProcAddress(hLocator,
"RpcNsBindingUnexportW");
if (pNsBindingUnexport == 0)
{
pNsBindingExport = 0;
return RPC_S_OUT_OF_MEMORY;
}
}
RpcInterface = FindOrCreateInterface (RpcInterfaceInformation, &Status);
if (RpcInterface == NULL)
{
return Status;
}
if (fUnexport == 0)
{
return RpcInterface->NsInterfaceExported(
EntryNameSyntax,
EntryName);
}
else
{
return RpcInterface->NsInterfaceUnexported(
EntryNameSyntax,
EntryName);
}
}
#endif
RPC_STATUS
RPC_SERVER::EnumerateAndCallEachAddress (
IN AddressCallbackType actType,
IN OUT void *Context OPTIONAL
)
/*++
Function Name: DestroyContextHandlesForInterface
Parameters:
actType - the type of callback.
Context - opaque memory block to be passed to the callback.
Description:
This function is called when we want to invoke a specific method
on each address.
Returns:
RPC_S_OK for success or RPC_S_* for error
--*/
{
RPC_ADDRESS_DICT AddressDict;
RPC_ADDRESS_DICT *AddressDictToUse;
RPC_ADDRESS *CurrentAddress;
BOOL UsingAddressDictionaryCopy;
int Result;
DictionaryCursor cursor;
DestroyContextHandleCallbackContext *ContextHandleContext;
// try to copy all entries in the address dictionary to the local
// dictionary. We will walk the address list from there to avoid
// holding the server mutex while walking potentially large tree.
// If we do that, only the page faults will be enough to kill the
// server. On the other hand, we can't rely that the memory will be
// there. Therefore, we attempt to copy the dictionary under the
// mutex, but if this fails, we will retain the mutex and go ahead
// with the cleanup. The logic behind this is that if we don't have
// the few bytes to copy the dictionary, probably the server isn't
// doing anything, and holding the mutex won't hurt it anymore
ServerMutex.Request();
#if DBG
if (actType == actDestroyContextHandle)
{
RPC_INTERFACE *Interface;
ContextHandleContext = (DestroyContextHandleCallbackContext *)Context;
Interface = FindInterface(ContextHandleContext->RpcInterfaceInformation);
ASSERT(Interface);
// the interface must use strict context handles
ASSERT(Interface->DoesInterfaceUseNonStrict() == FALSE);
}
#endif
UsingAddressDictionaryCopy = AddressDict.ExpandToSize(RpcAddressDictionary.Size());
if (UsingAddressDictionaryCopy)
{
AddressDictToUse = &AddressDict;
RpcAddressDictionary.Reset(cursor);
while ( (CurrentAddress = RpcAddressDictionary.Next(cursor)) != 0 )
{
// we never destroy addresses. Therefore, we don't need to mark
// those addresses as used in any way
Result = AddressDict.Insert(CurrentAddress);
// this must succeed as we have reserved enough size
ASSERT(Result != -1);
}
ServerMutex.Clear();
}
else
{
AddressDictToUse = &RpcAddressDictionary;
}
// N.B. We may, or may not have the ServerMutex here - depending on how
// we were doing with memory
AddressDictToUse->Reset(cursor);
while ( (CurrentAddress = AddressDictToUse->Next(cursor)) != 0 )
{
switch (actType)
{
case actDestroyContextHandle:
ContextHandleContext = (DestroyContextHandleCallbackContext *)Context;
CurrentAddress->DestroyContextHandlesForInterface(
ContextHandleContext->RpcInterfaceInformation,
ContextHandleContext->RundownContextHandles
);
break;
case actCleanupIdleSContext:
CurrentAddress->CleanupIdleSContexts();
break;
default:
ASSERT(0);
}
}
if (!UsingAddressDictionaryCopy)
{
ServerMutex.Clear();
}
return RPC_S_OK;
}
RPC_STATUS
RPC_ENTRY
I_RpcNsInterfaceExported (
IN unsigned long EntryNameSyntax,
IN unsigned short *EntryName,
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation
)
{
#if !defined(NO_LOCATOR_CODE)
InitializeIfNecessary();
return (GlobalRpcServer->NsInterfaceExported(
EntryNameSyntax,
EntryName,
RpcInterfaceInformation, 0));
#else
return RPC_S_CANNOT_SUPPORT;
#endif
}
RPC_STATUS
RPC_ENTRY
I_RpcNsInterfaceUnexported (
IN unsigned long EntryNameSyntax,
IN unsigned short *EntryName,
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation
)
{
#if !defined(NO_LOCATOR_CODE)
InitializeIfNecessary();
return (GlobalRpcServer->NsInterfaceExported(
EntryNameSyntax,
EntryName,
RpcInterfaceInformation, 1));
#else
return RPC_S_CANNOT_SUPPORT;
#endif
}
#define MAXIMUM_CACHED_THREAD_TIMEOUT (1000L * 60L * 60L)
void
BaseCachedThreadRoutine (
IN CACHED_THREAD * CachedThread
)
/*++
Routine Description:
Each thread will execute this routine. When it first gets called, it
will immediately call the procedure and parameter specified in the
cached thread object. After that it will wait on its event and then
execute the specified routine everytime it gets woken up. If the wait
on the event times out, the thread will exit unless it has been protected.
Arguments:
CachedThread - Supplies the cached thread object to be used by this
thread.
--*/
{
RPC_SERVER * RpcServer = CachedThread->OwningRpcServer;
THREAD *pThread = RpcpGetThreadPointer();
long WaitTimeout;
ASSERT(pThread);
while (pThread->ThreadHandle() == (void *) -1)
{
Sleep(1);
}
ASSERT(pThread->ThreadHandle());
CachedThread->SetThread(pThread);
if (pThread->DebugCell)
{
pThread->DebugCell->TID = (unsigned short)GetCurrentThreadId();
pThread->DebugCell->LastUpdateTime = NtGetTickCount();
}
for(;;)
{
if (CachedThread->CallProcedure())
{
#ifdef RPC_OLD_IO_PROTECTION
// This thread has already timed-out waiting on
// a transport level cache. Let it go now...
ASSERT(pThread->InqProtectCount() == 1);
#endif
if (pThread->IsIOPending() == FALSE)
{
delete CachedThread;
return;
}
// we're a cached IOCP thread - we need to unjoin the IOCP
UnjoinCompletionPort();
}
WaitTimeout = gThreadTimeout;
// Now we cache this thread. This consists of clearing the
// work available flag and inserting the thread cache object into
// the list thread cache objects.
CachedThread->WorkAvailableFlag = WorkIsNotAvailable;
RpcServer->ThreadCacheMutex.Request();
RpcServer->InsertIntoFreeList(CachedThread);
RpcServer->ThreadCacheMutex.Clear();
// Now we loop waiting for work. We get out of the loop in three
// ways: (1) a timeout occurs and there is work to do, (2) the
// event gets kicked because there is work to do, (3) a timeout
// occurs, there is no work to do, and the thread is not protected.
for (;;)
{
// Ignore spurious signals.
while( (CachedThread->WaitForWorkEvent.Wait(WaitTimeout) == 0)
&& (CachedThread->WorkAvailableFlag == WorkIsNotAvailable) )
;
if (CachedThread->WorkAvailableFlag == WorkIsAvailable)
{
break;
}
// We must take the lock to avoid a race condition where another
// thread is trying to signal us right now.
RpcServer->ThreadCacheMutex.Request();
if (CachedThread->WorkAvailableFlag)
{
RpcServer->ThreadCacheMutex.Clear();
break;
}
if (pThread->IsIOPending())
{
// If we reach here, there is no work available, and the thread
// is protected. We just need to wait again. There is no need to
// busy wait if the thread is protected and it keeps timing out.
if (WaitTimeout < MAXIMUM_CACHED_THREAD_TIMEOUT/2)
{
WaitTimeout = WaitTimeout * 2;
}
// Since this thread can't exit anyway, move it to the front of the
// free list so it will be reused first.
RpcServer->RemoveFromFreeList(CachedThread);
RpcServer->InsertIntoFreeList(CachedThread);
RpcServer->ThreadCacheMutex.Clear();
continue;
}
// No work available.
#ifdef RPC_OLD_IO_PROTECTION
ASSERT(pThread->InqProtectCount() == 1);
#endif
// There is no work available, and this thread is not
// protected, so we can safely let it commit suicide.
RpcServer->RemoveFromFreeList(CachedThread);
RpcServer->ThreadCacheMutex.Clear();
delete CachedThread;
return;
}
ASSERT(CachedThread->WorkAvailableFlag == WorkIsAvailable);
}
NO_RETURN;
}
RPC_STATUS
RPC_SERVER::CreateThread (
IN THREAD_PROC Procedure,
IN void * Parameter
)
/*++
Routine Description:
This routine is used to create a new thread which will begin
executing the specified procedure. The procedure will be passed
parameter as the argument.
Arguments:
Procedure - Supplies the procedure which the new thread should
begin executing.
Parameter - Supplies the argument to be passed to the procedure.
Return Value:
RPC_S_OK - We successfully created a new thread and started it
executing the supplied procedure.
RPC_S_OUT_OF_THREADS - We could not create another thread.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to allocate
the data structures we need to complete this operation.
--*/
{
THREAD * Thread;
CACHED_THREAD * CachedThread;
RPC_STATUS RpcStatus = RPC_S_OK;
ThreadCacheMutex.Request();
CachedThread = RemoveHeadFromFreeList();
if (CachedThread)
{
// set all parameters within the mutex to avoid races
CachedThread->SetWakeUpThreadParams(Procedure, Parameter);
ThreadCacheMutex.Clear();
CachedThread->WakeUpThread();
return(RPC_S_OK);
}
ThreadCacheMutex.Clear();
if (IsServerSideDebugInfoEnabled())
{
RpcStatus = InitializeServerSideCellHeapIfNecessary();
if (RpcStatus != RPC_S_OK)
return RpcStatus;
}
CachedThread = new CACHED_THREAD(Procedure, Parameter, this, &RpcStatus);
if ( CachedThread == 0 )
{
return(RPC_S_OUT_OF_MEMORY);
}
if ( RpcStatus != RPC_S_OK )
{
delete CachedThread;
return(RpcStatus);
}
ASSERT( RpcStatus == RPC_S_OK );
Thread = new THREAD((THREAD_PROC) BaseCachedThreadRoutine, CachedThread,
&RpcStatus);
if (Thread == 0)
{
delete CachedThread;
return(RPC_S_OUT_OF_THREADS);
}
if (RpcStatus != RPC_S_OK)
{
delete CachedThread;
delete Thread;
if (RpcStatus == ERROR_MAX_THRDS_REACHED)
RpcStatus = RPC_S_OUT_OF_THREADS;
}
return(RpcStatus);
}
RPC_STATUS
RPC_SERVER::InquireInterfaceIds (
OUT RPC_IF_ID_VECTOR __RPC_FAR * __RPC_FAR * InterfaceIdVector
)
/*++
Routine Description:
This routine is used to obtain a vector of the interface identifiers of
the interfaces supported by this server.
Arguments:
IfIdVector - Returns a vector of the interfaces supported by this server.
Return Value:
RPC_S_OK - Everything worked out just great.
RPC_S_NO_INTERFACES - No interfaces have been registered with the runtime.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to allocate
the interface id vector.
--*/
{
DictionaryCursor cursor;
ServerMutex.Request();
if (RpcInterfaceDictionary.Size() == 0)
{
ServerMutex.Clear();
*InterfaceIdVector = 0;
return RPC_S_NO_INTERFACES;
}
*InterfaceIdVector = (RPC_IF_ID_VECTOR __RPC_FAR *) RpcpFarAllocate(
sizeof(RPC_IF_ID_VECTOR) + (RpcInterfaceDictionary.Size() - 1)
* sizeof(RPC_IF_ID __RPC_FAR *));
if ( *InterfaceIdVector == 0 )
{
ServerMutex.Clear();
return(RPC_S_OUT_OF_MEMORY);
}
(*InterfaceIdVector)->Count = 0;
(*InterfaceIdVector)->IfId[0] = (RPC_IF_ID __RPC_FAR *) RpcpFarAllocate(
sizeof(RPC_IF_ID));
RpcInterfaceDictionary.Reset(cursor);
RPC_INTERFACE * RpcInterface;
while ((RpcInterface = RpcInterfaceDictionary.Next(cursor)) != 0)
{
(*InterfaceIdVector)->IfId[(*InterfaceIdVector)->Count] =
RpcInterface->InquireInterfaceId();
if ( (*InterfaceIdVector)->IfId[(*InterfaceIdVector)->Count] != 0 )
{
RPC_IF_ID * Interface = (*InterfaceIdVector)->IfId[(*InterfaceIdVector)->Count];
(*InterfaceIdVector)->Count += 1;
}
}
ServerMutex.Clear();
if (0 == (*InterfaceIdVector)->Count)
{
RpcpFarFree(*InterfaceIdVector);
*InterfaceIdVector = 0;
return RPC_S_NO_INTERFACES;
}
return(RPC_S_OK);
}
RPC_STATUS
RPC_SERVER::InquirePrincipalName (
IN unsigned long AuthenticationService,
OUT RPC_CHAR __RPC_FAR * __RPC_FAR * ServerPrincipalName
)
/*++
Routine Description:
Arguments:
Return Value:
RPC_S_OK - The operation completed successfully.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to complete the
operation.
RPC_S_UNKNOWN_AUTHN_SERVICE - The specified authentication service is
not supported.
--*/
{
RPC_AUTHENTICATION * Service;
DictionaryCursor cursor;
ServerMutex.Request();
AuthenticationDictionary.Reset(cursor);
while ( (Service = AuthenticationDictionary.Next(cursor)) != 0 )
{
if ( Service->AuthenticationService == AuthenticationService )
{
ServerMutex.Clear();
*ServerPrincipalName = DuplicateString(
Service->ServerPrincipalName);
if ( *ServerPrincipalName == 0 )
{
return(RPC_S_OUT_OF_MEMORY);
}
return(RPC_S_OK);
}
}
ServerMutex.Clear();
return(RPC_S_UNKNOWN_AUTHN_SERVICE);
}
void
RPC_SERVER::RegisterRpcForwardFunction (
RPC_FORWARD_FUNCTION * pForwardFunction
)
/*++
Routine Description:
Sets the RPC_SERVER pEpmapperForwardFunction. (The pEpmapperForwardFunction
is the function the runtime can call when it receives a pkt for a
dynamic endpoint. pEpmapperForwardFunction will return endpoint of
the server to forward the pkt to).
Arguments:
pForwardFunction - pointer to the epmapper forward function.
Return Value:
none
--*/
{
pRpcForwardFunction = pForwardFunction;
}
RPC_STATUS
RPC_SERVER::UnregisterEndpoint (
IN RPC_CHAR __RPC_FAR * Protseq,
IN RPC_CHAR __RPC_FAR * Endpoint
)
{
return (RPC_S_CANNOT_SUPPORT);
}
RPC_ADDRESS::RPC_ADDRESS (
IN OUT RPC_STATUS PAPI * RpcStatus
) : AddressMutex(RpcStatus,
TRUE // pre-allocate semaphore
)
/*++
Routine Description:
We just need to initialization some stuff to zero. That way if we
later have to delete this address because of an error in initialization
we can tell what instance variables need to be freed.
--*/
{
NetworkAddress = 0;
Endpoint = 0;
RpcProtocolSequence = 0;
}
RPC_ADDRESS::~RPC_ADDRESS (
)
/*++
Routine Description:
This routine will only get called if part way through initialization
an error occurs. We just need to free up any memory used by instance
variables. Once FireUpManager has been called and succeeds, the
address will never be destroyed.
--*/
{
if (Endpoint != 0)
delete Endpoint;
if (RpcProtocolSequence != 0)
delete RpcProtocolSequence;
}
RPC_CHAR *
RPC_ADDRESS::GetListNetworkAddress (
IN unsigned int Index
)
/*++
Routine Description:
A pointer to the network address for this address is returned.
--*/
{
if (Index >= pNetworkAddressVector->Count)
{
return (NULL);
}
return(pNetworkAddressVector->NetworkAddresses[Index]);
}
RPC_STATUS
RPC_ADDRESS::CopyDescriptor (
IN void *SecurityDescriptor,
OUT void **OutDescriptor
)
{
BOOL b;
SECURITY_DESCRIPTOR_CONTROL Control;
DWORD Revision;
DWORD BufferLength;
if ( IsValidSecurityDescriptor(SecurityDescriptor) == FALSE )
{
return(RPC_S_INVALID_SECURITY_DESC);
}
if (FALSE == GetSecurityDescriptorControl(SecurityDescriptor, &Control, &Revision))
{
return(RPC_S_INVALID_SECURITY_DESC);
}
if (Control & SE_SELF_RELATIVE)
{
//
// Already self-relative, just copy it.
//
BufferLength = GetSecurityDescriptorLength(SecurityDescriptor);
ASSERT(BufferLength >= sizeof(SECURITY_DESCRIPTOR));
*OutDescriptor = RpcpFarAllocate(BufferLength);
if (*OutDescriptor == 0)
{
return(RPC_S_OUT_OF_MEMORY);
}
memcpy(*OutDescriptor, SecurityDescriptor, BufferLength);
return(RPC_S_OK);
}
//
// Make self-relative and copy it.
//
BufferLength = 0;
b = MakeSelfRelativeSD(SecurityDescriptor, 0, &BufferLength);
ASSERT(b == FALSE);
if ( GetLastError() != ERROR_INSUFFICIENT_BUFFER )
{
return(RPC_S_INVALID_SECURITY_DESC);
}
ASSERT(BufferLength >= sizeof(SECURITY_DESCRIPTOR_RELATIVE));
*OutDescriptor = RpcpFarAllocate(BufferLength);
if (*OutDescriptor == 0)
{
return(RPC_S_OUT_OF_MEMORY);
}
b = MakeSelfRelativeSD(SecurityDescriptor,
*OutDescriptor,
&BufferLength);
if (b == FALSE)
{
ASSERT(GetLastError() != ERROR_INSUFFICIENT_BUFFER);
delete *OutDescriptor;
return(RPC_S_OUT_OF_MEMORY);
}
return(RPC_S_OK);
}
RPC_STATUS
RPC_ADDRESS::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,
IN NETWORK_ADDRESS_VECTOR *pNetworkAddressVector
)
/*++
Routine Description:
We just need to set some instance variables of this rpc address.
Arguments:
Endpoint - Supplies the endpoint for this rpc address.
RpcProtocolSequence - Supplies the rpc protocol sequence for this
rpc address.
Server - Supplies the rpc server which owns this rpc address.
StaticEndpointFlag - Supplies a flag which specifies whether this
address has a static endpoint or a dynamic endpoint.
--*/
{
RPC_STATUS Status;
this->NetworkAddress = NetworkAddress;
this->Endpoint = Endpoint;
this->RpcProtocolSequence = RpcProtocolSequence;
this->pNetworkAddressVector = pNetworkAddressVector;
this->Server = Server;
this->StaticEndpointFlag = StaticEndpointFlag;
this->PendingQueueSize = PendingQueueSize;
this->EndpointFlags = EndpointFlags;
this->NICFlags = NICFlags;
if (SecurityDescriptor)
{
Status = CopyDescriptor(SecurityDescriptor,
&this->SecurityDescriptor);
if (Status != RPC_S_OK)
{
return Status;
}
}
return RPC_S_OK;
}
RPC_STATUS
RPC_ADDRESS::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
)
/*++
Routine Description:
This method is used to determine if a client bind request can be
accepted or not. All we have got to do here is hand off to the
server which owns this address.
Arguments:
InterfaceIdentifier - Supplies the syntax identifier for the
interface; this is the interface uuid and version.
ProposedTransferSyntaxes - Supplies a list of one or more transfer
syntaxes which the client initiating the binding supports. The
server should pick one of these which is supported by the
interface.
NumberOfTransferSyntaxes - Supplies the number of transfer syntaxes
specified in the proposed transfer syntaxes argument.
AcceptedTransferSyntax - Returns the transfer syntax which the
server accepted.
RpcInterface - Returns a pointer to the rpc interface found which
supports the requested interface and one of the requested transfer
syntaxes.
Return Value:
RPC_S_OK - The requested interface exists and it supports at least
one of the proposed transfer syntaxes. We are all set, now we
can make remote procedure calls.
RPC_P_UNSUPPORTED_TRANSFER_SYNTAX - The requested interface exists,
but it does not support any of the proposed transfer syntaxes.
RPC_P_UNSUPPORTED_INTERFACE - The requested interface is not supported
by this rpc server.
--*/
{
return Server->FindInterfaceTransfer(
InterfaceIdentifier,
ProposedTransferSyntaxes,
NumberOfTransferSyntaxes,
AcceptedTransferSyntax,
RpcInterface,
fIsInterfaceTransferPreferred,
ProposedTransferSyntaxIndex,
AvailableTransferSyntaxIndex);
}
BINDING_HANDLE *
RPC_ADDRESS::InquireBinding (
RPC_CHAR * LocalNetworkAddress
)
/*++
Routine Description:
We need to return create and return a binding handle which can
be used by a client to make remote procedure calls to this rpc
address.
Return Value:
A newly created binding handle will be returned, inless an out
of memory error occurs, in which case zero will be returned.
--*/
{
RPC_STATUS Status;
DCE_BINDING * DceBinding;
BINDING_HANDLE * BindingHandle;
RPC_CHAR * DynamicEndpoint = 0;
RPC_CHAR * PAPI * tmpPtr;
if(LocalNetworkAddress == 0)
{
LocalNetworkAddress = pNetworkAddressVector->NetworkAddresses[0];
}
DceBinding = new DCE_BINDING(
0,
RpcProtocolSequence,
LocalNetworkAddress,
(StaticEndpointFlag != 0 ? Endpoint : 0),
0,
&Status);
if ((DceBinding == 0)
|| (Status != RPC_S_OK))
{
delete DceBinding;
return(0);
}
if (StaticEndpointFlag == 0)
{
DynamicEndpoint = DuplicateString(Endpoint);
if (DynamicEndpoint == 0)
{
delete DceBinding;
return(0);
}
}
BindingHandle = new SVR_BINDING_HANDLE(DceBinding, DynamicEndpoint, &Status);
if (BindingHandle == 0)
{
delete DceBinding;
}
return(BindingHandle);
}
RPC_STATUS
RPC_ADDRESS::ServerStartingToListen (
IN unsigned int MinimumCallThreads,
IN unsigned int MaximumConcurrentCalls
)
/*++
Routine Description:
This method will be called for each address when the server starts
listening. In addition, if an address is added while the server is
listening, then this method will be called. The purpose of the method
is to notify the address about the minimum number of call threads
required; the maximum concurrent calls can safely be ignored, but it
can be used to set an upper bound on the number of call threads.
Arguments:
MinimumCallThreads - Supplies a number indicating the minimum number
of call threads which should be created for this address.
MaximumConcurrentCalls - Supplies the maximum number of concurrent
calls which this server will support.
Return Value:
RPC_S_OK - This routine will always return this value. Protocol
support modules may return other values.
--*/
{
UNUSED(MinimumCallThreads);
UNUSED(MaximumConcurrentCalls);
return(RPC_S_OK);
}
void
RPC_ADDRESS::ServerStoppedListening (
)
/*++
Routine Description:
This routine will be called to notify an address that the server has
stopped listening for remote procedure calls. Each protocol module
may override this routine; it is safe not too, but not as efficient.
Note that this routine will be called before all calls using the
server have been allowed to complete.
--*/
{
}
long
RPC_ADDRESS::InqNumberOfActiveCalls (
)
/*++
Return Value:
Each protocol module will define this routine. We will use this
functionality when the server has stopped listening and is waiting
for all remote procedure calls to complete. The number of active calls
for the address will be returned.
--*/
{
return(ActiveCallCount);
}
RPC_STATUS
RPC_ADDRESS::RestartAddress (
IN unsigned int MinThreads,
IN unsigned int MaxCalls
)
{
RPC_STATUS Status;
int Key;
Status = ServerSetupAddress(
NetworkAddress,
&Endpoint,
PendingQueueSize,
SecurityDescriptor,
EndpointFlags,
NICFlags,
&pNetworkAddressVector);
if (Status != RPC_S_OK)
{
pNetworkAddressVector = NULL;
return Status;
}
Key = Server->AddAddress(this);
if (Key == -1)
{
return RPC_S_OUT_OF_MEMORY;
}
Server->ServerMutex.Request();
Status = ServerStartingToListen(MinThreads, MaxCalls);
Server->ServerMutex.Clear();
if (Status != RPC_S_OK)
{
return Status;
}
CompleteListen();
return RPC_S_OK;
}
void
RPC_ADDRESS::DestroyContextHandlesForInterface (
IN RPC_SERVER_INTERFACE PAPI * ,
IN BOOL
)
/*++
Function Name: DestroyContextHandlesForInterface
Parameters:
RpcInterfaceInformation - the interface for which context handles
are to be unregistered
RundownContextHandles - if non-zero, rundown the context handles. If
FALSE, destroy the runtime portion of the context handle resource,
but don't call the user rundown routine.
Description:
Each protocol engine will implement its own version of this routine,
if it supports the feature. For those who don't, this routine provides
default no-op behaviour
Returns:
--*/
{
}
void
RPC_ADDRESS::CleanupIdleSContexts (
void
)
/*++
Function Name: CleanupIdleSContexts
Parameters:
Description:
Each protocol engine will implement its own version of this routine,
if it supports the feature. For those who don't, this routine provides
default no-op behaviour
Returns:
--*/
{
}
/*====================================================================
SCONNECTION
==================================================================== */
RPC_STATUS
SetThreadSecurityContext(
SECURITY_CONTEXT * Context
)
/*++
Routine Description:
RpcImpersonateClient() takes a handle_t, so many threads can impersonate
the client of a single SCONNECTION. RPC needs to record which context
each thread is using. It is logical to place this in the TLS, but threads
not created by RPC lack the THREAD structure in their TLS. This wrapper
function will store the security context in the TLS if available, or
place the context in a dictionary if not.
Arguments:
Context - the security context to associate with this thread
Return Value:
RPC_S_OK if successful
RPC_S_OUT_OF_MEMORY if the dictionary insertion failed
--*/
{
THREAD * ThreadInfo = ThreadSelf();
if (ThreadInfo)
{
ThreadInfo->SecurityContext = Context;
return RPC_S_OK;
}
return RPC_S_OUT_OF_MEMORY;
}
SECURITY_CONTEXT *
QueryThreadSecurityContext(
)
/*++
Routine Description:
Fetches the security context associated with this thread for this
connection. We check the TLS if available; if nothing is there
then we scan the connection's dictionary.
Arguments:
none
Return Value:
the associated security context, or zero if none is found
--*/
{
THREAD * ThreadInfo = ThreadSelf();
if (ThreadInfo)
{
if (ThreadInfo->SecurityContext)
{
return (SECURITY_CONTEXT *) ThreadInfo->SecurityContext;
}
}
return 0;
}
SECURITY_CONTEXT *
ClearThreadSecurityContext(
)
/*++
Routine Description:
Clears the association between this thread and its security context
for this connection.
Arguments:
none
Return Value:
the formerly associated security context, or zero if none was found
--*/
{
THREAD * ThreadInfo = ThreadSelf();
if (ThreadInfo)
{
SECURITY_CONTEXT * Context =
(SECURITY_CONTEXT *) ThreadInfo->SecurityContext;
if (Context)
{
ThreadInfo->SecurityContext = 0;
return Context;
}
}
return 0;
}
RPC_STATUS
SCALL::ImpersonateClient (
)
// This routine just returns RPC_CANNOT_SUPPORT indicating that this
// particular connection does not support impersonation.
{
ASSERT(0 && "improper SCALL member called\n");
return(RPC_S_CANNOT_SUPPORT);
}
RPC_STATUS
SCALL::RevertToSelf (
)
// We always return RPC_CANNOT_SUPPORT indicating that the particular
// connection does not support impersonation.
{
ASSERT(0 && "improper SCALL member called\n");
return(RPC_S_CANNOT_SUPPORT);
}
void
NDRSContextHandlePostDispatchProcessing (
IN SCALL *SCall,
ServerContextHandle *CtxHandle
);
void
SCALL::DoPostDispatchProcessing (
void
)
{
DictionaryCursor cursor;
ServerContextHandle *CtxHandle;
ServerContextHandle *RetrievedCtxHandle;
int Key;
// the list will contain all in-only context
// handles, as they don't get marshalled. It will also
// contain the marshalling buffers for the newly
// created context handles
if (ActiveContextHandles.Size() > 0)
{
// no need to synchronize access to the
// dictionary - only this call will be
// touching it
ActiveContextHandles.Reset(cursor);
while ((CtxHandle = ActiveContextHandles.NextWithKey(cursor, &Key)) != 0)
{
// ignore buffers
if ((ULONG_PTR)CtxHandle & SCALL::DictionaryEntryIsBuffer)
{
RetrievedCtxHandle = ActiveContextHandles.Delete(Key);
ASSERT(RetrievedCtxHandle == CtxHandle);
continue;
}
// NDRSContextHandlePostDispatchProcessing will remove the context handle
// from the dictionary - this doesn't interfere with our
// enumeration
NDRSContextHandlePostDispatchProcessing(this,
CtxHandle
);
}
}
}
RPC_STATUS
SCONNECTION::IsClientLocal (
OUT unsigned int PAPI * ClientLocalFlag
)
/*++
Routine Description:
The connection oriented protocol module will override this method;
all other protocol modules should just use this routine. We need this
support so that the security system can tell if a client is local or
remote.
Arguments:
ClientLocalFlag - Returns an indication of whether or not the client is
local (ie. on the same machine as the server). This field will be
set to a non-zero value to indicate that the client is local;
otherwise, the client is remote.
Return Value:
RPC_S_CANNOT_SUPPORT - This will always be used.
--*/
{
UNUSED(ClientLocalFlag);
ASSERT(0 && "improper SCALL member called\n");
return(RPC_S_CANNOT_SUPPORT);
}
RPC_STATUS
SCALL::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
)
/*++
Routine Description:
Creates an Authz context from token. If saving is requested, it
tries to save it in a thread-safe manner and duplicates it before
returning. If saving is not requested, the resulting authz context
is simply returned. In both cases caller owns the returned auth
context.
Arguments:
pAuthzClientContextPlaceholder - contains a pointer to an authz placeholder.
If NULL, out of the ImpersonationToken an authz context will
be made and will be returned. If non-NULL, it must contain
NULL. In this case an authz context will be created from the token,
and it will be stored in the placeholder in a thread safe manner and a
duplicate will be made and returned in pAuthzClientContext.
ImpersonationToken - the impersonation token to use.
AuthzResourceManager - authz parameters (not interpreted)
pExpirationTime - authz parameters (not interpreted)
Identifier - authz parameters (not interpreted)
Flags - authz parameters (not interpreted)
DynamicGroupArgs - authz parameters (not interpreted)
pAuthzClientContext - contains the output authz context on success
Return Value:
Win32 error code. EEInfo has been added.
--*/
{
RPC_STATUS Status = RPC_S_OK;
BOOL Result;
AUTHZ_CLIENT_CONTEXT_HANDLE AuthzClientContext;
Result = AuthzInitializeContextFromTokenFn(
Flags,
ImpersonationToken,
AuthzResourceManager,
pExpirationTime,
Identifier,
DynamicGroupArgs,
&AuthzClientContext);
if (!Result)
{
Status = GetLastError();
RpcpErrorAddRecord(EEInfoGCAuthz,
Status,
EEInfoDLSCALL__CreateAndSaveAuthzContextFromToken10,
GetCurrentThreadId(),
(ULONGLONG)AuthzResourceManager);
return Status;
}
if (pAuthzClientContextPlaceholder)
{
if (InterlockedCompareExchangePointer((PVOID *)pAuthzClientContextPlaceholder,
AuthzClientContext,
NULL) != NULL)
{
// somebody beat us to the punch - free the context we obtained
AuthzFreeContextFn(AuthzClientContext);
// use the context that has been provided
AuthzClientContext = *pAuthzClientContextPlaceholder;
}
Status = DuplicateAuthzContext(AuthzClientContext,
pExpirationTime,
Identifier,
Flags,
DynamicGroupArgs,
pAuthzClientContext);
if (Status)
{
// EEInfo has already been added
return Status;
}
}
else
{
*pAuthzClientContext = AuthzClientContext;
}
return Status;
}
RPC_STATUS
SCALL::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
)
/*++
Routine Description:
Take an Authz context, and make a duplicate of it, using the
specified parameters. This method is a wrapper for
AuthzInitializeContextFromContext, mainly adding error handling.
Arguments:
AuthzClientContext - source authz context
pExpirationTime - authz parameters (not interpreted)
Identifier - authz parameters (not interpreted)
Flags - authz parameters (not interpreted)
DynamicGroupArgs - authz parameters (not interpreted)
pAuthzClientContext - target authz context pointer
Return Value:
Win32 error code.
--*/
{
RPC_STATUS Status;
BOOL Result;
// Copy the authz context. We must do a copy,
// to avoid lifetime issues b/n our copy
// and the client copy
Result = AuthzInitializeContextFromAuthzContextFn(
Flags,
AuthzClientContext,
pExpirationTime,
Identifier,
DynamicGroupArgs,
pAuthzClientContext);
if (!Result)
{
Status = GetLastError();
RpcpErrorAddRecord(EEInfoGCAuthz,
Status,
EEInfoDLSCALL__DuplicateAuthzContext10,
GetCurrentThreadId(),
(ULONGLONG)AuthzClientContext);
}
else
Status = RPC_S_OK;
return Status;
}
/* ====================================================================
ASSOCIATION_HANDLE :
==================================================================== */
static long AssociationIdCount = 0L;
void
DestroyContextCollection (
IN ContextCollection *CtxCollection
);
ASSOCIATION_HANDLE::ASSOCIATION_HANDLE (
void
)
{
CtxCollection = NULL;
AssociationID = InterlockedIncrement(&AssociationIdCount);
}
ASSOCIATION_HANDLE::~ASSOCIATION_HANDLE (
)
// We finally get to use the rundown routines for somethings. The association
// is being deleted which is the event that the rundown routines were waiting
// for.
{
FireRundown();
}
// Returns the context handle collection for this association.
RPC_STATUS
ASSOCIATION_HANDLE::GetAssociationContextCollection (
ContextCollection **CtxCollectionPlaceholder
)
/*++
Function Name: GetAssociationContextCollection
Parameters:
CtxCollectionPlaceholder - a placeholder where to put the pointer to
the context collection.
Description:
The context handle code will call the SCALL to get the collection
of context handles for this association. The SCALL method will
simply delegate to this.
This routine will check if the context handle collection was created
and if so, it will just return it. If it wasn't created, it will try
to create it.
Returns:
RPC_S_OK for success or RPC_S_* for error.
--*/
{
RPC_STATUS RpcStatus;
if (CtxCollection)
{
*CtxCollectionPlaceholder = CtxCollection;
return RPC_S_OK;
}
RpcStatus = NDRSContextInitializeCollection(&CtxCollection);
if (RpcStatus != RPC_S_OK)
return RpcStatus;
*CtxCollectionPlaceholder = CtxCollection;
return RpcStatus;
}
void
ASSOCIATION_HANDLE::FireRundown (
void
)
{
int nRetries = 20;
RPC_STATUS status;
if (CtxCollection)
{
// make a best effort to make sure there is another listening thread
// besides this one. If we repeatedly fail, we fire the rundown
// anyway - currently few servers use outgoing RPC callbacks into the
// same process, so we'd rather risk an unlikely deadlock than cause
// a sure leak
while (nRetries > 0)
{
status = CreateThread();
if (status == RPC_S_OK)
break;
Sleep(10);
nRetries --;
}
DestroyContextCollection(CtxCollection);
if (status == RPC_S_OK)
RundownNotificationCompleted();
}
}
// do nothing in the base case
RPC_STATUS ASSOCIATION_HANDLE::CreateThread(void)
{
return RPC_S_OK;
}
void ASSOCIATION_HANDLE::RundownNotificationCompleted(void)
{
}
void
ASSOCIATION_HANDLE::DestroyContextHandlesForInterface (
IN RPC_SERVER_INTERFACE PAPI * RpcInterfaceInformation,
IN BOOL RundownContextHandles
)
/*++
Function Name: DestroyContextHandlesForInterface
Parameters:
RpcInterfaceInformation - the interface for which context handles
are to be unregistered
RundownContextHandles - if non-zero, rundown the context handles. If
FALSE, destroy the runtime portion of the context handle resource,
but don't call the user rundown routine.
Description:
The association will call into NDR to destroy the specified context
handles. It will either have a reference on the association, or the
association mutex. Both ways, we're safe from destruction, and NDR
will synchronize access to the list internally. The address has made
a best effort not to hold the association mutex. If memory is low,
it may end up doing so, however.
Returns:
--*/
{
ContextCollection *LocalCtxCollection;
void *pGuard;
// N.B. An association mutex may be held on entry for this
// function. The server mutex may be held as well
LocalCtxCollection = CtxCollection;
// shortcut the common path
if (!LocalCtxCollection)
return;
pGuard = &RpcInterfaceInformation->InterfaceId;
// call into NDR to destroy the context handles
DestroyContextHandlesForGuard(LocalCtxCollection,
RundownContextHandles,
pGuard);
}
/* ====================================================================
Routine to initialize the server DLL.
==================================================================== */
int
InitializeServerDLL (
)
{
GetMaxRpcSizeAndThreadPoolParameters();
if (InitializeClientDLL() != 0)
return(1);
#if 0
if (InitializeSTransports() != 0)
return(1);
#endif
if (InitializeObjectDictionary() != 0)
return(1);
if (InitializeRpcServer() != 0)
return(1);
if (InitializeRpcProtocolLrpc() != 0)
return(1);
return(0);
}
#if DBG
void
RpcpInterfaceForCallDoesNotUseStrict (
IN RPC_BINDING_HANDLE BindingHandle
)
{
SCALL *SCall;
if (((MESSAGE_OBJECT *)BindingHandle)->Type(SCALL_TYPE))
{
SCall = (SCALL *)BindingHandle;
SCall->InterfaceForCallDoesNotUseStrict();
}
}
#endif
RPC_STATUS
InqLocalConnAddress (
IN SCALL *SCall,
IN OUT void *Buffer,
IN OUT unsigned long *BufferSize,
OUT unsigned long *AddressFormat
)
/*++
Routine Description:
This routine is used by a server application to inquire about the local
address on which a call is made.
Arguments:
Binding - Supplies a valid server binding. The binding must have been
verified to be an SCALL by the caller.
Buffer - The buffer that will receive the output address
BufferSize - the size of the supplied Buffer on input. On output the
number of bytes written to the buffer. If the buffer is too small
to receive all the output data, ERROR_MORE_DATA is returned,
nothing is written to the buffer, and BufferSize is set to
the size of the buffer needed to return all the data.
AddressFormat - a constant indicating the format of the returned address.
Currently supported are RPC_P_ADDR_FORMAT_TCP_IPV4 and
RPC_P_ADDR_FORMAT_TCP_IPV6.
Return Values:
RPC_S_OK - success.
RPC_S_OUT_OF_MEMORY - Insufficient memory is available to complete this
operation.
RPC_S_INVALID_BINDING - The supplied client binding is invalid.
RPC_S_CANNOT_SUPPORT - The local address was inquired for a protocol
sequence that doesn't support this type of functionality. Currently
only ncacn_ip_tcp supports it.
RPC_S_* or Win32 error for other errors
--*/
{
// is this an osf scall?
if (!SCall->InvalidHandle(OSF_SCALL_TYPE))
{
OSF_SCALL *OsfSCall;
OsfSCall = (OSF_SCALL *)SCall;
return OsfSCall->InqLocalConnAddress(
Buffer,
BufferSize,
AddressFormat);
}
else if (!SCall->InvalidHandle(DG_SCALL_TYPE))
{
// this is a dg call
DG_SCALL *DgSCall;
DgSCall = (DG_SCALL *)SCall;
return DgSCall->InqLocalConnAddress(
Buffer,
BufferSize,
AddressFormat);
}
else
{
// the others don't support it
return RPC_S_CANNOT_SUPPORT;
}
}
Reference in a new issue Copy permalink