able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/com/rpc/runtime/mtrt/rpctrans.hxx
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

2437 lines
56 KiB
C++
Raw Permalink Blame History

/*++
Copyright (C) Microsoft Corporation, 1996 - 1999
Module Name:
RpcTrans.hxx
Abstract:
Interface to transport (network protocol) used by the RPC runtime.
Each protocol supported by RPC must implement this interface.
Environment:
User mode Windows NT, Windows 95 and PPC Macintosh.
Author:
Mario Goertzel [MarioGo]
Revision History:
MarioGo 10/22/1996 Based on old, sync transport interface
EdwardR 07/09/1997 Added support for message transports (Falcon).
--*/
#ifndef __RPC_TRANS_HXX
#define __RPC_TRANS_HXX
// The runtime and transport DLL must share the same version number
const unsigned short RPC_TRANSPORT_INTERFACE_VERSION = 0x2004;
#if defined(_RPCRT4_) && !defined(_RPCTRANS_)
typedef PVOID BUFFER;
#else
typedef PUCHAR BUFFER;
#endif
//
// When an IO completes an event it returned to the runtime.
// Usually it will be one of connection/datagram | one of client/server
// | one of send/receive. Example CONNECTION|SERVER|SEND indicates
// that a send completed on a server-side connection.
//
//
typedef UINT RPC_TRANSPORT_EVENT;
const UINT CONNECTION = 0x0;
const UINT DATAGRAM = 0x1;
const UINT CLIENT = 0x0;
const UINT SERVER = 0x4;
const UINT SEND = 0x0;
const UINT RECEIVE = 0x8;
// there is some subtle namespace partitioning here. Complex_T will
// be used only by HTTP2's connections, which we know are not
// datagram or address. Therefore, the values 17 and 18, used
// as RuntimePosted and NewAddress do not conflict with Complex_T
// connections
const UINT COMPLEX_T = 0x10;
// Internal to transport - these bits should not be
// set in any events which reach the RPC runtime.
const UINT TRANSPORT = 0x10;
const UINT ADDRESS = 0x2;
// Masks for switching on a given event flag
const UINT PROTO_MASK = 0x0003;
const UINT TYPE_MASK = 0x0004;
const UINT IO_MASK = 0x0008;
// Event posted by the RPC runtime via POST_EVENT
// and the context is whatever context the runtime
// passed into POST_EVENT
const UINT RuntimePosted = 0x11;
const UINT NewAddress = 0x12;
const UINT LastRuntimeConstant = COMPLEX_T | SERVER | RECEIVE;
// Predefine events - these are the only combinations
// that the transport interface can return.
const UINT ConnectionServerReceive = CONNECTION | SERVER | RECEIVE;
const UINT ConnectionServerSend = CONNECTION | SERVER | SEND;
const UINT ConnectionClientReceive = CONNECTION | CLIENT | RECEIVE;
const UINT ConnectionClientSend = CONNECTION | CLIENT | SEND;
const UINT DatagramServerReceive = DATAGRAM | SERVER | RECEIVE;
const UINT DatagramServerSend = DATAGRAM | SERVER | SEND;
const UINT DatagramClientReceive = DATAGRAM | CLIENT | RECEIVE;
const UINT DatagramClientSend = DATAGRAM | CLIENT | SEND;
// Protocol or Endpoint ID's. These are associated with
// the endpoint entry in the tower and are what the runtime
// sees last before calling the transport interface.
const INT TCP_TOWER_ID = 0x07; // TCP/IP protocol
const INT UDP_TOWER_ID = 0x08; // UDP/IP protocol
const INT LRPC_TOWER_ID = 0x09; // Used for debugging only - never goes
// on the wire or in any tower. We just
// use this number to be able to uniquely
// identify all protocols with a single
// number.
const INT CDP_TOWER_ID = 0x00; // CDP/IP protocol
#ifdef SPX_ON
const INT SPX_TOWER_ID = 0x0C; // Netware SPX protocol
#endif
#ifdef IPX_ON
const INT IPX_TOWER_ID = 0x0E; // Netware IPX protocol
#endif
const INT NMP_TOWER_ID = 0x0F; // Microsoft (SMB) named pipes
#ifdef NETBIOS_ON
const INT NB_TOWER_ID = 0x12; // Netbios protocol
#endif
#ifdef APPLETALK_ON
const INT DSP_TOWER_ID = 0x16; // Appletalk datastream protocol
const INT DDP_TOWER_ID = 0x17; // Appletalk datagram protocol
#endif
//const INT SPP_TOWER_ID = 0x1A; // Banyan stream protocol - no longer supported
#ifdef NCADG_MQ_ON
const INT MQ_TOWER_ID = 0x1D; // Falcon protocol
#endif
const INT HTTP_TOWER_ID = 0x1F; // HTTP protocol
extern "C" {
typedef void (*RUNTIME_EVENT_FN)(PVOID Context);
typedef RPC_STATUS
(RPC_ENTRY * PROCESS_CALLS)
(
IN INT Timeout,
OUT RPC_TRANSPORT_EVENT *pEvent,
OUT RPC_STATUS *pEventStatus,
OUT PVOID *ppEventContext,
OUT UINT *pBufferLength,
OUT BUFFER *pBuffer,
OUT PVOID *ppSourceContext
);
/*++
Routine Description:
This routine waits for any async IO to complete for all protocols
within a transport DLL. It maybe called by multiple threads at a
time. A minimum of one thread should always be calling this function
for each DLL.
Note: async clients with no outstanding IO may allow the
last thread to timeout and only call this function again
when a new call is started.
Note: During calls to this API in connection oriented servers
a callback to I_RpcTransServerNewConnection() may occur.
Arguments:
Timeout - Milliseconds to block or INFINITE (-1)
pEvent - Indicates what sort of IO event has completed (finished)
pEventStatus - Indicates the status of the IO event.
RPC_S_OK - IO completed normally
RPC_P_RECEIVE_FAILED - Some kind of receive failed.
RPC_P_SEND_FAILED - CO_SEND failed and the connection has been aborted.
RPC_P_OVERSIZED_PACKET - Datagram received a packet that was larger
then the buffer size. (Partial datagram in buffer).
RPC_P_ENDPOINT_CLOSED - ASync datagram client endpoint closed.
RPC_P_CONNECTION_CLOSED - Transport closed a connection due
to some internal resource issue.
ppEventContext -
An RPC_TRANSPORT_CONNECTION object for all Connection events
An RPC_TRANSPORT_ENDPOINT for Datagram receive events.
pBuffer - Will contain the sent or received buffer
pBufferLength - The size of the data sent/received in pBuffer
ppSourceContext - For connection sends this is SendContext parameter
passed into the Send() call.
For datagram this is the sources address (DG_TRANSPORT_ADDRESS)
of the packet.
Return Value:
RPC_S_OK - IO completed successfully or with an error. See pEventStatus.
RPC_P_TIMEOUT - Timeout period expired no IP completed.
--*/
typedef VOID
(RPC_ENTRY * LISTEN_FOR_PNP_NOTIFICATIONS)
(
);
typedef VOID
(RPC_ENTRY * START_PNP_NOTIFICATIONS)
(
);
typedef RPC_STATUS
(RPC_ENTRY *TOWER_CONSTRUCT)
(
IN PCHAR Protseq,
IN PCHAR NetworkAddress,
IN PCHAR Endpoint,
OUT PUSHORT Floors,
OUT PULONG ByteCount,
OUT PUCHAR *Tower
);
/*++
Routine Description:
Constructs a OSF tower for the protocol, network address and endpoint.
Arguments:
Protseq - The protocol for the tower.
NetworkAddress - The network address to be encoded in the tower.
Endpoint - The endpoint to be encoded in the tower.
Floors - The number of twoer floors it encoded into the tower.
ByteCount - The size of the "upper-transport-specific" tower that
is encoded by this call.
Tower - The encoded "upper tower" that is encoded by this call.
This caller is responsible for freeing this memory.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
--*/
typedef RPC_STATUS
(RPC_ENTRY *TOWER_EXPLODE)
(
IN PUCHAR Tower,
OUT PCHAR *Protseq,
OUT PCHAR *NetworkAddress,
OUT PCHAR *Endpoint
);
/*++
Routine Description:
Decodes an OSF transport "upper tower" for the runtime.
Arguments:
Tower - The encoded "upper tower" to decode
Protseq - The protseq encoded in the Tower
Does not need to be freed by the caller.
NetworkAddress - The network address encoded in the Tower
Must be freed by the caller.
Endpoint - The endpoint encoded in the Tower.
Must be freed by the caller.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY
--*/
typedef RPC_STATUS
(RPC_ENTRY *POST_EVENT)
(
IN DWORD Type,
IN PVOID Context
);
/*++
Routine Description:
Posts an event to the completion port. This will complete
with an event type of RuntimePosted, event status RPC_S_OK
and event context of Context.
Arguments:
Context - Context associated with the event
Return Value:
RPC_S_OK
RPC_S_OUT_OF_RESOURCES
RPC_S_OUT_OF_MEMORY
--*/
} // extern "C"
// This is the "base class" for each of the two types of transport
// interfaces, connection and datagram. Each transport interface DLL
// supports these common function and has only one implementation of
// the ProcessCalls method.
//
// NOTE: Any changes here MUST also be made in BOTH the datagram and connection
// specific transport interface definitions.
struct RPC_TRANSPORT_INTERFACE_HEADER
{
UINT TransInterfaceVersion; // Compiled in version
USHORT TransId; // OSF DCE Tower ID for the protocol (eg TCP)
USHORT TransAddrId; // OSF DCE Tower ID for the address format (eg IP)
const RPC_CHAR *ProtocolSequence; // DCE RPC Protseq
const PCHAR WellKnownEndpoint; // Well known endpoint mapper endpoint
PROCESS_CALLS ProcessCalls;
#ifndef NO_PLUG_AND_PLAY
START_PNP_NOTIFICATIONS PnpNotify;
LISTEN_FOR_PNP_NOTIFICATIONS PnpListen;
#endif
TOWER_CONSTRUCT TowerConstruct;
TOWER_EXPLODE TowerExplode;
POST_EVENT PostEvent ;
BOOL fDatagram;
};
//
// Connection specific interface
//
typedef HANDLE RPC_TRANSPORT_CONNECTION; // Server or client connection
typedef HANDLE RPC_TRANSPORT_ADDRESS; // Server listening object
extern "C" {
typedef RPC_STATUS
(RPC_ENTRY *CO_CLIENT_INITIALIZE)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN RPC_CHAR * NetworkAddress,
IN RPC_CHAR * NetworkOptions,
IN BOOL fAsync
);
typedef void
(RPC_ENTRY *CO_CLIENT_INITCOMPLETE)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection
);
typedef RPC_STATUS
(RPC_ENTRY *CO_CLIENT_OPEN)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN RPC_CHAR * ProtocolSequence,
IN RPC_CHAR * NetworkAddress,
IN RPC_CHAR * Endpoint,
IN RPC_CHAR * NetworkOptions,
IN UINT ConnTimeout,
IN UINT SendBufferSize,
IN UINT RecvBufferSize,
IN OUT PVOID ResolverHint,
IN BOOL fHintInitialized,
IN ULONG CallTimeout,
IN ULONG AdditionalTransportCredentialsType, OPTIONAL
IN void *AdditionalCredentials OPTIONAL
);
/*++
Routine Description:
Opens a new client connection to the server specified.
Arguments:
ThisConnection - Pointer to uninitialzied memory large enough
for the transports connection object. Used in future
calls on the same connection.
ProtocolSequence -
NetworkAddress -
Endpoint -
NetworkOptions - (Optional)
ConnTimeout - connection timeout in runtime units
SendBufferSize -
RecvBufferSize - (Both optional) Specifies the size of the send/recv
transport buffers (or window).
ResolverHint - storage (of ResolveHintSize in the interface) for transport.
state.
fHintInitialize - If TRUE, the ResolveHint has previous passed into
open and the runtime wants to connect to the same server as it
connected to the first time.
If FALSE, the ResolveHint is not initialized and the runtime is
willing to connect to any server.
CallTimeout - the call timeout in milliseconds
TransportCredentials - optional transport credentials
Return Value:
RPC_S_OK - Success
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
RPC_S_INVALID_NETWORK_OPTIONS
RPC_S_SERVER_UNAVAILABLE
RPC_S_INVALID_ENDPOINT_FORMAT
RPC_S_ACCESS_DENIED
RPC_S_CALL_CANCELLED
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_ABORT)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection
);
/*++
Routine Description:
This is the first step is destroying a client or server connection.
This can be called at most once on any connection. Call this function
guarantees that all outstanding IO on the connection will complete
either successfully or with an error.
Note: Sometimes when a transport call fails it will abort the connection.
Arguments:
ThisConnection - The connection to abort.
Return Value:
RPC_S_OK
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_CLOSE)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN BOOL fDontFlush
);
/*++
Routine Description:
Closes a connection which has not outstanding IO pending on it.
This must be exactly once on every connection opened.
If a connection has outstanding IO then call Abort() and wait
for the IO to fail.
Arguments:
ThisConnection - The connection to cleanup.
Return Value:
RPC_S_OK
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_SEND)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN UINT Length,
IN BUFFER Buffer,
IN PVOID SendContext
);
/*++
Routine Description:
Submits a send of the buffer on the connection. Will complete with
ConnectionServerSend or ConnectionClientSend event either when
the data has been sent on the network or when the send fails.
Arguments:
ThisConnection - The connection to send the data on.
Length - The length of the data to send.
Buffer - The data to send.
SendContext - A buffer of at least SendContextSize bytes
which will be used during the call and returned
when the send completes.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY - Connection valid
RPC_S_OUT_OF_RESOURCES - Connection valid
RPC_P_SEND_FAILED - Connection aborted
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_RECV)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection
);
/*++
Routine Description:
Submits a receive on the connection. Will complete with a
ConnectionServerReceive or ConnectionClientReceive event
either when a PDU arrives or when the receive fails.
Arguments:
ThisConnection - The connection to wait on.
Return Value:
RPC_P_IO_PENDING - Success
RPC_P_RECEIVE_FAILED - Connection aborted.
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_SYNC_SEND)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN UINT Length,
IN BUFFER Buffer,
IN BOOL fDisableShutdownCheck,
IN BOOL fDisableCancelCheck,
IN ULONG Timeout
);
/*++
Routine Description:
Transmits the buffer (PDU) to the other side of the connection. May
block while the data is transmitted.
Arguments:
ThisConnection - The connection to send the data on.
Length - The length of the data to send.
Buffer - The data to send.
fDisableShutdownCheck - Normally FALSE, when true this disables
the transport check for async shutdown PDUs. This is needed
when sending the third leg.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY - Connection valid
RPC_S_OUT_OF_RESOURCES - Connection valid
RPC_P_SEND_FAILED - Connection aborted
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_CLIENT_SYNC_SEND_RECV)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN UINT InputBufferSize,
IN BUFFER InputBuffer,
OUT PUINT OutputBufferSize,
OUT BUFFER *pOutputBuffer
);
/*++
Routine Description:
Sends a request to the server of the connection and waits for
a reply. This is the same as calling CO_SYNC_SEND followed
by CO_SYNC_RECV but might be faster. It is assumed that if
this function is available from the transport it will always
be used.
Arguments:
ThisConnection - The client connection to transfer the data on.
InputBufferSize - The size in bytes of the data in InputBuffer
InputBuffer - The data to send to the server
OutputBufferSize - On output, the size of the reply message.
pOutputBuffer - On output, the reply PDU.
Return Value:
RPC_S_OK - Success
RPC_P_SEND_FAILED - Connection aborted, no data transmitted.
RPC_P_RECEIVE_FAILED - Connection aborted, data may have been transmitted.
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_CLIENT_SYNC_RECV)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
OUT BUFFER *pBuffer,
OUT PUINT pBufferSize,
IN ULONG Timeout
);
/*++
Routine Description:
Receive the next PDU to arrive at the connection.
Arguments:
ThisConnection - The connection to read from.
pBuffer - If successful, points to a buffer containing the next PDU.
pBufferSize - If successful, contains the length of the message.
dwTimeout - the amount of time to wait for the receive. If -1, we wait
infinitely.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY - Connection not aborted, no data received.
RPC_S_OUT_OF_RESOURCES - Connection not aborted, no data received.
RPC_P_RECEIVE_FAILED - Connection aborted.
RPC_P_CONNECTION_SHUTDOWN - Graceful close from server, connection aborted.
RPC_S_CALL_CANCELLED - Cancel event signaled and wait timed out; connection aborted.
--*/
// Keepalive timeout can be specified either in the RPC's runtime scale
// of a relative time from 0 to 10 (for the client) or as the number of
// milliseconds between keepalive packets (for the server).
enum KEEPALIVE_TIMEOUT_UNITS
{
tuMilliseconds,
tuRuntime
};
union KEEPALIVE_TIMEOUT
{
ULONG Milliseconds;
ULONG RuntimeUnits;
};
typedef RPC_STATUS
(RPC_ENTRY *CO_TURN_ON_OFF_KEEPALIVES)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN BOOL TurnOn,
IN BOOL bProtectIO,
IN KEEPALIVE_TIMEOUT_UNITS Units,
IN OUT KEEPALIVE_TIMEOUT KATime,
IN ULONG KAInterval = 5000 OPTIONAL
);
/*++
Routine Description:
Turns on or off keep alives at a rate appropriate for that transport. Used
to prevent hangs of async calls.
Arguments:
ThisConnection - The connection to turn keep alives on on.
TurnOn - if non-zero, keep alives are turned on. If zero, keep alives
are turned off.
bProtectIO - Determines whether the setting the timeout will be protected with
a call to StartingOtherIO. TRUE on the server, FALSE on the client.
Units - is the itmeout specified in the relative scale or in milliseconds
KATime - how much to wait before sending first keep alive
KAInterval - the keepalive interval
Return Value:
RPC_S_OK or RPC_S_* / Win32 errors on failure
--*/
typedef void
(RPC_ENTRY *CO_FREE_RESOLVER_HINT)
(
IN void *ResolverHint
);
/*++
Routine Description:
Gives the transport a chance to free any data associated with the resolver hint.
Arguments:
ResolverHint - pointer to the resolver hint
Return Value:
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_COPY_RESOLVER_HINT)
(
IN void *TargetResolverHint,
IN void *SourceResolverHint,
IN BOOL SourceWillBeAbandoned
);
/*++
Routine Description:
Tells the transport to copy the resolver hint from Source to Target
Arguments:
TargetResolverHint - pointer to the target resolver hint
SourceResolverHint - pointer to the source resolver hint
SourceWillBeAbandoned - non-zero if the source hint was in temporary
location and will be abandoned. Zero otherwise.
Return Value:
if SourceWillBeAbandoned is specified, this function is guaranteed
to return RPC_S_OK. Otherwise, it may return RPC_S_OUT_OF_MEMORY as well.
--*/
typedef int
(RPC_ENTRY *CO_COMPARE_RESOLVER_HINT)
(
IN void *ResolverHint1,
IN void *ResolverHint2
);
/*++
Routine Description:
Tells the transport to compare the given 2 resolver hints
Arguments:
ResolverHint1 - pointer to the first resolver hint
ResolverHint2 - pointer to the second resolver hint
Return Value:
(same semantics as memcmp)
0 - the resolver hints are equal
non-zero - the resolver hints are not equal
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_SET_LAST_BUFFER_TO_FREE)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN void *Buffer
);
/*++
Routine Description:
Before the last send runtime may call this to tell the transport
what buffer to free when the send is done.
Arguments:
ThisConnection - connection to act on.
Buffer - the buffer to free
Return Value:
RPC_S_OK - the value was accepted.
RPC_S_CANNOT_SUPPORT - the transport doesn't support this functionality.
If this value is returned, ownership of the buffer remains with the
transport.
--*/
#pragma warning(disable:4200) // nonstandard extension: zero-length array
typedef struct
{
UINT Count;
RPC_CHAR *NetworkAddresses[];
} NETWORK_ADDRESS_VECTOR;
#pragma warning(3:4200) // nonstandard extension: zero-length array
#define MAX_PROTOCOLS 16
typedef RPC_STATUS
(RPC_ENTRY *CO_SERVER_LISTEN)
(
IN RPC_TRANSPORT_ADDRESS ThisAddress,
IN RPC_CHAR *NetworkAddress,
IN OUT RPC_CHAR **ppEndpoint,
IN UINT PendingQueueSize,
IN OPTIONAL PVOID SecurityDescriptor,
IN ULONG EndpointFlags,
IN ULONG NICFlags,
OUT NETWORK_ADDRESS_VECTOR **ppNetworkAddressVector
);
/*++
Routine Description:
This routine allocates a transport endpoint (port/socket/pipe) to
receive new client connections on. If successful a call to
CompleteListen() will cause new connection callbacks to the
RPC runtime for the newly created address.
Arguments:
ThisAddress - A pointer to uninitialized memory large enough to
hold the transport address object.
pEndpoint - The endpoint to listen on. Pointer to NULL for
dynamic endpoints. Does not need to be freed by the
RPC runtime.
PendingQueueSize - A hint passed into the RPC runtime as the
MaxCalls parameter to RpcServerUse*Protseq*(). It is intended
as a hint in buffer allocations for new connections.
SecurityDescriptor - NT security descriptor passed into
RpcServerUseProtseq*. Optional, only by named pipes.
EndpointFlags - Application flags passed into RPC via
RpcServerUseProtseq*Ex.
NICFlags - Application flags passed into RPC via
RpcServerUseProtseq*Ex.
ppNetworkAddressVector - A vector of network addresses listened
to by the call. This parameter does not need to freed, will
not and should not be changed.
Return Value:
RPC_S_OK - Success
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
RPC_S_INVALID_ENDPOINT_FORMAT
RPC_S_INVALID_SECURITY_DESC
RPC_S_CANT_CREATE_ENDPOINT
--*/
typedef void
(RPC_ENTRY *CO_SERVER_ABORT_LISTEN)
(
IN RPC_TRANSPORT_ADDRESS ThisAddress
);
/*++
Routine Description:
Destroys on a newly, successfully created RPC_TRANS_ADDRESS which
for some reason known only to the runtime will not be used.
Arguments:
ThisAddress - The address to destroy.
Return Value:
Must succeed.
--*/
typedef void
(RPC_ENTRY *CO_SERVER_COMPLETE_LISTEN)
(
IN RPC_TRANSPORT_ADDRESS ThisAddress
);
/*++
Routine Description:
Called when the runtime is actually ready for new connection
callbacks to start on the address. This call cannot fail since
the runtime can't undo the operation at this point.
Arguments:
ThisAddress - The address the runtime is now ready to receive
connections on.
Return Value:
Must succeed.
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_SERVER_QUERY_ADDRESS)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
OUT RPC_CHAR **pClientAddress
);
/*++
Routine Description:
Returns the raw network address of the client to the connection.
Arguments:
ThisConnection - A server connection object.
pClientAddress - Pointer to a unicode string allocated
via I_RpcAllocate from the transport interface.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_SERVER_QUERY_LOCAL_ADDRESS)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN OUT void *Buffer,
IN OUT unsigned long *BufferSize,
OUT unsigned long *AddressFormat
);
/*++
Routine Description:
Returns the raw local network address of the connection.
Arguments:
ThisConnection - A server connection object.
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 Value:
RPC_S_OK, ERROR_MORE_DATA, RPC_S_* or Win32 error codes.
--*/
const int RPC_CLIENT_PROCESS_IDENTIFIER_ULONGLONG_ARRAY_SIZE = 0x10;
const int RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE = 0x20;
class RPC_CLIENT_PROCESS_IDENTIFIER
{
public:
inline void
Set (
IN RPC_CLIENT_PROCESS_IDENTIFIER *ClientProcess
);
inline void
ZeroOut (
void
);
inline int
Compare (
IN RPC_CLIENT_PROCESS_IDENTIFIER *ClientProcess
);
inline BOOL
IsNull (
void
);
inline ULONGLONG
GetDebugULongLong1 (
void
);
inline ULONGLONG
GetDebugULongLong2 (
void
);
inline ULONG
GetDebugULong1 (
void
);
inline ULONG
GetDebugULong2 (
void
);
inline BOOL
IsLocal (
void
);
// defined in wstrans.cxx to avoid general runtime dependency on
// IPv6 headers
void
SetIPv6ClientIdentifier (
IN void *Buffer,
IN size_t BufferSize,
IN BOOL fLocal
);
inline void
SetIPv4ClientIdentifier (
IN ULONG Addr,
IN BOOL fLocal
);
void
SetHTTP2ClientIdentifier (
IN void *Buffer,
IN size_t BufferSize,
IN BOOL fLocal
);
inline void
SetNMPClientIdentifier (
IN FILE_PIPE_CLIENT_PROCESS_BUFFER *ClientId,
IN BOOL fLocal
);
inline void
SetIPXClientIdentifier (
IN void *Buffer,
IN size_t BufferSize,
IN BOOL fLocal
);
private:
BOOL fLocal;
BOOL ZeroPadding; // if member wise initialization is done,
// this must be set to 0. This allows callers
// to call memcmp for the whole object.
// provide storage for 0x80 bytes. This is the max client id
// (the client id of an IPv6 client address)
union
{
ULONGLONG ULongLongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONGLONG_ARRAY_SIZE];
ULONG ULongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE];
} u;
};
void
RPC_CLIENT_PROCESS_IDENTIFIER::Set (
IN RPC_CLIENT_PROCESS_IDENTIFIER *ClientProcess
)
/*++
Routine Description:
Initialize the client process identifier from another client
process identifier
Arguments:
ClientProcess - a pointer to the other client process
Return Value:
--*/
{
RpcpMemoryCopy(this, ClientProcess, sizeof(RPC_CLIENT_PROCESS_IDENTIFIER));
}
void
RPC_CLIENT_PROCESS_IDENTIFIER::ZeroOut (
void
)
/*++
Routine Description:
Zero out a RPC_CLIENT_PROCESS_IDENTIFIED.
Arguments:
Return Value:
--*/
{
RpcpMemorySet(this, 0, sizeof(RPC_CLIENT_PROCESS_IDENTIFIER));
}
int
RPC_CLIENT_PROCESS_IDENTIFIER::Compare (
IN RPC_CLIENT_PROCESS_IDENTIFIER *ClientProcess
)
/*++
Routine Description:
Compare two RPC_CLIENT_PROCESS_IDENTIFIED structs.
Arguments:
ClientProcess - a pointer to the ClientProcess ID to compare to
Return Value:
non-zero - the Client Process Ids are different.
0 - the Client process Ids are the same
--*/
{
return RpcpMemoryCompare(this, ClientProcess, sizeof(RPC_CLIENT_PROCESS_IDENTIFIER));
}
BOOL
RPC_CLIENT_PROCESS_IDENTIFIER::IsNull (
void
)
/*++
Routine Description:
Utility function to check whether the ClientId portion is NULL.
N.B. the function does not check for the fLocal flag!
Arguments:
Return Value:
TRUE - the ClientId of the ClientProcess is all zeroes.
FALSE - at least one element of the ClientId is non-zero
--*/
{
int i;
#if defined(_WIN64)
for (i = 0; i < RPC_CLIENT_PROCESS_IDENTIFIER_ULONGLONG_ARRAY_SIZE; i ++)
{
if (u.ULongLongClientId[i] != 0)
return FALSE;
}
#else
for (i = 0; i < RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE; i ++)
{
if (u.ULongClientId[i] != 0)
return FALSE;
}
#endif
return TRUE;
}
ULONGLONG
RPC_CLIENT_PROCESS_IDENTIFIER::GetDebugULongLong1 (
void
)
/*++
Routine Description:
Returns the first ULONGLONG from the ClientProcess identifier
Used for debugging.
Arguments:
Return Value:
the value used for debugging
--*/
{
return u.ULongLongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONGLONG_ARRAY_SIZE - 2];
}
ULONGLONG
RPC_CLIENT_PROCESS_IDENTIFIER::GetDebugULongLong2 (
void
)
/*++
Routine Description:
Returns the second ULONGLONG from the ClientProcess identifier
Used for debugging.
Arguments:
Return Value:
the value used for debugging
--*/
{
return u.ULongLongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONGLONG_ARRAY_SIZE - 1];
}
ULONG
RPC_CLIENT_PROCESS_IDENTIFIER::GetDebugULong1 (
void
)
/*++
Routine Description:
Returns the first ULONG from the ClientProcess identifier
Used for debugging.
Arguments:
Return Value:
the value used for debugging
--*/
{
return u.ULongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE - 2];
}
ULONG
RPC_CLIENT_PROCESS_IDENTIFIER::GetDebugULong2 (
void
)
/*++
Routine Description:
Returns the second ULONG from the ClientProcess identifier
Used for debugging.
Arguments:
Return Value:
the value used for debugging
--*/
{
return u.ULongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE - 1];
}
void
RPC_CLIENT_PROCESS_IDENTIFIER::SetIPv4ClientIdentifier (
IN ULONG Addr,
IN BOOL fLocal
)
/*++
Routine Description:
IPv4 servers can use this to store their IP address in
the client identifier.
Arguments:
Addr - IPv4 address
fLocal - TRUE if the client is guaranteed to be Local. False otherwise.
Return Value:
--*/
{
this->fLocal = fLocal;
u.ULongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE - 1] = Addr;
}
void
RPC_CLIENT_PROCESS_IDENTIFIER::SetNMPClientIdentifier (
IN FILE_PIPE_CLIENT_PROCESS_BUFFER *ClientId,
IN BOOL fLocal
)
/*++
Routine Description:
Stores a client identifier as returned by the named pipes
primitives
Arguments:
ClientId - the buffer the named pipe driver (NPFS or SVR)
returned.
fLocal - TRUE if the client is guaranteed to be Local. False otherwise.
Return Value:
--*/
{
this->fLocal = fLocal;
#if defined(_WIN64) || defined(BUILD_WOW6432)
u.ULongLongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONGLONG_ARRAY_SIZE - 2] = (ULONGLONG)ClientId->ClientSession;
u.ULongLongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONGLONG_ARRAY_SIZE - 1] = (ULONGLONG)ClientId->ClientProcess;
#else
u.ULongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE - 2] = (ULONG)ClientId->ClientSession;
u.ULongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE - 1] = (ULONG)ClientId->ClientProcess;
#endif
}
void
RPC_CLIENT_PROCESS_IDENTIFIER::SetIPXClientIdentifier (
IN void *Buffer,
IN size_t BufferSize,
IN BOOL fLocal)
/*++
Routine Description:
IPX servers can use this to store their client address in
the client identifier.
Arguments:
Buffer - the buffer with the client identifier
BufferSize - the size of the data in buffer
fLocal - TRUE if the client is guaranteed to be Local. False otherwise.
Return Value:
--*/
{
ASSERT(BufferSize <= sizeof(u.ULongClientId));
this->fLocal = fLocal;
RpcpMemoryCopy(((unsigned char *)(&u.ULongClientId[RPC_CLIENT_PROCESS_IDENTIFIER_ULONG_ARRAY_SIZE])) - BufferSize, Buffer, BufferSize);
}
BOOL
RPC_CLIENT_PROCESS_IDENTIFIER::IsLocal (
void
)
/*++
Routine Description:
Returns TRUE if the client process identifier is for a local process.
Arguments:
Return Value:
TRUE - the client process is guaranteed to be local.
FALSE - the client process is either remote, or it is not known
whether the client process is local or remote.
--*/
{
return fLocal;
}
typedef RPC_STATUS
(RPC_ENTRY *CO_SERVER_QUERY_CLIENT_ID)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
OUT RPC_CLIENT_PROCESS_IDENTIFIER *pClientId
);
/*++
Routine Description:
For transport which support security this returns the ID of the
client process.
This API is optional and not support on most protocols.
Arguments:
ThisConnection - Server connection to the client in question.
pClientId - Will return the ID of the client connection/process.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_RESOURCES
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_SERVER_IMPERSONATE)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection
);
/*++
Routine Description:
For protocols which support security this impersonates the client.
Arguments:
ThisConnection - The server connection to the client to be impersonated.
Return Value:
RPC_S_OK
RPC_S_NO_CONTEXT_AVAILABLE
--*/
typedef RPC_STATUS
(RPC_ENTRY *CO_SERVER_REVERT)
(
IN RPC_TRANSPORT_CONNECTION ThisConnection
);
/*++
Routine Description:
Maybe called on a thread which has previously, successfully called
CO_SERVER_IMPERSONATE on the same connection.
Resets the threads token to that of the server process.
Arguments:
ThisConnection - The connection previously impersonated on this thread.
Return Value:
RPC_S_OK
--*/
extern RPC_STATUS RPC_ENTRY
COMMON_PostRuntimeEvent(
IN DWORD Type,
IN PVOID Context
);
} // extern "C"
// Connection oriented transport interface
struct RPC_CONNECTION_TRANSPORT
{
//
// RPC_TRANSPORT_INTERFACE_HEADER definitions
//
UINT TransInterfaceVersion;
USHORT TransId;
USHORT TransAddrId;
RPC_CHAR *ProtocolSequence;
PCHAR WellKnownEndpoint;
PROCESS_CALLS ProcessCalls;
#ifndef NO_PLUG_AND_PLAY
START_PNP_NOTIFICATIONS PnpNotify;
LISTEN_FOR_PNP_NOTIFICATIONS PnpListen;
#endif
TOWER_CONSTRUCT TowerConstruct;
TOWER_EXPLODE TowerExplode;
POST_EVENT PostEvent ;
BOOL fDatagram;
//
// Connection specific interface
//
UINT AddressSize;
UINT ClientConnectionSize;
UINT ServerConnectionSize;
UINT SendContextSize;
UINT ResolverHintSize;
UINT MaximumFragmentSize;
CO_CLIENT_INITIALIZE Initialize;
CO_CLIENT_INITCOMPLETE InitComplete;
// Operations on client-side connections
CO_CLIENT_OPEN Open;
CO_CLIENT_SYNC_SEND_RECV SyncSendRecv; OPTIONAL
CO_CLIENT_SYNC_RECV SyncRecv;
// Operations on connecitons
CO_ABORT Abort;
CO_CLOSE Close;
CO_SEND Send;
CO_RECV Recv;
CO_SYNC_SEND SyncSend;
// Client side explicit keep alive operations
CO_TURN_ON_OFF_KEEPALIVES TurnOnOffKeepAlives;
// Server only startup APIs
CO_SERVER_LISTEN Listen;
CO_SERVER_ABORT_LISTEN AbortListen;
CO_SERVER_COMPLETE_LISTEN CompleteListen;
// Operations on sever-side connections
CO_SERVER_QUERY_ADDRESS QueryClientAddress; OPTIONAL
CO_SERVER_QUERY_LOCAL_ADDRESS QueryLocalAddress; OPTIONAL
// Server-side security related APIs
CO_SERVER_QUERY_CLIENT_ID QueryClientId;
CO_SERVER_IMPERSONATE ImpersonateClient; OPTIONAL
CO_SERVER_REVERT RevertToSelf; OPTIONAL
// Resolver hint APIs
CO_FREE_RESOLVER_HINT FreeResolverHint; OPTIONAL
CO_COPY_RESOLVER_HINT CopyResolverHint; OPTIONAL
CO_COMPARE_RESOLVER_HINT CompareResolverHint; OPTIONAL
// Misc. APIs
CO_SET_LAST_BUFFER_TO_FREE SetLastBufferToFree; OPTIONAL
};
// Datagram specific transport interface
typedef struct tagDatagramTransportPair
{
HANDLE RemoteAddress;
HANDLE LocalAddress;
} DatagramTransportPair;
typedef HANDLE DG_TRANSPORT_ENDPOINT; // Listening/sending object
typedef HANDLE DG_TRANSPORT_ADDRESS; // Destination/source address
struct DG_ENDPOINT_STATS
{
unsigned long PreferredPduSize;
unsigned long MaxPduSize;
unsigned long MaxPacketSize;
unsigned long ReceiveBufferSize;
};
extern "C" {
typedef RPC_STATUS
(RPC_ENTRY *DG_SEND)
(
IN DG_TRANSPORT_ENDPOINT SourceEndpoint,
IN DG_TRANSPORT_ADDRESS DestinationAddress,
IN BUFFER Header,
IN UINT HeaderLength,
IN BUFFER Body,
IN UINT BodyLength,
IN BUFFER Trailer,
IN UINT TrailerLength
);
/*++
Routine Description:
Sends the complete packet (Header+Body+Trailer) to the destination
address from the source endpoint. Replys, if any, will then come back
to the source endpoint.
Arguments:
SourceEndpoint - Client or server endpoint object to send from.
DestinationAddress - The address to send the packet to.
Header - First part of the data.
HeaderLength - The number of bytes of Header to send.
Body - The main (bulk) of the data to send.
BodyLength - The number of bytes of Body to send.
Trailer - The last part of the data to send.
TrailerLength - The number of bytes of Trailer to send.
Return Value:
RPC_S_OK
RPC_S_OUT_OF_RESOURCES
RPC_P_SEND_FAILED
--*/
typedef RPC_STATUS
(RPC_ENTRY *DG_CLIENT_OPEN_ENDPOINT)
(
IN DG_TRANSPORT_ENDPOINT Endpoint,
IN BOOL fAsync,
IN DWORD Flags
);
/*++
Routine Description:
Creates a local endpoint object which can be used to send
and receive packets.
Arguments:
Endpoint - Storage for the transport endpoint object.
fAsync - TRUE - Transport should post and manage receives
which complete via ProcessCalls.
FALSE - Runtime will use Send and SyncRecv only
Flags - endpoint flags, one of RPC_C_USE_INTERNET_PORT or
RPC_C_USE_INTRANET_PORT
Return Value:
RPC_S_OK
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
--*/
typedef RPC_STATUS
(RPC_ENTRY *DG_CLIENT_INITIALIZE_ADDRESS)
(
OUT DG_TRANSPORT_ADDRESS Address,
IN RPC_CHAR *NetworkAddress,
IN RPC_CHAR *Endpoint,
IN BOOL fUseCache,
IN BOOL fBroadcast
);
/*++
Routine Description:
Initializes a address object for sending to a server.
Arguments:
Address - Storage for the address
NetworkAddress - The address of the server or 0 if local
Endpoint - The endpoint of the server
fBroadcast - If TURE, NetworkAddress is ignored and a
transport-specific broadcast address is used.
fUseCache - If TRUE then the transport may use a cached
value from a previous call on the same NetworkAddress.
Return Value:
RPC_S_OK - Success, name resolved
RPC_P_FOUND_IN_CACHE - Success, returned only if fUseCache is TRUE
and the was name found in local cache.
RPC_P_MATCHED_CACHE - Partial success, fUseCache is FALSE and the
result of the lookup was the same as the value previously
in the cache.
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
RPC_S_INVALID_ENDPOINT_FORMAT
RPC_S_SERVER_UNAVAILABLE
--*/
typedef RPC_STATUS
(RPC_ENTRY *DG_CLIENT_CLOSE)
(
IN DG_TRANSPORT_ENDPOINT Endpoint
);
/*++
Routine Description:
Closes a client endpoint object when it will no longer be needed.
Note: For async endpoint this doesn't actually destroy the endpoint,
but it will eventually cause a thread waiting in ProcessCalls
to get back an RPC_P_ENDPOINT_CLOSED completion for the endpoint.
In the meantime it is possible for new packets to arrive at the
endpoint.
Arguments:
Endpoing - The endpoint that should be closed.
Return Value:
RPC_S_OK - Sync endpoints
RPC_P_IO_PENDING - Async endpoints
--*/
typedef RPC_STATUS
(RPC_ENTRY *DG_CLIENT_SYNC_RECV)
(
IN DG_TRANSPORT_ENDPOINT Endpoint,
OUT DG_TRANSPORT_ADDRESS *pAddress,
OUT PUINT pBufferLength,
OUT BUFFER *pBuffer,
IN LONG Timeout
);
/*++
Routine Description:
Used to wait for a datagram from a server. Returns the data
returned and the ADDRESS of the machine which replied.
Arguments:
Endpoint - The endpoint to receive from.
pAddress - A block of memory which will contain the server's
address on completion.
BufferLength - The size of Buffer on input, the size of the
datagram received on output.
Timeout - Milliseconds to wait for a datagram.
Return Value:
RPC_S_OK
RPC_P_OVERSIZE_PACKET - Datagram > BufferLength arrived,
first BufferLength bytes of Buffer contain the partial datagram.
RPC_P_RECEIVE_FAILED
RPC_P_TIMEOUT
--*/
typedef RPC_STATUS
(RPC_ENTRY *DG_SERVER_LISTEN)
(
IN OUT DG_TRANSPORT_ENDPOINT ServerEndpoint,
IN RPC_CHAR *NetworkAddress,
IN OUT RPC_CHAR **Endpoint,
IN void *SecurityDescriptor,
IN ULONG EndpointFlags,
IN ULONG NICFlags,
OUT NETWORK_ADDRESS_VECTOR **pNetworkAddresses
);
/*++
Routine Description:
Creates a server endpoint object to receive packets. New
packets won't actually arrive until CompleteListen is
called.
Arguments:
ServerEndpoint - Storage for the server endpoint object.
Endpoint - The endpoint to listen on or a pointer to 0 if
the transport should choose the address.
Contains the endpoint listened to on output. The
caller should free this.
EndpointFlags - Application flags passed into RPC via
RpcServerUseProtseq*Ex.
NICFlags - Application flags passed into RPC via
RpcServerUseProtseq*Ex.
pNetworkAddresses - A vector of the network addresses
listened on by this call. This vector does
not need to be freed.
Return Value:
RPC_S_OK - Success
RPC_S_INVALID_ENDPOINT_FORMAT
RPC_S_DUPLICATE_ENDPOINT
RPC_S_CANT_CREATE_ENDPOINT
RPC_S_OUT_OF_MEMORY
RPC_S_OUT_OF_RESOURCES
--*/
typedef void
(RPC_ENTRY *DG_SERVER_ABORT_LISTEN)
(
IN RPC_TRANSPORT_ADDRESS ThisEndpoint
);
/*++
Routine Description:
Destroys on a newly, successfully created server endpoint
for some reason known only to the runtime will not be used.
Arguments:
ThisEndpoint - The endpoint to destroy.
Return Value:
Must succeed.
--*/
typedef void
(RPC_ENTRY *DG_SERVER_COMPLETE_LISTEN)
(
IN DG_TRANSPORT_ENDPOINT ThisAddress
);
/*++
Routine Description:
Called when the runtime is actually ready for packets to be
completed (received) on this endpoint. This call cannot fail since
the runtime can't undo the operation at this point.
Arguments:
ThisAddress - The address the runtime is now ready to receive
connections on.
Return Value:
Must succeed.
--*/
typedef RPC_STATUS
(RPC_ENTRY *DG_QUERY_ADDRESS)
(
IN DG_TRANSPORT_ADDRESS ThisAddress,
OUT RPC_CHAR *AddressString
);
/*++
Routine Description:
Converts the network address of a DG_TRANSPORT_ADDRESS into a string.
Arguments:
ThisAddress - The transport address containing the network address.
AddressString - Storage for the string form of the network address.
Note: This buffer is assumed to be <AddressSize> bytes.
Return Value:
RPC_S_OK
--*/
typedef RPC_STATUS
(RPC_ENTRY *DG_QUERY_ENDPOINT_STATS)
(
IN DG_TRANSPORT_ADDRESS ThisAddress,
OUT DG_ENDPOINT_STATS * pStats
);
/*++
Routine Description:
Returns the endpoint's receive buffer length and max PDU sizes.
Arguments:
ThisAddress - The transport address containing the network address.
pStats - a structure to fill with stats
Return Value:
RPC_S_OK
--*/
typedef RPC_STATUS
(RPC_ENTRY *DG_QUERY_ENDPOINT)
(
IN DG_TRANSPORT_ADDRESS ThisAddress,
OUT RPC_CHAR *EndpointString
);
/*++
Routine Description:
Converts the endpoint of a DG_TRANSPORT_ADDRESS into a string.
Arguments:
ThisAddress - The transport address containing the endpoint.
AddressString - Storage for the string form of the endpoint.
Note: This buffer is assumed to be <EndpointStringSize> bytes.
Return Value:
RPC_S_OK
--*/
typedef RPC_STATUS
(RPC_ENTRY * DG_CLIENT_INIT_OPTIONS)
(
IN void *pvTransportOptions
);
typedef RPC_STATUS
(RPC_ENTRY * DG_CLIENT_SET_OPTION)
(
IN void *pvTransportOptions,
IN ULONG Option,
IN ULONG_PTR OptionValue
);
typedef RPC_STATUS
(RPC_ENTRY * DG_CLIENT_INQ_OPTION)
(
IN void *pvTransportOptions,
IN ULONG Option,
OUT ULONG_PTR * pOptionValue
);
typedef RPC_STATUS
(RPC_ENTRY * DG_CLIENT_IMPLEMENT_OPTIONS)
(
IN DG_TRANSPORT_ENDPOINT pEndpoint,
IN void *pvTransportOptions
);
typedef BOOL
(RPC_ENTRY * DG_SERVER_ALLOW_RECEIVES)
(
IN DG_TRANSPORT_ENDPOINT pEndpoint,
IN BOOL fAllowReceives,
IN BOOL fCancelPendingIos
);
typedef RPC_STATUS
(RPC_ENTRY * DG_SERVER_INQUIRE_AUTH_CLIENT)
(
IN void *pClientEndpoint,
OUT RPC_CHAR **ppPrincipal,
OUT SID **ppSid,
OUT ULONG *pulAuthenLevel,
OUT ULONG *pulAuthnService,
OUT ULONG *pulAuthzService
);
typedef RPC_STATUS
(RPC_ENTRY *DG_SERVER_FORWARD_PACKET)
(
IN DG_TRANSPORT_ENDPOINT SourceEndpoint,
IN BUFFER Header,
IN UINT HeaderLength,
IN BUFFER Body,
IN UINT BodyLength,
IN BUFFER Trailer,
IN UINT TrailerLength,
IN CHAR *Endpoint
);
/*++
Routine Description:
A special form of DG_SEND which takes an string endpoint
to send to rather then a full DG_TRANSPORT_ADDRESS.
The packet is forwarded to the local machine.
Arguments:
SourceEndpoint - The endpoint to send from.
Headers - TrailerLength - Same as DG_SEND above
Endpoint - The string form of the endpoint to send to.
Return Value:
RPC_S_OK
--*/
}
struct RPC_DATAGRAM_TRANSPORT
{
//
// Common RPC_TRANSPORT_INTERFACE_HEADER definitions
//
UINT TransInterfaceVersion;
USHORT TransId;
USHORT TransAddrId;
RPC_CHAR *ProtocolSequence;
PCHAR WellKnownEndpoint;
PROCESS_CALLS ProcessCalls;
#ifndef NO_PLUG_AND_PLAY
START_PNP_NOTIFICATIONS PnpNotify;
LISTEN_FOR_PNP_NOTIFICATIONS PnpListen;
#endif
TOWER_CONSTRUCT TowerConstruct;
TOWER_EXPLODE TowerExplode;
POST_EVENT PostEvent ;
BOOL fDatagram;
//
// Datagram specific
//
UINT ServerEndpointSize;
UINT ClientEndpointSize;
UINT AddressSize;
UINT EndpointStringSize;
UINT AddressStringSize;
UINT BasePduSize;
UINT ExpectedPduSize;
DG_SEND Send;
DG_CLIENT_OPEN_ENDPOINT OpenEndpoint;
DG_CLIENT_INITIALIZE_ADDRESS InitializeAddress;
DG_CLIENT_CLOSE Close;
DG_CLIENT_SYNC_RECV SyncReceive;
DG_SERVER_LISTEN Listen;
DG_SERVER_ABORT_LISTEN AbortListen;
DG_SERVER_COMPLETE_LISTEN CompleteListen;
DG_SERVER_FORWARD_PACKET ForwardPacket;
DG_QUERY_ADDRESS QueryAddress;
DG_QUERY_ENDPOINT QueryEndpoint;
DG_QUERY_ENDPOINT_STATS QueryEndpointStats;
BOOL IsMessageTransport; // ncadg_mq message transport.
UINT OptionsSize; // Endpoint options.
DG_CLIENT_INIT_OPTIONS InitOptions;
DG_CLIENT_SET_OPTION SetOption;
DG_CLIENT_INQ_OPTION InqOption;
DG_CLIENT_IMPLEMENT_OPTIONS ImplementOptions;
DG_SERVER_ALLOW_RECEIVES AllowReceives;
DG_SERVER_INQUIRE_AUTH_CLIENT InquireAuthClient;
};
typedef RPC_TRANSPORT_INTERFACE_HEADER *RPC_TRANSPORT_INTERFACE;
typedef RPC_TRANSPORT_INTERFACE
(RPC_ENTRY *TRANSPORT_LOAD)(const RPC_CHAR *Protseq);
typedef HANDLE (RPC_ENTRY *FuncGetHandleForThread)(void);
typedef void (RPC_ENTRY *FuncReleaseHandleForThread)(HANDLE);
//
// Exports from the RPC runtime; used by the transport interface
//
extern "C" {
//
// Memory management APIs
//
// rpcdcep.h - I_RpcAllocate
// rpcdcep.h - I_RpcFree
// Connection allocation functions are called on either
// client-side or server-side connections during the
// receive path. Buffers must be 0 mod 8.
RPCRTAPI
BUFFER
RPC_ENTRY
I_RpcTransConnectionAllocatePacket(
RPC_TRANSPORT_CONNECTION ThisConnection,
UINT Size
);
RPCRTAPI
void
RPC_ENTRY
I_RpcTransConnectionFreePacket(
RPC_TRANSPORT_CONNECTION ThisConnection,
BUFFER Ptr
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
I_RpcTransConnectionReallocPacket(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN BUFFER *ppBuffer,
IN UINT OldSize,
IN UINT NewSize
);
RPCRTAPI
BUFFER
RPC_ENTRY
I_RpcTransServerAllocatePacket(
RPC_TRANSPORT_CONNECTION ThisConnection,
UINT Size
);
RPCRTAPI
void
RPC_ENTRY
I_RpcTransServerFreePacket(
RPC_TRANSPORT_CONNECTION ThisConnection,
BUFFER Ptr
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
I_RpcTransServerReallocPacket(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
IN BUFFER *ppBuffer,
IN UINT OldSize,
IN UINT NewSize
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
I_RpcTransDatagramAllocate(
IN RPC_TRANSPORT_ADDRESS ThisAddress,
OUT BUFFER *pBuffer,
OUT PUINT pBufferLength,
OUT DatagramTransportPair **pAddressPair
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
I_RpcTransDatagramAllocate2(
IN RPC_TRANSPORT_ADDRESS ThisAddress,
OUT BUFFER *pBuffer,
IN OUT PUINT pBufferLength,
OUT DG_TRANSPORT_ADDRESS *pAddress
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
I_RpcTransDatagramFree(
IN RPC_TRANSPORT_ADDRESS ThisAddress,
IN BUFFER Buffer
);
//
// Thread APIs
//
RPCRTAPI
PVOID
RPC_ENTRY
I_RpcTransProtectThread (
void
);
RPCRTAPI
void
RPC_ENTRY
I_RpcTransUnprotectThread (
IN PVOID Thread
);
//
// Runtime supplied per thread events.
//
RPCRTAPI
HANDLE
RPC_ENTRY
I_RpcTransGetThreadEvent(
);
//
// Misc connection oriented callbacks
//
RPCRTAPI
RPC_STATUS
RPC_ENTRY
I_RpcTransIoCancelled(
IN RPC_TRANSPORT_CONNECTION ThisConnection,
OUT PDWORD pTimeoutInMilliseconds
);
RPCRTAPI
BOOL
RPC_ENTRY
I_RpcTransPingServer(
IN RPC_TRANSPORT_CONNECTION ThisConnection
) ;
RPCRTAPI
RPC_TRANSPORT_CONNECTION
RPC_ENTRY
I_RpcTransServerNewConnection (
IN RPC_TRANSPORT_ADDRESS ThisAddress
);
RPC_TRANSPORT_INTERFACE
TransportLoad (
IN const RPC_CHAR * RpcProtocolSequence
);
#define SU_TRANS_CONN 'o'
#define EV_ABORT 'R'
void RPC_ENTRY
I_RpcLogEvent (
IN unsigned char Subject,
IN unsigned char Verb,
IN void * SubjectPointer,
IN void * ObjectPointer,
IN unsigned Data,
IN BOOL fCaptureStackTrace,
IN int AdditionalFramesToSkip
);
//
// constants for CallTestHook
//
#define TH_X_DG_SEND MAKE_TEST_HOOK_ID( TH_TRANS_BASE, 1 )
// args:
// hook ID
// pointer to NCA_PACKET_HEADER
// pointer to DWORD status variable
// nonzero status will be returned to caller w/o sending a packet
#define TH_X_DG_SYNC_RECV MAKE_TEST_HOOK_ID( TH_TRANS_BASE, 2 )
// args:
// hook ID
// pointer to DG_TRANSPORT_ENDPOINT
// pointer to DWORD status variable
// nonzero status will be returned to caller w/o receiving
//
// Call to allocate an IP port. This allows control of dynamic port
// allocation by the RPC runtime.
//
RPCRTAPI
RPC_STATUS
RPC_ENTRY
I_RpcServerAllocateIpPort(
IN ULONG Flags,
OUT USHORT *pPort
);
void
I_RpcTransVerifyServerRuntimeCallFromContext(
void *SendContext
);
void
I_RpcTransVerifyClientRuntimeCallFromContext(
void *SendContext
);
BOOL
I_RpcTransIsClientConnectionExclusive(
void *RuntimeConnection
);
RPC_STATUS
I_RpcTransCertMatchPrincipalName(
PCCERT_CONTEXT Context,
RPC_CHAR PrincipalName[]
);
RPC_HTTP_TRANSPORT_CREDENTIALS_W *
I_RpcTransGetHttpCredentials (
const IN RPC_HTTP_TRANSPORT_CREDENTIALS_W *SourceCredentials
);
void I_RpcTransFreeHttpCredentials (
IN RPC_HTTP_TRANSPORT_CREDENTIALS_W *SourceCredentials
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
HTTP2IISDirectReceive (
IN void *Context
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
HTTP2DirectReceive (
IN void *Context,
OUT BYTE **ReceivedBuffer,
OUT ULONG *ReceivedBufferLength,
OUT void **RuntimeConnection,
OUT BOOL *IsServer
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
HTTP2WinHttpDirectReceive (
IN void *Context,
OUT BYTE **ReceivedBuffer,
OUT ULONG *ReceivedBufferLength,
OUT void **RuntimeConnection
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
HTTP2WinHttpDirectSend (
IN void *Context,
OUT BYTE **SentBuffer,
OUT void **SendContext
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
HTTP2PlugChannelDirectSend (
IN void *Context
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
HTTP2FlowControlChannelDirectSend (
IN void *Context,
OUT BOOL *IsServer,
OUT BOOL *SendToRuntime,
OUT void **SendContext,
OUT BUFFER *Buffer,
OUT UINT *BufferLength
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
HTTP2ChannelDataOriginatorDirectSend (
IN void *Context,
OUT BOOL *IsServer,
OUT void **SendContext,
OUT BUFFER *Buffer,
OUT UINT *BufferLength
);
RPCRTAPI
void
RPC_ENTRY
HTTP2TimerReschedule (
IN void *Context
);
RPCRTAPI
void
RPC_ENTRY
HTTP2AbortConnection (
IN void *Context
);
RPCRTAPI
void
RPC_ENTRY
HTTP2RecycleChannel (
IN void *Context
);
RPC_STATUS
HTTP2ProcessComplexTReceive (
IN OUT void **Connection,
IN RPC_STATUS EventStatus,
IN ULONG Bytes,
OUT BUFFER *Buffer,
OUT UINT *BufferLength
);
RPC_STATUS
HTTP2ProcessComplexTSend (
IN void *SendContext,
IN RPC_STATUS EventStatus,
OUT BUFFER *Buffer
);
RPCRTAPI
RPC_STATUS
RPC_ENTRY
HTTP2TestHook (
IN SystemFunction001Commands FunctionCode,
IN void *InData,
OUT void *OutData
);
// Note: Gathered send support.
//
// Scatter/gather support is a common hardware feature of networking
// devices. Gather support is often useful for both DG and CO RPC.
//
// Not all networking programming APIs, for example winsock 1.x, support
// the feature, for example winsock 1.x.
//
// When possible transport implementer's should implement gathered sends,
// but the following assumptions can be made for those who cannot support
// gathered sends:
//
// Sends will consist of three (3) buffers: Header, Body and Trailer.
//
// The following rules are maintained by the RPC runtime:
// - All three buffer remain valid until the send completes.
// - Header and Trailer are small in size
// - sizeof(Header) bytes *before* the Body pointer are valid
// and maybe used during the send. But must be restored when
// the send completes (with or without an error.)
// - sizeof(Trailer) bytes *after* the Body pointer are valid
// and maybe used during the send. But must be restored when
// the send completes (with or without an error.)
//
// Scattered recv support is interesting in some protocols but it is
// not practical to simulate scattered recv's in the transport. Since
// the CO header is variable in length
} // extern "C"
#endif // __RPC_TRANS_HXX
Reference in a new issue View git blame Copy permalink