merged rpcrt-dll part from transgaming (Ove)
---
juergen.schmied@debitel.net
Index: wine/dlls/rpcrt4/Makefile.in
===================================================================
RCS file: /home/wine/wine/dlls/rpcrt4/Makefile.in,v
retrieving revision 1.8
diff -d -u -r1.8 Makefile.in
--- wine/dlls/rpcrt4/Makefile.in 17 May 2002 03:37:14 -0000 1.8
+++ wine/dlls/rpcrt4/Makefile.in 16 Jun 2002 10:53:10 -0000
@@ -4,14 +4,29 @@
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = rpcrt4.dll
-IMPORTS = kernel32
+IMPORTS = kernel32 ntdll advapi32
+EXTRALIBS = $(LIBUUID)
LDDLLFLAGS = @LDDLLFLAGS@
SYMBOLFILE = $(MODULE).tmp.o
C_SRCS = \
+ cproxy.c \
+ cpsf.c \
+ cstub.c \
+ ndr_midl.c \
+ ndr_ole.c \
+ ndr_stubless.c \
+ rpc_binding.c \
+ rpc_epmap.c \
+ rpc_message.c \
+ rpc_server.c \
rpcrt4_main.c
@MAKE_DLL_RULES@
### Dependencies:
+
+
+
+
Index: wine/dlls/rpcrt4/rpcrt4.spec
===================================================================
RCS file: /home/wine/wine/dlls/rpcrt4/rpcrt4.spec,v
retrieving revision 1.17
diff -d -u -r1.17 rpcrt4.spec
--- wine/dlls/rpcrt4/rpcrt4.spec 13 Jun 2002 21:50:12 -0000 1.17
+++ wine/dlls/rpcrt4/rpcrt4.spec 16 Jun 2002 10:53:11 -0000
@@ -18,11 +18,6 @@
@ stub MqGetContext # win9x
@ stub MqRegisterQueue # win9x
-@ stdcall NdrDllCanUnloadNow(ptr) NdrDllCanUnloadNow
-@ stdcall NdrDllGetClassObject(ptr ptr ptr ptr ptr ptr) NdrDllGetClassObject
-@ stdcall NdrDllRegisterProxy(long ptr ptr) NdrDllRegisterProxy
-@ stub NdrDllUnregisterProxy
-
@ stub RpcAbortAsyncCall
@ stub RpcAsyncAbortCall
@ stub RpcAsyncCancelCall
@@ -42,7 +37,7 @@
@ stub RpcBindingInqAuthInfoW
@ stub RpcBindingInqAuthInfoExA
@ stub RpcBindingInqAuthInfoExW
-@ stub RpcBindingInqObject
+@ stdcall RpcBindingInqObject(ptr ptr) RpcBindingInqObject
@ stub RpcBindingInqOption
@ stub RpcBindingReset
@ stub RpcBindingServerFromClient
@@ -50,23 +45,23 @@
@ stub RpcBindingSetAuthInfoW
@ stub RpcBindingSetAuthInfoExA
@ stub RpcBindingSetAuthInfoExW
-@ stub RpcBindingSetObject
+@ stdcall RpcBindingSetObject(ptr ptr) RpcBindingSetObject
@ stub RpcBindingSetOption
-@ stub RpcBindingToStringBindingA
-@ stub RpcBindingToStringBindingW
-@ stub RpcBindingVectorFree
+@ stdcall RpcBindingToStringBindingA(ptr ptr) RpcBindingToStringBindingA
+@ stdcall RpcBindingToStringBindingW(ptr ptr) RpcBindingToStringBindingW
+@ stdcall RpcBindingVectorFree(ptr) RpcBindingVectorFree
@ stub RpcCancelAsyncCall
@ stub RpcCancelThread
@ stub RpcCancelThreadEx
@ stub RpcCertGeneratePrincipalNameA
@ stub RpcCertGeneratePrincipalNameW
@ stub RpcCompleteAsyncCall
-@ stub RpcEpRegisterA
+@ stdcall RpcEpRegisterA(ptr ptr ptr str) RpcEpRegisterA
@ stub RpcEpRegisterW
@ stub RpcEpRegisterNoReplaceA
@ stub RpcEpRegisterNoReplaceW
-@ stub RpcEpResolveBinding
-@ stub RpcEpUnregister
+@ stdcall RpcEpResolveBinding(ptr ptr) RpcEpResolveBinding
+@ stdcall RpcEpUnregister(ptr ptr ptr) RpcEpUnregister
@ stub RpcGetAsyncCallStatus
@ stub RpcIfIdVectorFree
@ stub RpcIfInqId
@@ -111,7 +106,7 @@
@ stub RpcRegisterAsyncInfo
@ stub RpcRevertToSelf
@ stub RpcRevertToSelfEx
-@ stub RpcServerInqBindings
+@ stdcall RpcServerInqBindings(ptr) RpcServerInqBindings
@ stub RpcServerInqDefaultPrincNameA
@ stub RpcServerInqDefaultPrincNameW
@ stub RpcServerInqIf
@@ -163,49 +158,54 @@
@ stub RpcSsSwapClientAllocFree
@ stdcall RpcStringBindingComposeA(str str str str str ptr) RpcStringBindingComposeA
@ stdcall RpcStringBindingComposeW(wstr wstr wstr wstr wstr ptr) RpcStringBindingComposeW
-@ stub RpcStringBindingParseA
-@ stub RpcStringBindingParseW
+@ stdcall RpcStringBindingParseA(str ptr ptr ptr ptr ptr) RpcStringBindingParseA
+@ stdcall RpcStringBindingParseW(wstr ptr ptr ptr ptr ptr) RpcStringBindingParseW
@ stdcall RpcStringFreeA(ptr) RpcStringFreeA
-@ stub RpcStringFreeW
+@ stdcall RpcStringFreeW(ptr) RpcStringFreeW
@ stub RpcTestCancel
@ stub TowerConstruct
@ stub TowerExplode
@ stub UuidCompare
-@ stdcall UuidCreate(ptr) UuidCreate
-@ stdcall UuidCreateSequential(ptr) UuidCreateSequential # win 2000
-@ stub UuidCreateNil
-@ stub UuidEqual
-@ stdcall UuidFromStringA(ptr ptr) UuidFromStringA
-@ stdcall UuidFromStringW(ptr ptr) UuidFromStringW
-@ stdcall UuidHash(ptr ptr) UuidHash
-@ stub UuidIsNil
-@ stdcall UuidToStringA(ptr ptr) UuidToStringA
-@ stub UuidToStringW
+@ stdcall UuidCreate(ptr) UuidCreate
+@ stdcall UuidCreateNil(ptr) UuidCreateNil
+@ stdcall UuidCreateSequential(ptr) UuidCreateSequential
+@ stdcall UuidEqual(ptr ptr ptr) UuidEqual
+@ stdcall UuidFromStringA(str ptr) UuidFromStringA
+@ stdcall UuidFromStringW(wstr ptr) UuidFromStringW
+@ stdcall UuidHash(ptr ptr) UuidHash
+@ stdcall UuidIsNil(ptr ptr) UuidIsNil
+@ stdcall UuidToStringA(ptr ptr) UuidToStringA
+@ stdcall UuidToStringW(ptr ptr) UuidToStringW
-@ stub CStdStubBuffer_QueryInterface
-@ stub CStdStubBuffer_AddRef
-@ stub CStdStubBuffer_Connect
-@ stub CStdStubBuffer_Disconnect
-@ stub CStdStubBuffer_Invoke
-@ stub CStdStubBuffer_IsIIDSupported
-@ stub CStdStubBuffer_CountRefs
-@ stub CStdStubBuffer_DebugServerQueryInterface
-@ stub CStdStubBuffer_DebugServerRelease
+@ stdcall CStdStubBuffer_QueryInterface(ptr ptr) CStdStubBuffer_QueryInterface
+@ stdcall CStdStubBuffer_AddRef(ptr) CStdStubBuffer_AddRef
+@ stdcall CStdStubBuffer_Connect(ptr ptr) CStdStubBuffer_Connect
+@ stdcall CStdStubBuffer_Disconnect(ptr) CStdStubBuffer_Disconnect
+@ stdcall CStdStubBuffer_Invoke(ptr ptr ptr) CStdStubBuffer_Invoke
+@ stdcall CStdStubBuffer_IsIIDSupported(ptr ptr) CStdStubBuffer_IsIIDSupported
+@ stdcall CStdStubBuffer_CountRefs(ptr) CStdStubBuffer_CountRefs
+@ stdcall CStdStubBuffer_DebugServerQueryInterface(ptr ptr) CStdStubBuffer_DebugServerQueryInterface
+@ stdcall CStdStubBuffer_DebugServerRelease(ptr ptr) CStdStubBuffer_DebugServerRelease
+@ stdcall NdrCStdStubBuffer_Release(ptr ptr) NdrCStdStubBuffer_Release
@ stub NdrCStdStubBuffer2_Release
-@ stub NdrCStdStubBuffer_Release
-@ stub IUnknown_QueryInterface_Proxy
-@ stub IUnknown_AddRef_Proxy
-@ stub IUnknown_Release_Proxy
+@ stdcall IUnknown_QueryInterface_Proxy(ptr ptr ptr) IUnknown_QueryInterface_Proxy
+@ stdcall IUnknown_AddRef_Proxy(ptr) IUnknown_AddRef_Proxy
+@ stdcall IUnknown_Release_Proxy(ptr) IUnknown_Release_Proxy
+
+@ stdcall NdrDllCanUnloadNow(ptr) NdrDllCanUnloadNow
+@ stdcall NdrDllGetClassObject(ptr ptr ptr ptr ptr ptr) NdrDllGetClassObject
+@ stdcall NdrDllRegisterProxy(long ptr ptr) NdrDllRegisterProxy
+@ stdcall NdrDllUnregisterProxy(long ptr ptr) NdrDllUnregisterProxy
@ stub NdrAllocate
@ stub NdrAsyncClientCall
@ stub NdrAsyncServerCall
@ stub NdrClearOutParameters
@ stub NdrClientCall
-@ stub NdrClientCall2
+@ varargs NdrClientCall2(ptr ptr) NdrClientCall2
@ stub NdrClientInitialize
@ stub NdrClientInitializeNew
@ stub NdrContextHandleInitialize
@@ -246,18 +246,18 @@
@ stub NdrMesTypeFree2
@ stub NdrNsGetBuffer
@ stub NdrNsSendReceive
-@ stub NdrOleAllocate
-@ stub NdrOleFree
+@ stdcall NdrOleAllocate(long) NdrOleAllocate
+@ stdcall NdrOleFree(ptr) NdrOleFree
@ stub NdrPipePull
@ stub NdrPipePush
@ stub NdrPipeSendReceive
@ stub NdrPipesDone
@ stub NdrPipesInitialize
@ stub NdrProxyErrorHandler
-@ stub NdrProxyFreeBuffer
-@ stub NdrProxyGetBuffer
-@ stub NdrProxyInitialize
-@ stub NdrProxySendReceive
+@ stdcall NdrProxyFreeBuffer(ptr ptr) NdrProxyFreeBuffer
+@ stdcall NdrProxyGetBuffer(ptr ptr) NdrProxyGetBuffer
+@ stdcall NdrProxyInitialize(ptr ptr ptr ptr long) NdrProxyInitialize
+@ stdcall NdrProxySendReceive(ptr ptr) NdrProxySendReceive
@ stub NdrRangeUnmarshall
@ stub NdrRpcSmClientAllocate
@ stub NdrRpcSmClientFree
@@ -272,7 +272,9 @@
@ stub NdrStubCall
@ stub NdrStubCall2
@ stub NdrStubForwardingFunction
-@ stub NdrStubGetBuffer
+@ stdcall NdrStubGetBuffer(ptr ptr ptr) NdrStubGetBuffer
+@ stdcall NdrStubInitialize(ptr ptr ptr ptr) NdrStubInitialize
+@ stub NdrStubInitializeMarshall
@ stub NdrpSetRpcSsDefaults
@ stub NdrByteCountPointerBufferSize
@@ -325,11 +327,11 @@
@ stub NdrHardStructMarshall
@ stub NdrHardStructMemorySize
@ stub NdrHardStructUnmarshall
-@ stub NdrInterfacePointerBufferSize
-@ stub NdrInterfacePointerFree
-@ stub NdrInterfacePointerMarshall
-@ stub NdrInterfacePointerMemorySize
-@ stub NdrInterfacePointerUnmarshall
+@ stdcall NdrInterfacePointerBufferSize(ptr ptr ptr) NdrInterfacePointerBufferSize
+@ stdcall NdrInterfacePointerFree(ptr ptr ptr) NdrInterfacePointerFree
+@ stdcall NdrInterfacePointerMarshall(ptr ptr ptr) NdrInterfacePointerMarshall
+@ stdcall NdrInterfacePointerMemorySize(ptr ptr) NdrInterfacePointerMemorySize
+@ stdcall NdrInterfacePointerUnmarshall(ptr ptr ptr long) NdrInterfacePointerUnmarshall
@ stub NdrNonConformantStringBufferSize
@ stub NdrNonConformantStringMarshall
@ stub NdrNonConformantStringMemorySize
@@ -359,8 +361,6 @@
@ stub NdrSimpleStructUnmarshall
@ stub NdrSimpleTypeMarshall
@ stub NdrSimpleTypeUnmarshall
-@ stub NdrStubInitialize
-@ stub NdrStubInitializeMarshall
@ stub NdrUserMarshalBufferSize
@ stub NdrUserMarshalFree
@ stub NdrUserMarshalMarshall
@@ -428,17 +428,18 @@
@ stub I_RpcBindingInqWireIdForSnego
@ stub I_RpcBindingIsClientLocal
@ stub I_RpcBindingToStaticStringBindingW
-@ stub I_RpcBindingSetAsync # win9x
+@ stdcall I_RpcBindingSetAsync(ptr ptr long) I_RpcBindingSetAsync # win9x
+# NT version of I_RpcBindingSetAsync has 2 arguments, not 3
@ stub I_RpcClearMutex
@ stub I_RpcConnectionInqSockBuffSize
@ stub I_RpcConnectionInqSockBuffSize2
@ stub I_RpcConnectionSetSockBuffSize
@ stub I_RpcDeleteMutex
@ stub I_RpcFree
-@ stub I_RpcFreeBuffer
+@ stdcall I_RpcFreeBuffer(ptr) I_RpcFreeBuffer
@ stub I_RpcFreePipeBuffer
@ stub I_RpcGetAssociationContext
-@ stub I_RpcGetBuffer
+@ stdcall I_RpcGetBuffer(ptr) I_RpcGetBuffer
@ stub I_RpcGetBufferWithObject
@ stub I_RpcGetCurrentCallHandle
@ stub I_RpcGetExtendedError
@@ -458,17 +459,17 @@
@ stub I_RpcParseSecurity
@ stub I_RpcPauseExecution
@ stub I_RpcReallocPipeBuffer
-@ stub I_RpcReceive
+@ stdcall I_RpcReceive(ptr) I_RpcReceive
@ stub I_RpcRequestMutex
-@ stub I_RpcSend
-@ stub I_RpcSendReceive
+@ stdcall I_RpcSend(ptr) I_RpcSend
+@ stdcall I_RpcSendReceive(ptr) I_RpcSendReceive
@ stub I_RpcServerAllocateIpPort
@ stub I_RpcServerInqAddressChangeFn
@ stub I_RpcServerInqTransportType
@ stub I_RpcServerRegisterForwardFunction
@ stub I_RpcServerSetAddressChangeFn
-@ stub I_RpcServerStartListening # win9x
-@ stub I_RpcServerStopListening # win9x
+@ stdcall I_RpcServerStartListening(ptr) I_RpcServerStartListening # win9x
+@ stdcall I_RpcServerStopListening() I_RpcServerStopListening # win9x
@ stub I_RpcServerUnregisterEndpointA # win9x
@ stub I_RpcServerUnregisterEndpointW # win9x
@ stub I_RpcServerUseProtseq2A
@@ -505,7 +506,7 @@
@ stub I_RpcTransServerReallocBuffer # win9x
@ stub I_RpcTransServerReceiveDirectReady # win9x
@ stub I_RpcTransServerUnprotectThread # win9x
-@ stub I_RpcWindowProc # win9x
+@ stdcall I_RpcWindowProc(ptr long long long) I_RpcWindowProc # win9x
@ stub I_RpcltDebugSetPDUFilter
@ stub I_UuidCreate
@@ -515,3 +516,5 @@
@ stub StartServiceIfNecessary # win9x
@ stub GlobalMutexClearExternal
@ stub GlobalMutexRequestExternal
+
+
Index: wine/dlls/rpcrt4/rpcrt4_main.c
===================================================================
RCS file: /home/wine/wine/dlls/rpcrt4/rpcrt4_main.c,v
retrieving revision 1.25
diff -d -u -r1.25 rpcrt4_main.c
--- wine/dlls/rpcrt4/rpcrt4_main.c 13 Jun 2002 21:50:12 -0000 1.25
+++ wine/dlls/rpcrt4/rpcrt4_main.c 16 Jun 2002 10:53:12 -0000
@@ -28,9 +28,9 @@
#include <unistd.h>
#include "windef.h"
-#include "wine/windef16.h"
#include "winerror.h"
#include "winbase.h"
+#include "wine/unicode.h"
#include "rpc.h"
#include "ole2.h"
@@ -58,8 +58,12 @@
#include "wine/debug.h"
+#include "rpc_binding.h"
+
WINE_DEFAULT_DEBUG_CHANNEL(ole);
+static UUID uuid_nil;
+
/***********************************************************************
* RPCRT4_LibMain
*
@@ -87,6 +91,41 @@
return TRUE;
}
+
+/*************************************************************************
+ * RpcStringFreeA [RPCRT4.@]
+ *
+ * Frees a character string allocated by the RPC run-time library.
+ *
+ * RETURNS
+ *
+ * S_OK if successful.
+ */
+RPC_STATUS WINAPI RpcStringFreeA(LPSTR* String)
+{
+ HeapFree( GetProcessHeap(), 0, *String);
+
+ return RPC_S_OK;
+}
+
+
+/*************************************************************************
+ * RpcStringFreeW [RPCRT4.@]
+ *
+ * Frees a character string allocated by the RPC run-time library.
+ *
+ * RETURNS
+ *
+ * S_OK if successful.
+ */
+RPC_STATUS WINAPI RpcStringFreeW(LPWSTR* String)
+{
+ HeapFree( GetProcessHeap(), 0, *String);
+
+ return RPC_S_OK;
+}
+
+
/*************************************************************************
* UuidCreate [RPCRT4.@]
*
@@ -105,11 +144,11 @@
static unsigned char a[6];
static int adjustment = 0;
static struct timeval last = {0, 0};
- static UINT16 clock_seq;
+ static WORD clock_seq;
struct timeval tv;
unsigned long long clock_reg;
- UINT clock_high, clock_low;
- UINT16 temp_clock_seq, temp_clock_mid, temp_clock_hi_and_version;
+ DWORD clock_high, clock_low;
+ WORD temp_clock_seq, temp_clock_mid, temp_clock_hi_and_version;
#ifdef HAVE_NET_IF_H
int sd;
struct ifreq ifr, *ifrp;
@@ -248,7 +287,7 @@
clock_high = clock_reg >> 32;
clock_low = clock_reg;
temp_clock_seq = clock_seq | 0x8000;
- temp_clock_mid = (UINT16)clock_high;
+ temp_clock_mid = (WORD)clock_high;
temp_clock_hi_and_version = (clock_high >> 16) | 0x1000;
/* pack the information into the GUID structure */
@@ -285,6 +324,14 @@
return RPC_S_OK;
}
+/*************************************************************************
+ * UuidCreateNil [RPCRT4.@]
+ */
+RPC_STATUS WINAPI UuidCreateNil(UUID *Uuid)
+{
+ *Uuid = uuid_nil;
+ return RPC_S_OK;
+}
/*************************************************************************
* UuidCreateSequential [RPCRT4.@]
@@ -292,45 +339,87 @@
* Creates a 128bit UUID by calling UuidCreate.
* New API in Win 2000
*/
-
RPC_STATUS WINAPI UuidCreateSequential(UUID *Uuid)
{
return UuidCreate (Uuid);
}
-
/*************************************************************************
- * RpcStringFreeA [RPCRT4.@]
- *
- * Frees a character string allocated by the RPC run-time library.
- *
- * RETURNS
- *
- * S_OK if successful.
+ * UuidEqual [RPCRT4.@]
*/
-RPC_STATUS WINAPI RpcStringFreeA(unsigned char** String)
+int WINAPI UuidEqual(UUID *uuid1, UUID *uuid2, RPC_STATUS *Status)
{
- HeapFree( GetProcessHeap(), 0, *String);
-
- return RPC_S_OK;
+ TRACE("(%s,%s)\n", debugstr_guid(uuid1), debugstr_guid(uuid2));
+ *Status = RPC_S_OK;
+ if (!uuid1) uuid1 = &uuid_nil;
+ if (!uuid2) uuid2 = &uuid_nil;
+ if (uuid1 == uuid2) return TRUE;
+ return !memcmp(uuid1, uuid2, sizeof(UUID));
}
+/*************************************************************************
+ * UuidIsNil [RPCRT4.@]
+ */
+int WINAPI UuidIsNil(UUID *uuid, RPC_STATUS *Status)
+{
+ TRACE("(%s)\n", debugstr_guid(uuid));
+ *Status = RPC_S_OK;
+ if (!uuid) return TRUE;
+ return !memcmp(uuid, &uuid_nil, sizeof(UUID));
+}
/*************************************************************************
* UuidHash [RPCRT4.@]
*
* Generates a hash value for a given UUID
- *
+ * Code based on FreeDCE implementation
*/
unsigned short WINAPI UuidHash(UUID *uuid, RPC_STATUS *Status)
{
- FIXME("stub:\n");
+ BYTE *data = (BYTE*)uuid;
+ short c0 = 0, c1 = 0, x, y;
+ int i;
+
+ TRACE("(%s)\n", debugstr_guid(uuid));
+
+ for (i=0; i<sizeof(UUID); i++) {
+ c0 += data[i];
+ c1 += c0;
+ }
+
+ x = -c1 % 255;
+ if (x < 0) x += 255;
+
+ y = (c1 - c0) % 255;
+ if (y < 0) y += 255;
+
*Status = RPC_S_OK;
- return 0xabcd;
+ return y*256 + x;
}
/*************************************************************************
* UuidToStringA [RPCRT4.@]
+ */
+RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, LPSTR* StringUuid)
+{
+ char buf[37];
+
+ sprintf(buf, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ Uuid->Data1, Uuid->Data2, Uuid->Data3,
+ Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
+ Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
+ Uuid->Data4[6], Uuid->Data4[7] );
+
+ *StringUuid = RPCRT4_strdupAA(buf, -1);
+
+ if(!(*StringUuid))
+ return RPC_S_OUT_OF_MEMORY;
+
+ return RPC_S_OK;
+}
+
+/*************************************************************************
+ * UuidToStringW [RPCRT4.@]
*
* Converts a UUID to a string.
*
@@ -342,256 +431,151 @@
* S_OK if successful.
* S_OUT_OF_MEMORY if unsucessful.
*/
-RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, unsigned char** StringUuid)
+RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, LPWSTR* StringUuid)
{
- *StringUuid = HeapAlloc( GetProcessHeap(), 0, sizeof(char) * 37);
+ char buf[37];
+
+ sprintf(buf, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+ Uuid->Data1, Uuid->Data2, Uuid->Data3,
+ Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
+ Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
+ Uuid->Data4[6], Uuid->Data4[7] );
+
+ *StringUuid = RPCRT4_strdupWA(buf, -1);
if(!(*StringUuid))
return RPC_S_OUT_OF_MEMORY;
- sprintf(*StringUuid, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
- Uuid->Data1, Uuid->Data2, Uuid->Data3,
- Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
- Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
- Uuid->Data4[6], Uuid->Data4[7] );
-
return RPC_S_OK;
}
-/***********************************************************************
- * UuidFromStringA (RPCRT4.@)
- */
-RPC_STATUS WINAPI UuidFromStringA(unsigned char *str, UUID *uuid)
-{
- FIXME("%s %p\n",debugstr_a(str),uuid);
- return RPC_S_INVALID_STRING_UUID;
-}
-
-/***********************************************************************
- * UuidFromStringW (RPCRT4.@)
- */
-RPC_STATUS WINAPI UuidFromStringW(unsigned short *str, UUID *uuid)
-{
- FIXME("%s %p\n",debugstr_w(str),uuid);
- return RPC_S_INVALID_STRING_UUID;
-}
-
-/***********************************************************************
- * NdrDllRegisterProxy (RPCRT4.@)
- */
-HRESULT WINAPI NdrDllRegisterProxy(
- HMODULE hDll, /* [in] */
- const ProxyFileInfo **pProxyFileList, /* [in] */
- const CLSID *pclsid /* [in] */
-)
+static inline int hex_d(WCHAR v)
{
- FIXME("(%x,%p,%s), stub!\n",hDll,pProxyFileList,debugstr_guid(pclsid));
- return S_OK;
+ switch (v) {
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+ return v - '0';
+ case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+ return v - 'a' + 10;
+ case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+ return v - 'A' + 10;
+ default:
+ return -1;
+ }
}
-/***********************************************************************
- * RpcServerUseProtseqEpA (RPCRT4.@)
- */
-
-RPC_STATUS WINAPI RpcServerUseProtseqEpA( LPSTR Protseq, UINT MaxCalls, LPSTR Endpoint, LPVOID SecurityDescriptor )
+static inline unsigned char hex1A(LPSTR s)
{
- RPC_POLICY policy;
-
- TRACE( "(%s,%u,%s,%p)\n", Protseq, MaxCalls, Endpoint, SecurityDescriptor );
-
- /* This should provide the default behaviour */
- policy.Length = sizeof( policy );
- policy.EndpointFlags = 0;
- policy.NICFlags = 0;
-
- return RpcServerUseProtseqEpExA( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
+ unsigned char v1 = hex_d(s[0]), v2 = hex_d(s[1]);
+ return (v1 << 4) | v2;
}
-/***********************************************************************
- * RpcServerUseProtseqEpW (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcServerUseProtseqEpW( LPWSTR Protseq, UINT MaxCalls, LPWSTR Endpoint, LPVOID SecurityDescriptor )
+static inline unsigned char hex1W(LPWSTR s)
{
- RPC_POLICY policy;
-
- TRACE( "(%s,%u,%s,%p)\n", debugstr_w( Protseq ), MaxCalls, debugstr_w( Endpoint ), SecurityDescriptor );
-
- /* This should provide the default behaviour */
- policy.Length = sizeof( policy );
- policy.EndpointFlags = 0;
- policy.NICFlags = 0;
-
- return RpcServerUseProtseqEpExW( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
+ unsigned char v1 = hex_d(s[0]), v2 = hex_d(s[1]);
+ return (v1 << 4) | v2;
}
-/***********************************************************************
- * RpcServerUseProtseqEpExA (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcServerUseProtseqEpExA( LPSTR Protseq, UINT MaxCalls, LPSTR Endpoint, LPVOID SecurityDescriptor,
- PRPC_POLICY lpPolicy )
+static inline unsigned short hex2A(LPSTR s)
{
- FIXME( "(%s,%u,%s,%p,{%u,%lu,%lu}): stub\n", Protseq, MaxCalls, Endpoint, SecurityDescriptor,
- lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
-
- return RPC_S_PROTSEQ_NOT_SUPPORTED; /* We don't support anything at this point */
+ unsigned char v1 = hex1A(s+0), v2 = hex1A(s+2);
+ return (unsigned short)(v1 << 8) | v2;
}
-/***********************************************************************
- * RpcServerUseProtseqEpExW (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcServerUseProtseqEpExW( LPWSTR Protseq, UINT MaxCalls, LPWSTR Endpoint, LPVOID SecurityDescriptor,
- PRPC_POLICY lpPolicy )
+static inline unsigned short hex2W(LPWSTR s)
{
- FIXME( "(%s,%u,%s,%p,{%u,%lu,%lu}): stub\n", debugstr_w( Protseq ), MaxCalls, debugstr_w( Endpoint ),
- SecurityDescriptor,
- lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
-
- return RPC_S_PROTSEQ_NOT_SUPPORTED; /* We don't support anything at this point */
+ unsigned char v1 = hex1W(s+0), v2 = hex1W(s+2);
+ return (unsigned short)(v1 << 8) | v2;
}
-/***********************************************************************
- * RpcServerRegisterIf (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcServerRegisterIf( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv )
+static inline unsigned long hex4A(LPSTR s)
{
- /* FIXME: Dump UUID using UuidToStringA */
- TRACE( "(%p,%p,%p)\n", IfSpec, MgrTypeUuid, MgrEpv );
-
- return RpcServerRegisterIf2( IfSpec, MgrTypeUuid, MgrEpv, 0, RPC_C_LISTEN_MAX_CALLS_DEFAULT, (UINT)-1, NULL );
+ unsigned short v1 = hex2A(s+0), v2 = hex2A(s+4);
+ return (unsigned long)(v1 << 16) | v2;
}
-/***********************************************************************
- * RpcServerRegisterIfEx (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcServerRegisterIfEx( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
- UINT Flags, UINT MaxCalls, RPC_IF_CALLBACK_FN* IfCallbackFn )
+static inline unsigned long hex4W(LPWSTR s)
{
- /* FIXME: Dump UUID using UuidToStringA */
- TRACE( "(%p,%p,%p,%u,%u,%p)\n", IfSpec, MgrTypeUuid, MgrEpv, Flags, MaxCalls, IfCallbackFn );
-
- return RpcServerRegisterIf2( IfSpec, MgrTypeUuid, MgrEpv, Flags, MaxCalls, (UINT)-1, IfCallbackFn );
+ unsigned short v1 = hex2W(s+0), v2 = hex2W(s+4);
+ return (unsigned long)(v1 << 16) | v2;
}
-/***********************************************************************
- * RpcServerRegisterIf2 (RPCRT4.@)
+/*************************************************************************
+ * UuidFromStringA [RPCRT4.@]
+ *
+ * Converts a string to a UUID.
*/
-RPC_STATUS WINAPI RpcServerRegisterIf2( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
- UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN* IfCallbackFn )
+RPC_STATUS WINAPI UuidFromStringA(LPSTR StringUuid, UUID *Uuid)
{
- /* FIXME: Dump UUID using UuidToStringA */
- FIXME( "(%p,%p,%p,%u,%u,%u,%p): stub\n", IfSpec, MgrTypeUuid, MgrEpv, Flags, MaxCalls, MaxRpcSize, IfCallbackFn );
-
- return RPC_S_UNKNOWN_IF; /* I guess this return code is as good as any failure */
-}
+ unsigned i;
+ if(!StringUuid)
+ return UuidCreateNil(Uuid);
-/***********************************************************************
- * RpcServerRegisterAuthInfoA (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcServerRegisterAuthInfoA( LPSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
- LPVOID Arg )
-{
- FIXME( "(%s,%lu,%p,%p): stub\n", ServerPrincName, AuthnSvc, GetKeyFn, Arg );
+ if (strlen(StringUuid) != 36)
+ return RPC_S_INVALID_STRING_UUID;
- return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
-}
+ if (StringUuid[8]!='-' || StringUuid[13]!='-' || StringUuid[18]!='-' || StringUuid[23]!='-')
+ return RPC_S_INVALID_STRING_UUID;
-/***********************************************************************
- * RpcServerRegisterAuthInfoW (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcServerRegisterAuthInfoW( LPWSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
- LPVOID Arg )
-{
- FIXME( "(%s,%lu,%p,%p): stub\n", debugstr_w( ServerPrincName ), AuthnSvc, GetKeyFn, Arg );
+ for (i=0; i<36; i++) {
+ if (i==8 || i == 13 || i == 18 || i == 23) continue;
+ if (hex_d(StringUuid[i]) == -1)
+ return RPC_S_INVALID_STRING_UUID;
+ }
- return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
+ Uuid->Data1 = hex4A(StringUuid);
+ Uuid->Data2 = hex2A(StringUuid+9);
+ Uuid->Data3 = hex2A(StringUuid+14);
+ Uuid->Data4[0] = hex1A(StringUuid+19);
+ Uuid->Data4[1] = hex1A(StringUuid+21);
+ Uuid->Data4[2] = hex1A(StringUuid+24);
+ Uuid->Data4[3] = hex1A(StringUuid+26);
+ Uuid->Data4[4] = hex1A(StringUuid+28);
+ Uuid->Data4[5] = hex1A(StringUuid+30);
+ Uuid->Data4[6] = hex1A(StringUuid+32);
+ Uuid->Data4[7] = hex1A(StringUuid+34);
+ return RPC_S_OK;
}
-/***********************************************************************
- * RpcServerListen (RPCRT4.@)
+/*************************************************************************
+ * UuidFromStringW [RPCRT4.@]
+ *
+ * Converts a string to a UUID.
*/
-RPC_STATUS WINAPI RpcServerListen( UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait )
+RPC_STATUS WINAPI UuidFromStringW(LPWSTR StringUuid, UUID *Uuid)
{
- FIXME( "(%u,%u,%u): stub\n", MinimumCallThreads, MaxCalls, DontWait );
+ unsigned i;
- return RPC_S_NO_PROTSEQS_REGISTERED; /* Since we don't allow registration this seems reasonable */
-}
+ if(!StringUuid)
+ return UuidCreateNil(Uuid);
-/***********************************************************************
- * RpcStringBindingComposeA (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcStringBindingComposeA( LPSTR ObjUuid, LPSTR Protseq, LPSTR NetworkAddr, LPSTR Endpoint,
- LPSTR Options, LPSTR* StringBinding )
-{
- FIXME( "(%s,%s,%s,%s,%s,%p): stub\n", ObjUuid, Protseq, NetworkAddr, Endpoint, Options, StringBinding );
- *StringBinding = NULL;
+ if (strlenW(StringUuid) != 36)
+ return RPC_S_INVALID_STRING_UUID;
- return RPC_S_INVALID_STRING_UUID; /* Failure */
-}
+ if (StringUuid[8]!='-' || StringUuid[13]!='-' || StringUuid[18]!='-' || StringUuid[23]!='-')
+ return RPC_S_INVALID_STRING_UUID;
-/***********************************************************************
- * RpcStringBindingComposeW (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcStringBindingComposeW( LPWSTR ObjUuid, LPWSTR Protseq, LPWSTR NetworkAddr, LPWSTR Endpoint,
- LPWSTR Options, LPWSTR* StringBinding )
-{
- FIXME( "(%s,%s,%s,%s,%s,%p): stub\n", debugstr_w( ObjUuid ), debugstr_w( Protseq ), debugstr_w( NetworkAddr ),
- debugstr_w( Endpoint ), debugstr_w( Options ), StringBinding );
- *StringBinding = NULL;
+ for (i=0; i<36; i++) {
+ if (i==8 || i == 13 || i == 18 || i == 23) continue;
+ if (hex_d(StringUuid[i]) == -1)
+ return RPC_S_INVALID_STRING_UUID;
+ }
- return RPC_S_INVALID_STRING_UUID; /* Failure */
-}
+ Uuid->Data1 = hex4W(StringUuid);
+ Uuid->Data2 = hex2W(StringUuid+9);
+ Uuid->Data3 = hex2W(StringUuid+14);
+ Uuid->Data4[0] = hex1W(StringUuid+19);
+ Uuid->Data4[1] = hex1W(StringUuid+21);
+ Uuid->Data4[2] = hex1W(StringUuid+24);
+ Uuid->Data4[3] = hex1W(StringUuid+26);
+ Uuid->Data4[4] = hex1W(StringUuid+28);
+ Uuid->Data4[5] = hex1W(StringUuid+30);
+ Uuid->Data4[6] = hex1W(StringUuid+32);
+ Uuid->Data4[7] = hex1W(StringUuid+34);
-/***********************************************************************
- * RpcBindingFree (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcBindingFree(RPC_BINDING_HANDLE* Binding)
-{
- FIXME("(%p): stub\n", Binding);
return RPC_S_OK;
}
-/***********************************************************************
- * RpcBindingFromStringBindingA (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcBindingFromStringBindingA( LPSTR StringBinding, RPC_BINDING_HANDLE* Binding )
-{
- FIXME( "(%s,%p): stub\n", StringBinding, Binding );
-
- return RPC_S_INVALID_STRING_BINDING; /* As good as any failure code */
-}
-
-/***********************************************************************
- * RpcBindingFromStringBindingW (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcBindingFromStringBindingW( LPWSTR StringBinding, RPC_BINDING_HANDLE* Binding )
-{
- FIXME( "(%s,%p): stub\n", debugstr_w( StringBinding ), Binding );
-
- return RPC_S_INVALID_STRING_BINDING; /* As good as any failure code */
-}
-
-/***********************************************************************
- * NdrDllCanUnloadNow (RPCRT4.@)
- */
-HRESULT WINAPI NdrDllCanUnloadNow(CStdPSFactoryBuffer *pPSFactoryBuffer)
-{
- FIXME("%p\n",pPSFactoryBuffer);
- return FALSE;
-}
-
-/***********************************************************************
- * NdrDllGetClassObject (RPCRT4.@)
- */
-HRESULT WINAPI NdrDllGetClassObject(
- REFCLSID rclsid, REFIID riid , LPVOID *ppv,
- const ProxyFileInfo ** pProxyFileList,
- const CLSID * pclsid,
- CStdPSFactoryBuffer * pPSFactoryBuffer)
-{
- if(ppv)
- *ppv = NULL;
- return RPC_S_UNKNOWN_IF;
-}
/***********************************************************************
* DllRegisterServer (RPCRT4.@)
@@ -602,3 +586,4 @@
FIXME( "(): stub\n" );
return S_OK;
}
+
Index: wine/include/rpc.h
===================================================================
RCS file: /home/wine/wine/include/rpc.h,v
retrieving revision 1.8
diff -d -u -r1.8 rpc.h
--- wine/include/rpc.h 10 Mar 2002 00:02:34 -0000 1.8
+++ wine/include/rpc.h 16 Jun 2002 10:53:43 -0000
@@ -25,6 +25,8 @@
#ifndef __WINE_RPC_H
#define __WINE_RPC_H
+#define __RPC_WIN32__
+
#define __RPC_FAR
#define __RPC_API WINAPI
#define __RPC_USER WINAPI
Index: wine/include/rpcdce.h
===================================================================
RCS file: /home/wine/wine/include/rpcdce.h,v
retrieving revision 1.8
diff -d -u -r1.8 rpcdce.h
--- wine/include/rpcdce.h 31 May 2002 23:06:48 -0000 1.8
+++ wine/include/rpcdce.h 16 Jun 2002 10:53:43 -0000
@@ -29,8 +29,6 @@
typedef void* RPC_AUTHZ_HANDLE;
typedef void* RPC_IF_HANDLE;
typedef I_RPC_HANDLE RPC_BINDING_HANDLE;
-typedef RPC_BINDING_HANDLE handle_t;
-#define rpc_binding_handle_t RPC_BINDING_HANDLE
#define RPC_MGR_EPV void
typedef struct _RPC_BINDING_VECTOR
@@ -38,14 +36,19 @@
unsigned long Count;
RPC_BINDING_HANDLE BindingH[1];
} RPC_BINDING_VECTOR;
-#define rpc_binding_vector_t RPC_BINDING_VECTOR
typedef struct _UUID_VECTOR
{
unsigned long Count;
UUID *Uuid[1];
} UUID_VECTOR;
+
+#ifndef __WINE__
+typedef RPC_BINDING_HANDLE handle_t;
+#define rpc_binding_handle_t RPC_BINDING_HANDLE
+#define rpc_binding_vector_t RPC_BINDING_VECTOR
#define uuid_vector_t UUID_VECTOR
+#endif
typedef struct _RPC_IF_ID
{
@@ -90,6 +93,11 @@
ULONG NICFlags;
} RPC_POLICY, *PRPC_POLICY;
+/* RpcServerRegisterIfEx Flags */
+#define RPC_IF_AUTOLISTEN 0x1
+#define RPC_IF_OLE 0x2
+#define RPC_IF_ALLOW_UNKNOWN_AUTHORITY 0x4
+#define RPC_IF_ALLOW_SECURE_ONLY 0x8
RPCRTAPI RPC_STATUS RPC_ENTRY
RpcBindingCopy( RPC_BINDING_HANDLE SourceBinding, RPC_BINDING_HANDLE* DestinationBinding );
@@ -98,6 +106,13 @@
RpcBindingFree( RPC_BINDING_HANDLE* Binding );
RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcBindingInqObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcBindingReset( RPC_BINDING_HANDLE Binding );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcBindingSetObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid );
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
RpcBindingFromStringBindingA( LPSTR StringBinding, RPC_BINDING_HANDLE* Binding );
RPCRTAPI RPC_STATUS RPC_ENTRY
RpcBindingFromStringBindingW( LPWSTR StringBinding, RPC_BINDING_HANDLE* Binding );
@@ -113,6 +128,45 @@
RpcBindingVectorFree( RPC_BINDING_VECTOR** BindingVector );
RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcStringBindingComposeA( LPSTR ObjUuid, LPSTR Protseq, LPSTR NetworkAddr,
+ LPSTR Endpoint, LPSTR Options, LPSTR* StringBinding );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcStringBindingComposeW( LPWSTR ObjUuid, LPWSTR Protseq, LPWSTR NetworkAddr,
+ LPWSTR Endpoint, LPWSTR Options, LPWSTR* StringBinding );
+#define RpcStringBindingCompose WINELIB_NAME_AW(RpcStringBindingCompose)
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcStringBindingParseA( LPSTR StringBinding, LPSTR* ObjUuid, LPSTR* Protseq,
+ LPSTR* NetworkAddr, LPSTR* Endpoint, LPSTR* NetworkOptions );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcStringBindingParseW( LPWSTR StringBinding, LPWSTR* ObjUuid, LPWSTR* Protseq,
+ LPWSTR* NetworkAddr, LPWSTR* Endpoint, LPWSTR* NetworkOptions );
+#define RpcStringBindingParse WINELIB_NAME_AW(RpcStringBindingParse)
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcEpResolveBinding( RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec );
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcEpRegisterA( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
+ UUID_VECTOR* UuidVector, LPSTR Annotation );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcEpRegisterW( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
+ UUID_VECTOR* UuidVector, LPWSTR Annotation );
+#define RpcEpRegister WINELIB_NAME_AW(RpcEpRegister)
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcEpRegisterNoReplaceA( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
+ UUID_VECTOR* UuidVector, LPSTR Annotation );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcEpRegisterNoReplaceW( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
+ UUID_VECTOR* UuidVector, LPWSTR Annotation );
+#define RpcEpRegisterNoReplace WINELIB_NAME_AW(RpcEpRegisterNoReplace)
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ RpcEpUnregister( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
+ UUID_VECTOR* UuidVector );
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
RpcServerInqBindings( RPC_BINDING_VECTOR** BindingVector );
RPCRTAPI RPC_STATUS RPC_ENTRY
@@ -163,22 +217,37 @@
#define RpcStringBindingCompose WINELIB_NAME_AW(RpcStringBindingCompose)
RPCRTAPI RPC_STATUS RPC_ENTRY
- RpcStringFreeA(unsigned char** String);
+ RpcStringFreeA(LPSTR* String);
RPCRTAPI RPC_STATUS RPC_ENTRY
- RpcStringFreeW(unsigned short** String);
+ RpcStringFreeW(LPWSTR* String);
#define RpcStringFree WINELIB_NAME_AW(RpcStringFree)
RPCRTAPI RPC_STATUS RPC_ENTRY
- UuidCreate( UUID* Uuid );
+ UuidToStringA( UUID* Uuid, LPSTR* StringUuid );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ UuidToStringW( UUID* Uuid, LPWSTR* StringUuid );
+#define UuidToString WINELIB_NAME_AW(UuidToString)
RPCRTAPI RPC_STATUS RPC_ENTRY
- UuidToStringA( UUID* Uuid, unsigned char** StringUuid );
+ UuidFromStringA( LPSTR StringUuid, UUID* Uuid );
RPCRTAPI RPC_STATUS RPC_ENTRY
- UuidToStringW( UUID* Uuid, unsigned short** StringUuid );
-#define UuidToString WINELIB_NAME_AW(UuidToString)
+ UuidFromStringW( LPWSTR StringUuid, UUID* Uuid );
+#define UuidFromString WINELIB_NAME_AW(UuidFromString)
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ UuidCreate( UUID* Uuid );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ UuidCreateSequential( UUID* Uuid );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ UuidCreateNil( UUID* Uuid );
+RPCRTAPI signed int RPC_ENTRY
+ UuidCompare( UUID* Uuid1, UUID* Uuid2, RPC_STATUS* Status_ );
+RPCRTAPI int RPC_ENTRY
+ UuidEqual( UUID* Uuid1, UUID* Uuid2, RPC_STATUS* Status_ );
RPCRTAPI unsigned short RPC_ENTRY
UuidHash(UUID* Uuid, RPC_STATUS* Status_ );
+RPCRTAPI int RPC_ENTRY
+ UuidIsNil( UUID* Uuid, RPC_STATUS* Status_ );
#include "rpcdcep.h"
Index: wine/include/rpcdcep.h
===================================================================
RCS file: /home/wine/wine/include/rpcdcep.h,v
retrieving revision 1.2
diff -d -u -r1.2 rpcdcep.h
--- wine/include/rpcdcep.h 10 Mar 2002 00:02:34 -0000 1.2
+++ wine/include/rpcdcep.h 16 Jun 2002 10:53:43 -0000
@@ -19,7 +19,6 @@
#ifndef __WINE_RPCDCEP_H
#define __WINE_RPCDCEP_H
-
typedef struct _RPC_VERSION {
unsigned short MajorVersion;
unsigned short MinorVersion;
@@ -45,4 +44,117 @@
unsigned long RpcFlags;
} RPC_MESSAGE, *PRPC_MESSAGE;
-#endif /*__WINE_RPCDCE_H */
+typedef void __RPC_STUB (*RPC_DISPATCH_FUNCTION)(PRPC_MESSAGE Message);
+
+typedef struct
+{
+ unsigned int DispatchTableCount;
+ RPC_DISPATCH_FUNCTION* DispatchTable;
+ LONG_PTR Reserved;
+} RPC_DISPATCH_TABLE, *PRPC_DISPATCH_TABLE;
+
+typedef struct _RPC_PROTSEQ_ENDPOINT
+{
+ unsigned char* RpcProtocolSequence;
+ unsigned char* Endpoint;
+} RPC_PROTSEQ_ENDPOINT, *PRPC_PROTSEQ_ENDPOINT;
+
+#define NT351_INTERFACE_SIZE 0x40
+#define RPC_INTERFACE_HAS_PIPES 0x0001
+
+typedef struct _RPC_SERVER_INTERFACE
+{
+ unsigned int Length;
+ RPC_SYNTAX_IDENTIFIER InterfaceId;
+ RPC_SYNTAX_IDENTIFIER TransferSyntax;
+ PRPC_DISPATCH_TABLE DispatchTable;
+ unsigned int RpcProtseqEndpointCount;
+ PRPC_PROTSEQ_ENDPOINT RpcProtseqEndpoint;
+ RPC_MGR_EPV* DefaultManagerEpv;
+ void const* InterpreterInfo;
+ unsigned int Flags;
+} RPC_SERVER_INTERFACE, *PRPC_SERVER_INTERFACE;
+
+typedef struct _RPC_CLIENT_INTERFACE
+{
+ unsigned int Length;
+ RPC_SYNTAX_IDENTIFIER InterfaceId;
+ RPC_SYNTAX_IDENTIFIER TransferSyntax;
+ PRPC_DISPATCH_TABLE DispatchTable;
+ unsigned int RpcProtseqEndpointCount;
+ PRPC_PROTSEQ_ENDPOINT RpcProtseqEndpoint;
+ ULONG_PTR Reserved;
+ void const* InterpreterInfo;
+ unsigned int Flags;
+} RPC_CLIENT_INTERFACE, *PRPC_CLIENT_INTERFACE;
+
+#define TRANSPORT_TYPE_CN 0x01
+#define TRANSPORT_TYPE_DG 0x02
+#define TRANSPORT_TYPE_LPC 0x04
+#define TRANSPORT_TYPE_WMSG 0x08
+
+#ifdef WINNT
+typedef RPC_STATUS (*RPC_BLOCKING_FN)(void* hWnd, void* Context, HANDLE hSyncEvent);
+#else
+typedef RPC_STATUS (*RPC_BLOCKING_FN)(void* hWnd, void* Context, void* hSyncEvent);
+#endif
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcGetBuffer( RPC_MESSAGE* Message );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcGetBufferWithObject( RPC_MESSAGE* Message, UUID* ObjectUuid );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcSendReceive( RPC_MESSAGE* Message );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcFreeBuffer( RPC_MESSAGE* Message );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcSend( RPC_MESSAGE* Message );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcReceive( RPC_MESSAGE* Message );
+
+RPCRTAPI void* RPC_ENTRY
+ I_RpcAllocate( unsigned int Size );
+RPCRTAPI void RPC_ENTRY
+ I_RpcFree( void* Object );
+
+RPCRTAPI RPC_BINDING_HANDLE RPC_ENTRY
+ I_RpcGetCurrentCallHandle( void );
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcServerStartListening( void* hWnd );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcServerStopListening( void );
+/* WINNT */
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_GetThreadWindowHandle( HWND* hWnd );
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcAsyncSendReceive( RPC_MESSAGE* Message, void* Context, HWND hWnd );
+
+#ifdef WINNT
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcBindingSetAsync( RPC_BINDING_HANDLE Binding, RPC_BLOCKING_FN BlockingFn );
+#else
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcBindingSetAsync( RPC_BINDING_HANDLE Binding, RPC_BLOCKING_FN BlockingFn, unsigned long ServerTid );
+#endif
+
+/* WIN9x */
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcSetThreadParams( int fClientFree, void* Context, void* hWndClient );
+
+#ifdef WINNT
+RPCRTAPI LONG RPC_ENTRY
+ I_RpcWindowProc( HWND hWnd, UINT Message, WPARAM wParam, LPARAM lParam );
+#else
+RPCRTAPI unsigned int RPC_ENTRY
+ I_RpcWindowProc( void* hWnd, unsigned int Message, unsigned int wParam, unsigned long lParam );
+#endif
+
+/* WINNT */
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcSetWMsgEndpoint( WCHAR* Endpoint );
+
+RPCRTAPI RPC_STATUS RPC_ENTRY
+ I_RpcBindingInqTransportType( RPC_BINDING_HANDLE Binding, unsigned int* Type );
+
+#endif /*__WINE_RPCDCEP_H */
Index: wine/include/rpcndr.h
===================================================================
RCS file: /home/wine/wine/include/rpcndr.h,v
retrieving revision 1.5
diff -d -u -r1.5 rpcndr.h
--- wine/include/rpcndr.h 10 Mar 2002 00:02:34 -0000 1.5
+++ wine/include/rpcndr.h 16 Jun 2002 10:53:44 -0000
@@ -22,7 +22,10 @@
#ifndef __RPCNDR_H_VERSION__
/* FIXME: I'm not sure what version though */
#define __RPCNDR_H_VERSION__
-#endif // __RPCNDR_H_VERSION__
+#endif
+
+#define TARGET_IS_NT40_OR_LATER 1
+#define TARGET_IS_NT351_OR_WIN95_OR_LATER 1
typedef unsigned char byte;
typedef __int64 hyper;
@@ -31,6 +34,9 @@
typedef unsigned char _wine_boolean;
/* typedef _wine_boolean boolean; */
+#define __RPC_CALLEE WINAPI
+#define RPC_VAR_ENTRY WINAPIV
+
typedef struct
{
void *pad[2];
@@ -96,7 +102,7 @@
unsigned char *StackTop;
unsigned char *pPresentedType;
unsigned char *pTransmitType;
- handle_t SavedHandle;
+ RPC_BINDING_HANDLE SavedHandle;
const struct _MIDL_STUB_DESC *StubDesc;
struct _FULL_PTR_XLAT_TABLES *FullPtrXlatTables;
unsigned long FullPtrRefId;
@@ -146,8 +152,8 @@
void * (__RPC_API *pfnAllocate)(size_t);
void (__RPC_API *pfnFree)(void *);
union {
- handle_t *pAutoHandle;
- handle_t *pPrimitiveHandle;
+ RPC_BINDING_HANDLE *pAutoHandle;
+ RPC_BINDING_HANDLE *pPrimitiveHandle;
PGENERIC_BINDING_INFO pGenericBindingInfo;
} IMPLICIT_HANDLE_INFO;
const NDR_RUNDOWN *apfnNdrRundownRoutines;
@@ -195,6 +201,22 @@
const unsigned short *LocalFmtStringOffset;
} MIDL_SERVER_INFO, *PMIDL_SERVER_INFO;
+typedef struct _MIDL_STUBLESS_PROXY_INFO
+{
+ PMIDL_STUB_DESC pStubDesc;
+ PFORMAT_STRING ProcFormatString;
+ const unsigned short *FormatStringOffset;
+ PFORMAT_STRING LocalFormatTypes;
+ PFORMAT_STRING LocalProcStrings;
+ const unsigned short *LocalFmtStringOffset;
+} MIDL_STUBLESS_PROXY_INFO, *PMIDL_STUBLESS_PROXY_INFO;
+
+typedef union _CLIENT_CALL_RETURN
+{
+ void *Pointer;
+ LONG_PTR Simple;
+} CLIENT_CALL_RETURN;
+
typedef enum {
STUB_UNMARSHAL,
STUB_CALL_SERVER,
@@ -253,6 +275,21 @@
NdrConvert2( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, long NumberParams );
RPCRTAPI void RPC_ENTRY
NdrConvert( PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat );
+
+CLIENT_CALL_RETURN RPC_VAR_ENTRY
+ NdrClientCall2( PMIDL_STUB_DESC pStubDescriptor, PFORMAT_STRING pFormat, ... );
+CLIENT_CALL_RETURN RPC_VAR_ENTRY
+ NdrClientCall( PMIDL_STUB_DESC pStubDescriptor, PFORMAT_STRING pFormat, ... );
+
+RPCRTAPI void RPC_ENTRY
+ NdrServerCall2( PRPC_MESSAGE pRpcMsg );
+RPCRTAPI void RPC_ENTRY
+ NdrServerCall( PRPC_MESSAGE pRpcMsg );
+
+RPCRTAPI long RPC_ENTRY
+ NdrStubCall2( struct IRpcStubBuffer* pThis, struct IRpcChannelBuffer* pChannel, PRPC_MESSAGE pRpcMsg, LPDWORD pdwStubPhase );
+RPCRTAPI long RPC_ENTRY
+ NdrStubCall( struct IRpcStubBuffer* pThis, struct IRpcChannelBuffer* pChannel, PRPC_MESSAGE pRpcMsg, LPDWORD pdwStubPhase );
RPCRTAPI void* RPC_ENTRY
NdrOleAllocate( size_t Size );
Index: wine/include/rpcproxy.h
===================================================================
RCS file: /home/wine/wine/include/rpcproxy.h,v
retrieving revision 1.2
diff -d -u -r1.2 rpcproxy.h
--- wine/include/rpcproxy.h 10 Mar 2002 00:02:34 -0000 1.2
+++ wine/include/rpcproxy.h 16 Jun 2002 10:53:44 -0000
@@ -19,8 +19,14 @@
#ifndef __WINE_RPCPROXY_H
#define __WINE_RPCPROXY_H
+#ifndef __RPCPROXY_H_VERSION__
+/* FIXME: I'm not sure what version though */
+#define __RPCPROXY_H_VERSION__
+#endif
+
#include "basetsd.h"
#include "guiddef.h"
+#include "winnt.h"
typedef struct tagCInterfaceStubVtbl *PCInterfaceStubVtblList;
typedef struct tagCInterfaceProxyVtbl *PCInterfaceProxyVtblList;
@@ -47,6 +53,8 @@
#include "rpc.h"
#include "rpcndr.h"
+#include "wine/obj_base.h"
+#include "wine/obj_channel.h"
typedef struct tagCInterfaceProxyHeader
{
@@ -147,6 +155,32 @@
CStdStubBuffer_DebugServerQueryInterface, \
CStdStubBuffer_DebugServerRelease
+RPCRTAPI void RPC_ENTRY
+ NdrProxyInitialize( void *This, PRPC_MESSAGE pRpcMsg, PMIDL_STUB_MESSAGE pStubMsg,
+ PMIDL_STUB_DESC pStubDescriptor, unsigned int ProcNum );
+RPCRTAPI void RPC_ENTRY
+ NdrProxyGetBuffer( void *This, PMIDL_STUB_MESSAGE pStubMsg );
+RPCRTAPI void RPC_ENTRY
+ NdrProxySendReceive( void *This, PMIDL_STUB_MESSAGE pStubMsg );
+RPCRTAPI void RPC_ENTRY
+ NdrProxyFreeBuffer( void *This, PMIDL_STUB_MESSAGE pStubMsg );
+RPCRTAPI HRESULT RPC_ENTRY
+ NdrProxyErrorHandler( DWORD dwExceptionCode );
+
+RPCRTAPI void RPC_ENTRY
+ NdrStubInitialize( PRPC_MESSAGE pRpcMsg, PMIDL_STUB_MESSAGE pStubMsg,
+ PMIDL_STUB_DESC pStubDescriptor, IRpcChannelBuffer *pRpcChannelBuffer );
+RPCRTAPI void RPC_ENTRY
+ NdrStubInitializePartial( PRPC_MESSAGE pRpcMsg, PMIDL_STUB_MESSAGE pStubMsg,
+ PMIDL_STUB_DESC pStubDescriptor, IRpcChannelBuffer *pRpcChannelBuffer,
+ unsigned long RequestedBufferSize );
+void __RPC_STUB NdrStubForwardingFunction( IRpcStubBuffer *This, IRpcChannelBuffer *pChannel,
+ PRPC_MESSAGE pMsg, DWORD *pdwStubPhase );
+RPCRTAPI void RPC_ENTRY
+ NdrStubGetBuffer( IRpcStubBuffer *This, IRpcChannelBuffer *pRpcChannelBuffer, PMIDL_STUB_MESSAGE pStubMsg );
+RPCRTAPI HRESULT RPC_ENTRY
+ NdrStubErrorHandler( DWORD dwExceptionCode );
+
RPCRTAPI HRESULT RPC_ENTRY
NdrDllGetClassObject( REFCLSID rclsid, REFIID riid, void **ppv, const ProxyFileInfo **pProxyFileList,
const CLSID *pclsid, CStdPSFactoryBuffer *pPSFactoryBuffer );
@@ -161,6 +195,8 @@
#define CSTDSTUBBUFFERRELEASE(pFactory) \
ULONG WINAPI CStdStubBuffer_Release(IRpcStubBuffer *This) \
{ return NdrCStdStubBuffer_Release(This, (IPSFactoryBuffer *)pFactory); }
+
+#define IID_GENERIC_CHECK_IID(name,pIID,index) memcmp(pIID, name##_ProxyVtblList[index]->header.piid, sizeof(IID))
#if defined(__WINE__) && defined(__WINE_WINE_OBJ_OLEAUT_H)
/* see http://msdn.microsoft.com/library/en-us/dnmsj99/html/com0199.asp?frame=true */
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/cproxy.c Thu Jun 13 17:15:25 2002
@@ -0,0 +1,276 @@
+/*
+ * COM proxy implementation
+ *
+ * Copyright 2001 Ove K�en, TransGaming Technologies
+ */
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+#include "wine/obj_base.h"
+#include "wine/obj_channel.h"
+
+#include "rpcproxy.h"
+
+#include "cpsf.h"
+#include "ndr_misc.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+struct StublessThunk;
+
+/* I don't know what MS's std proxy structure looks like,
+ so this probably doesn't match, but that shouldn't matter */
+typedef struct {
+ ICOM_VTABLE(IRpcProxyBuffer) *lpVtbl;
+ LPVOID *PVtbl;
+ DWORD RefCount;
+ const MIDL_STUBLESS_PROXY_INFO *stubless;
+ const IID* piid;
+ LPUNKNOWN pUnkOuter;
+ LPPSFACTORYBUFFER pPSFactory;
+ LPRPCCHANNELBUFFER pChannel;
+ struct StublessThunk *thunks;
+} StdProxyImpl;
+
+static ICOM_VTABLE(IRpcProxyBuffer) StdProxy_Vtbl;
+
+/* How the Windows stubless proxy thunks work is explained at
+ * http://msdn.microsoft.com/library/en-us/dnmsj99/html/com0199.asp,
+ * but I'll use a slightly different method, to make life easier */
+
+#if defined(__i386__)
+
+struct StublessThunk {
+ BYTE push WINE_PACKED;
+ DWORD index WINE_PACKED;
+ BYTE call WINE_PACKED;
+ LONG handler WINE_PACKED;
+ BYTE ret WINE_PACKED;
+ WORD bytes WINE_PACKED;
+ BYTE pad[3];
+};
+
+/* adjust the stack size since we don't use Windows's method */
+#define STACK_ADJUST sizeof(DWORD)
+
+#define FILL_STUBLESS(x,idx,stk) \
+ x->push = 0x68; /* pushl [immediate] */ \
+ x->index = (idx); \
+ x->call = 0xe8; /* call [near] */ \
+ x->handler = (char*)ObjectStubless - (char*)&x->ret; \
+ x->ret = 0xc2; /* ret [immediate] */ \
+ x->bytes = stk; \
+ x->pad[0] = 0x8d; /* leal (%esi),%esi */ \
+ x->pad[1] = 0x76; \
+ x->pad[2] = 0x00;
+
+#else
+/* can't do that on this arch */
+struct ObjectStubless {};
+#define FILL_STUBLESS(x,idx) \
+ ERR("stubless proxies are not supported on this architecture\n");
+#endif
+
+static HRESULT WINAPI ObjectStubless(DWORD index)
+{
+ char *args = (char*)(&index + 2);
+ LPVOID iface = *(LPVOID*)args;
+ ICOM_THIS_MULTI(StdProxyImpl,PVtbl,iface);
+ PFORMAT_STRING fs = This->stubless->ProcFormatString + This->stubless->FormatStringOffset[index];
+ unsigned bytes = *(WORD*)(fs+8) - STACK_ADJUST;
+ TRACE("(%p)->(%ld)([%d bytes]) ret=%08lx\n", iface, index, bytes, *(DWORD*)(args+bytes));
+ return RPCRT4_NdrClientCall2(This->stubless->pStubDesc, fs, args);
+}
+
+HRESULT WINAPI StdProxy_Construct(REFIID riid,
+ LPUNKNOWN pUnkOuter,
+ CInterfaceProxyVtbl *vtbl,
+ CInterfaceStubVtbl *svtbl,
+ LPPSFACTORYBUFFER pPSFactory,
+ LPRPCPROXYBUFFER *ppProxy,
+ LPVOID *ppvObj)
+{
+ StdProxyImpl *This;
+ const MIDL_STUBLESS_PROXY_INFO *stubless = NULL;
+ TRACE("(%p,%p,%p,%p,%p)\n", pUnkOuter, vtbl, pPSFactory, ppProxy, ppvObj);
+ /* I can't find any other way to detect stubless proxies than this hack */
+ if (!IsEqualGUID(vtbl->header.piid, riid)) {
+ stubless = *((const void **)vtbl)++;
+ TRACE("stubless=%p\n", stubless);
+ }
+ TRACE("iid=%s\n", debugstr_guid(vtbl->header.piid));
+ TRACE("vtbl=%p\n", vtbl->Vtbl);
+ if (!IsEqualGUID(vtbl->header.piid, riid)) {
+ ERR("IID mismatch during proxy creation\n");
+ return RPC_E_UNEXPECTED;
+ }
+ This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(StdProxyImpl));
+ if (!This) return E_OUTOFMEMORY;
+ if (stubless) {
+ unsigned i, count = svtbl->header.DispatchTableCount;
+ /* Maybe the original vtbl is just modified directly to point at
+ * ObjectStublessClientXXX thunks in real Windows, but I don't like it
+ */
+ TRACE("stubless thunks: count=%d\n", count);
+ This->thunks = HeapAlloc(GetProcessHeap(),0,sizeof(struct StublessThunk)*count);
+ This->PVtbl = HeapAlloc(GetProcessHeap(),0,sizeof(LPVOID)*count);
+ for (i=0; i<count; i++) {
+ struct StublessThunk *thunk = &This->thunks[i];
+ if (vtbl->Vtbl[i] == (LPVOID)-1) {
+ PFORMAT_STRING fs = stubless->ProcFormatString + stubless->FormatStringOffset[i];
+ unsigned bytes = *(WORD*)(fs+8) - STACK_ADJUST;
+ TRACE("method %d: stacksize=%d\n", i, bytes);
+ FILL_STUBLESS(thunk, i, bytes)
+ This->PVtbl[i] = thunk;
+ }
+ else {
+ memset(thunk, 0, sizeof(struct StublessThunk));
+ This->PVtbl[i] = vtbl->Vtbl[i];
+ }
+ }
+ }
+ else This->PVtbl = vtbl->Vtbl;
+ This->lpVtbl = &StdProxy_Vtbl;
+ This->RefCount = 1;
+ This->stubless = stubless;
+ This->piid = vtbl->header.piid;
+ This->pUnkOuter = pUnkOuter;
+ This->pPSFactory = pPSFactory;
+ This->pChannel = NULL;
+ *ppProxy = (LPRPCPROXYBUFFER)&This->lpVtbl;
+ *ppvObj = &This->PVtbl;
+ IPSFactoryBuffer_AddRef(pPSFactory);
+ return S_OK;
+}
+
+static void WINAPI StdProxy_Destruct(LPRPCPROXYBUFFER iface)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,lpVtbl,iface);
+ IPSFactoryBuffer_Release(This->pPSFactory);
+ if (This->thunks) {
+ HeapFree(GetProcessHeap(),0,This->PVtbl);
+ HeapFree(GetProcessHeap(),0,This->thunks);
+ }
+ HeapFree(GetProcessHeap(),0,This);
+}
+
+static HRESULT WINAPI StdProxy_QueryInterface(LPRPCPROXYBUFFER iface,
+ REFIID riid,
+ LPVOID *obj)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,lpVtbl,iface);
+ TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
+ if (IsEqualGUID(&IID_IUnknown,riid) ||
+ IsEqualGUID(This->piid,riid)) {
+ *obj = &This->PVtbl;
+ This->RefCount++;
+ return S_OK;
+ }
+ if (IsEqualGUID(&IID_IRpcProxyBuffer,riid)) {
+ *obj = &This->lpVtbl;
+ This->RefCount++;
+ return S_OK;
+ }
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI StdProxy_AddRef(LPRPCPROXYBUFFER iface)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,lpVtbl,iface);
+ TRACE("(%p)->AddRef()\n",This);
+ return ++(This->RefCount);
+}
+
+static ULONG WINAPI StdProxy_Release(LPRPCPROXYBUFFER iface)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,lpVtbl,iface);
+ TRACE("(%p)->Release()\n",This);
+ if (!--(This->RefCount)) {
+ StdProxy_Destruct((LPRPCPROXYBUFFER)&This->lpVtbl);
+ return 0;
+ }
+ return This->RefCount;
+}
+
+static HRESULT WINAPI StdProxy_Connect(LPRPCPROXYBUFFER iface,
+ LPRPCCHANNELBUFFER pChannel)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,lpVtbl,iface);
+ TRACE("(%p)->Connect(%p)\n",This,pChannel);
+ This->pChannel = pChannel;
+ return S_OK;
+}
+
+static VOID WINAPI StdProxy_Disconnect(LPRPCPROXYBUFFER iface)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,lpVtbl,iface);
+ TRACE("(%p)->Disconnect()\n",This);
+ This->pChannel = NULL;
+}
+
+static ICOM_VTABLE(IRpcProxyBuffer) StdProxy_Vtbl =
+{
+ ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+ StdProxy_QueryInterface,
+ StdProxy_AddRef,
+ StdProxy_Release,
+ StdProxy_Connect,
+ StdProxy_Disconnect
+};
+
+HRESULT WINAPI StdProxy_GetChannel(LPVOID iface,
+ LPRPCCHANNELBUFFER *ppChannel)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,PVtbl,iface);
+ TRACE("(%p)->GetChannel(%p)\n",This,ppChannel);
+ *ppChannel = This->pChannel;
+ return S_OK;
+}
+
+HRESULT WINAPI StdProxy_GetIID(LPVOID iface,
+ const IID **ppiid)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,PVtbl,iface);
+ TRACE("(%p)->GetIID(%p)\n",This,ppiid);
+ *ppiid = This->piid;
+ return S_OK;
+}
+
+HRESULT WINAPI IUnknown_QueryInterface_Proxy(LPUNKNOWN iface,
+ REFIID riid,
+ LPVOID *ppvObj)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,PVtbl,iface);
+ TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),ppvObj);
+ return IUnknown_QueryInterface(This->pUnkOuter,riid,ppvObj);
+}
+
+ULONG WINAPI IUnknown_AddRef_Proxy(LPUNKNOWN iface)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,PVtbl,iface);
+ TRACE("(%p)->AddRef()\n",This);
+#if 0 /* interface refcounting */
+ return ++(This->RefCount);
+#else /* object refcounting */
+ return IUnknown_AddRef(This->pUnkOuter);
+#endif
+}
+
+ULONG WINAPI IUnknown_Release_Proxy(LPUNKNOWN iface)
+{
+ ICOM_THIS_MULTI(StdProxyImpl,PVtbl,iface);
+ TRACE("(%p)->Release()\n",This);
+#if 0 /* interface refcounting */
+ if (!--(This->RefCount)) {
+ StdProxy_Destruct((LPRPCPROXYBUFFER)&This->lpVtbl);
+ return 0;
+ }
+ return This->RefCount;
+#else /* object refcounting */
+ return IUnknown_Release(This->pUnkOuter);
+#endif
+}
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/cpsf.c Thu Jun 13 17:15:56 2002
@@ -0,0 +1,245 @@
+/*
+ * COM proxy/stub factory (CStdPSFactory) implementation
+ *
+ * Copyright 2001 Ove K�en, TransGaming Technologies
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+
+#include "wine/obj_base.h"
+#include "wine/obj_channel.h"
+
+#include "rpcproxy.h"
+
+#include "wine/debug.h"
+
+#include "cpsf.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+static BOOL FindProxyInfo(const ProxyFileInfo **pProxyFileList, REFIID riid, const ProxyFileInfo **pProxyInfo, int *pIndex)
+{
+ while (*pProxyFileList) {
+ if ((*pProxyFileList)->pIIDLookupRtn(riid, pIndex)) {
+ *pProxyInfo = *pProxyFileList;
+ TRACE("found: ProxyInfo %p Index %d\n", *pProxyInfo, *pIndex);
+ return TRUE;
+ }
+ pProxyFileList++;
+ }
+ TRACE("not found\n");
+ return FALSE;
+}
+
+static HRESULT WINAPI CStdPSFactory_QueryInterface(LPPSFACTORYBUFFER iface,
+ REFIID riid,
+ LPVOID *obj)
+{
+ ICOM_THIS(CStdPSFactoryBuffer,iface);
+ TRACE("(%p)->QueryInterface(%s,%p)\n",iface,debugstr_guid(riid),obj);
+ if (IsEqualGUID(&IID_IUnknown,riid) ||
+ IsEqualGUID(&IID_IPSFactoryBuffer,riid)) {
+ *obj = This;
+ This->RefCount++;
+ return S_OK;
+ }
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI CStdPSFactory_AddRef(LPPSFACTORYBUFFER iface)
+{
+ ICOM_THIS(CStdPSFactoryBuffer,iface);
+ TRACE("(%p)->AddRef()\n",iface);
+ return ++(This->RefCount);
+}
+
+static ULONG WINAPI CStdPSFactory_Release(LPPSFACTORYBUFFER iface)
+{
+ ICOM_THIS(CStdPSFactoryBuffer,iface);
+ TRACE("(%p)->Release()\n",iface);
+ return --(This->RefCount);
+}
+
+static HRESULT WINAPI CStdPSFactory_CreateProxy(LPPSFACTORYBUFFER iface,
+ LPUNKNOWN pUnkOuter,
+ REFIID riid,
+ LPRPCPROXYBUFFER *ppProxy,
+ LPVOID *ppv)
+{
+ ICOM_THIS(CStdPSFactoryBuffer,iface);
+ const ProxyFileInfo *ProxyInfo;
+ int Index;
+ TRACE("(%p)->CreateProxy(%p,%s,%p,%p)\n",iface,pUnkOuter,
+ debugstr_guid(riid),ppProxy,ppv);
+ if (!FindProxyInfo(This->pProxyFileList,riid,&ProxyInfo,&Index))
+ return E_NOINTERFACE;
+ return StdProxy_Construct(riid, pUnkOuter, ProxyInfo->pProxyVtblList[Index],
+ ProxyInfo->pStubVtblList[Index], iface, ppProxy, ppv);
+}
+
+static HRESULT WINAPI CStdPSFactory_CreateStub(LPPSFACTORYBUFFER iface,
+ REFIID riid,
+ LPUNKNOWN pUnkServer,
+ LPRPCSTUBBUFFER *ppStub)
+{
+ ICOM_THIS(CStdPSFactoryBuffer,iface);
+ const ProxyFileInfo *ProxyInfo;
+ int Index;
+ TRACE("(%p)->CreateStub(%s,%p,%p)\n",iface,debugstr_guid(riid),
+ pUnkServer,ppStub);
+ if (!FindProxyInfo(This->pProxyFileList,riid,&ProxyInfo,&Index))
+ return E_NOINTERFACE;
+ return CStdStubBuffer_Construct(riid, pUnkServer, ProxyInfo->pStubVtblList[Index], iface, ppStub);
+}
+
+static ICOM_VTABLE(IPSFactoryBuffer) CStdPSFactory_Vtbl =
+{
+ ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+ CStdPSFactory_QueryInterface,
+ CStdPSFactory_AddRef,
+ CStdPSFactory_Release,
+ CStdPSFactory_CreateProxy,
+ CStdPSFactory_CreateStub
+};
+
+/***********************************************************************
+ * NdrDllGetClassObject [RPCRT4.@]
+ */
+HRESULT WINAPI NdrDllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv,
+ const ProxyFileInfo **pProxyFileList,
+ const CLSID *pclsid,
+ CStdPSFactoryBuffer *pPSFactoryBuffer)
+{
+ *ppv = NULL;
+ if (!pPSFactoryBuffer->lpVtbl) {
+ pPSFactoryBuffer->lpVtbl = &CStdPSFactory_Vtbl;
+ pPSFactoryBuffer->RefCount = 0;
+ pPSFactoryBuffer->pProxyFileList = pProxyFileList;
+ }
+ if (IsEqualGUID(rclsid, pclsid))
+ return IPSFactoryBuffer_QueryInterface((LPPSFACTORYBUFFER)pPSFactoryBuffer, iid, ppv);
+ return CLASS_E_CLASSNOTAVAILABLE;
+}
+
+/***********************************************************************
+ * NdrDllCanUnloadNow [RPCRT4.@]
+ */
+HRESULT WINAPI NdrDllCanUnloadNow(CStdPSFactoryBuffer *pPSFactoryBuffer)
+{
+ return !(pPSFactoryBuffer->RefCount);
+}
+
+/***********************************************************************
+ * NdrDllRegisterProxy [RPCRT4.@]
+ */
+HRESULT WINAPI NdrDllRegisterProxy(HMODULE hDll,
+ const ProxyFileInfo **pProxyFileList,
+ const CLSID *pclsid)
+{
+/* #define INSTALLSHIELD_HACK */
+#ifndef INSTALLSHIELD_HACK
+ LPSTR clsid;
+ char keyname[120], module[120];
+ HKEY key, subkey;
+
+ TRACE("(%x,%p,%s)\n", hDll, pProxyFileList, debugstr_guid(pclsid));
+ UuidToStringA((UUID*)pclsid, &clsid);
+
+ /* register interfaces to point to clsid */
+ while (*pProxyFileList) {
+ unsigned u;
+ for (u=0; u<(*pProxyFileList)->TableSize; u++) {
+ CInterfaceProxyVtbl *proxy = (*pProxyFileList)->pProxyVtblList[u];
+ PCInterfaceName name = (*pProxyFileList)->pNamesArray[u];
+ LPSTR iid;
+
+ TRACE("registering %s %s => %s\n", name, debugstr_guid(proxy->header.piid), clsid);
+
+ UuidToStringA((UUID*)proxy->header.piid, &iid);
+ snprintf(keyname, sizeof(keyname), "Interface\\%s", iid);
+ RpcStringFreeA(&iid);
+ if (RegCreateKeyExA(HKEY_CLASSES_ROOT, keyname, 0, NULL, 0,
+ KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS) {
+ if (name)
+ RegSetValueExA(key, NULL, 0, REG_SZ, name, strlen(name));
+ if (RegCreateKeyExA(key, "ProxyStubClsid32", 0, NULL, 0,
+ KEY_WRITE, NULL, &subkey, NULL) == ERROR_SUCCESS) {
+ RegSetValueExA(subkey, NULL, 0, REG_SZ, clsid, strlen(clsid));
+ RegCloseKey(subkey);
+ }
+ RegCloseKey(key);
+ }
+ }
+ pProxyFileList++;
+ }
+
+ /* register clsid to point to module */
+ snprintf(keyname, sizeof(keyname), "CLSID\\%s", clsid);
+ GetModuleFileNameA(hDll, module, sizeof(module));
+ TRACE("registering %s => %s\n", clsid, module);
+ if (RegCreateKeyExA(HKEY_CLASSES_ROOT, keyname, 0, NULL, 0,
+ KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS) {
+ if (RegCreateKeyExA(key, "InProcServer32", 0, NULL, 0,
+ KEY_WRITE, NULL, &subkey, NULL) == ERROR_SUCCESS) {
+ RegSetValueExA(subkey, NULL, 0, REG_SZ, module, strlen(module));
+ RegCloseKey(subkey);
+ }
+ RegCloseKey(key);
+ }
+
+ /* done */
+ RpcStringFreeA(&clsid);
+#endif
+ return S_OK;
+}
+
+/***********************************************************************
+ * NdrDllUnregisterProxy [RPCRT4.@]
+ */
+HRESULT WINAPI NdrDllUnregisterProxy(HMODULE hDll,
+ const ProxyFileInfo **pProxyFileList,
+ const CLSID *pclsid)
+{
+#ifndef INSTALLSHIELD_HACK
+ LPSTR clsid;
+ char keyname[120], module[120];
+
+ TRACE("(%x,%p,%s)\n", hDll, pProxyFileList, debugstr_guid(pclsid));
+ UuidToStringA((UUID*)pclsid, &clsid);
+
+ /* unregister interfaces */
+ while (*pProxyFileList) {
+ unsigned u;
+ for (u=0; u<(*pProxyFileList)->TableSize; u++) {
+ CInterfaceProxyVtbl *proxy = (*pProxyFileList)->pProxyVtblList[u];
+ PCInterfaceName name = (*pProxyFileList)->pNamesArray[u];
+ LPSTR iid;
+
+ TRACE("unregistering %s %s <= %s\n", name, debugstr_guid(proxy->header.piid), clsid);
+
+ UuidToStringA((UUID*)proxy->header.piid, &iid);
+ snprintf(keyname, sizeof(keyname), "Interface\\%s", iid);
+ RpcStringFreeA(&iid);
+ RegDeleteKeyA(HKEY_CLASSES_ROOT, keyname);
+ }
+ pProxyFileList++;
+ }
+
+ /* unregister clsid */
+ snprintf(keyname, sizeof(keyname), "CLSID\\%s", clsid);
+ GetModuleFileNameA(hDll, module, sizeof(module));
+ TRACE("unregistering %s <= %s\n", clsid, module);
+ RegDeleteKeyA(HKEY_CLASSES_ROOT, keyname);
+
+ /* done */
+ RpcStringFreeA(&clsid);
+#endif
+ return S_OK;
+}
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/cstub.c Thu Jun 13 17:16:27 2002
@@ -0,0 +1,141 @@
+/*
+ * COM stub (CStdStubBuffer) implementation
+ *
+ * Copyright 2001 Ove K�en, TransGaming Technologies
+ */
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+
+#include "wine/obj_base.h"
+#include "wine/obj_channel.h"
+
+#include "rpcproxy.h"
+
+#include "wine/debug.h"
+
+#include "cpsf.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+#define STUB_HEADER(This) (((CInterfaceStubHeader*)((This)->lpVtbl))[-1])
+
+HRESULT WINAPI CStdStubBuffer_Construct(REFIID riid,
+ LPUNKNOWN pUnkServer,
+ CInterfaceStubVtbl *vtbl,
+ LPPSFACTORYBUFFER pPSFactory,
+ LPRPCSTUBBUFFER *ppStub)
+{
+ CStdStubBuffer *This;
+ TRACE("(%p,%p,%p,%p)\n", pUnkServer, vtbl, pPSFactory, ppStub);
+ TRACE("iid=%s\n", debugstr_guid(vtbl->header.piid));
+ TRACE("vtbl=%p\n", &vtbl->Vtbl);
+ if (!IsEqualGUID(vtbl->header.piid, riid)) {
+ ERR("IID mismatch during stub creation\n");
+ return RPC_E_UNEXPECTED;
+ }
+ This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CStdStubBuffer));
+ if (!This) return E_OUTOFMEMORY;
+ This->lpVtbl = &vtbl->Vtbl;
+ This->RefCount = 1;
+ This->pvServerObject = pUnkServer;
+ This->pPSFactory = pPSFactory;
+ *ppStub = (LPRPCSTUBBUFFER)This;
+ IPSFactoryBuffer_AddRef(pPSFactory);
+ return S_OK;
+}
+
+HRESULT WINAPI CStdStubBuffer_QueryInterface(LPRPCSTUBBUFFER iface,
+ REFIID riid,
+ LPVOID *obj)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
+ if (IsEqualGUID(&IID_IUnknown,riid) ||
+ IsEqualGUID(&IID_IRpcStubBuffer,riid)) {
+ *obj = This;
+ This->RefCount++;
+ return S_OK;
+ }
+ return E_NOINTERFACE;
+}
+
+ULONG WINAPI CStdStubBuffer_AddRef(LPRPCSTUBBUFFER iface)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->AddRef()\n",This);
+ return ++(This->RefCount);
+}
+
+ULONG WINAPI NdrCStdStubBuffer_Release(LPRPCSTUBBUFFER iface,
+ LPPSFACTORYBUFFER pPSF)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->Release()\n",This);
+ if (!--(This->RefCount)) {
+ IUnknown_Release(This->pvServerObject);
+ IPSFactoryBuffer_Release(This->pPSFactory);
+ HeapFree(GetProcessHeap(),0,This);
+ return 0;
+ }
+ return This->RefCount;
+}
+
+HRESULT WINAPI CStdStubBuffer_Connect(LPRPCSTUBBUFFER iface,
+ LPUNKNOWN lpUnkServer)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->Connect(%p)\n",This,lpUnkServer);
+ This->pvServerObject = lpUnkServer;
+ return S_OK;
+}
+
+void WINAPI CStdStubBuffer_Disconnect(LPRPCSTUBBUFFER iface)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->Disconnect()\n",This);
+ This->pvServerObject = NULL;
+}
+
+HRESULT WINAPI CStdStubBuffer_Invoke(LPRPCSTUBBUFFER iface,
+ PRPCOLEMESSAGE pMsg,
+ LPRPCCHANNELBUFFER pChannel)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ DWORD dwPhase = STUB_UNMARSHAL;
+ TRACE("(%p)->Invoke(%p,%p)\n",This,pMsg,pChannel);
+ STUB_HEADER(This).pDispatchTable[pMsg->iMethod](iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
+ return S_OK;
+}
+
+LPRPCSTUBBUFFER WINAPI CStdStubBuffer_IsIIDSupported(LPRPCSTUBBUFFER iface,
+ REFIID riid)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->IsIIDSupported(%s)\n",This,debugstr_guid(riid));
+ return IsEqualGUID(STUB_HEADER(This).piid, riid) ? iface : NULL;
+}
+
+ULONG WINAPI CStdStubBuffer_CountRefs(LPRPCSTUBBUFFER iface)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->CountRefs()\n",This);
+ return This->RefCount;
+}
+
+HRESULT WINAPI CStdStubBuffer_DebugServerQueryInterface(LPRPCSTUBBUFFER iface,
+ LPVOID *ppv)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->DebugServerQueryInterface(%p)\n",This,ppv);
+ return S_OK;
+}
+
+void WINAPI CStdStubBuffer_DebugServerRelease(LPRPCSTUBBUFFER iface,
+ LPVOID pv)
+{
+ ICOM_THIS(CStdStubBuffer,iface);
+ TRACE("(%p)->DebugServerRelease(%p)\n",This,pv);
+}
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/ndr_midl.c Thu Jun 13 17:16:55 2002
@@ -0,0 +1,157 @@
+/*
+ * MIDL proxy/stub stuff
+ *
+ * Copyright 2002 Ove K�en, TransGaming Technologies
+ *
+ * TODO:
+ * - figure out whether we *really* got this right
+ * - check for errors and throw exceptions
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+
+#include "wine/obj_base.h"
+#include "wine/obj_channel.h"
+
+#include "rpcproxy.h"
+
+#include "wine/debug.h"
+
+#include "cpsf.h"
+#include "ndr_misc.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+/***********************************************************************
+ * NdrProxyInitialize [RPCRT4.@]
+ */
+void WINAPI NdrProxyInitialize(void *This,
+ PRPC_MESSAGE pRpcMsg,
+ PMIDL_STUB_MESSAGE pStubMsg,
+ PMIDL_STUB_DESC pStubDescriptor,
+ unsigned int ProcNum)
+{
+ HRESULT hr;
+
+ TRACE("(%p,%p,%p,%p,%d)\n", This, pRpcMsg, pStubMsg, pStubDescriptor, ProcNum);
+ memset(pRpcMsg, 0, sizeof(RPC_MESSAGE));
+ memset(pStubMsg, 0, sizeof(MIDL_STUB_MESSAGE));
+ pRpcMsg->ProcNum = ProcNum;
+ pRpcMsg->RpcInterfaceInformation = pStubDescriptor->RpcInterfaceInformation;
+ pStubMsg->RpcMsg = pRpcMsg;
+ pStubMsg->IsClient = 1;
+ pStubMsg->ReuseBuffer = 1;
+ pStubMsg->pfnAllocate = pStubDescriptor->pfnAllocate;
+ pStubMsg->pfnFree = pStubDescriptor->pfnFree;
+ pStubMsg->StubDesc = pStubDescriptor;
+ if (This) StdProxy_GetChannel(This, &pStubMsg->pRpcChannelBuffer);
+ if (pStubMsg->pRpcChannelBuffer) {
+ hr = IRpcChannelBuffer_GetDestCtx(pStubMsg->pRpcChannelBuffer,
+ &pStubMsg->dwDestContext,
+ &pStubMsg->pvDestContext);
+ }
+ TRACE("channel=%p\n", pStubMsg->pRpcChannelBuffer);
+}
+
+/***********************************************************************
+ * NdrProxyGetBuffer [RPCRT4.@]
+ */
+void WINAPI NdrProxyGetBuffer(void *This,
+ PMIDL_STUB_MESSAGE pStubMsg)
+{
+ HRESULT hr;
+ const IID *riid = NULL;
+
+ TRACE("(%p,%p)\n", This, pStubMsg);
+ pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
+ pStubMsg->dwStubPhase = PROXY_GETBUFFER;
+ hr = StdProxy_GetIID(This, &riid);
+ hr = IRpcChannelBuffer_GetBuffer(pStubMsg->pRpcChannelBuffer,
+ (RPCOLEMESSAGE*)pStubMsg->RpcMsg,
+ riid);
+ pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
+ pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
+ pStubMsg->Buffer = pStubMsg->BufferStart;
+ pStubMsg->dwStubPhase = PROXY_MARSHAL;
+}
+
+/***********************************************************************
+ * NdrProxySendReceive [RPCRT4.@]
+ */
+void WINAPI NdrProxySendReceive(void *This,
+ PMIDL_STUB_MESSAGE pStubMsg)
+{
+ ULONG Status = 0;
+ HRESULT hr;
+
+ TRACE("(%p,%p)\n", This, pStubMsg);
+ pStubMsg->dwStubPhase = PROXY_SENDRECEIVE;
+ hr = IRpcChannelBuffer_SendReceive(pStubMsg->pRpcChannelBuffer,
+ (RPCOLEMESSAGE*)pStubMsg->RpcMsg,
+ &Status);
+ pStubMsg->dwStubPhase = PROXY_UNMARSHAL;
+ pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
+ pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
+ pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
+ pStubMsg->Buffer = pStubMsg->BufferStart;
+}
+
+/***********************************************************************
+ * NdrProxyFreeBuffer [RPCRT4.@]
+ */
+void WINAPI NdrProxyFreeBuffer(void *This,
+ PMIDL_STUB_MESSAGE pStubMsg)
+{
+ HRESULT hr;
+
+ TRACE("(%p,%p)\n", This, pStubMsg);
+ hr = IRpcChannelBuffer_FreeBuffer(pStubMsg->pRpcChannelBuffer,
+ (RPCOLEMESSAGE*)pStubMsg->RpcMsg);
+}
+
+/***********************************************************************
+ * NdrStubInitialize [RPCRT4.@]
+ */
+void WINAPI NdrStubInitialize(PRPC_MESSAGE pRpcMsg,
+ PMIDL_STUB_MESSAGE pStubMsg,
+ PMIDL_STUB_DESC pStubDescriptor,
+ LPRPCCHANNELBUFFER pRpcChannelBuffer)
+{
+ TRACE("(%p,%p,%p,%p)\n", pRpcMsg, pStubMsg, pStubDescriptor, pRpcChannelBuffer);
+ memset(pStubMsg, 0, sizeof(MIDL_STUB_MESSAGE));
+ pStubMsg->RpcMsg = pRpcMsg;
+ pStubMsg->IsClient = 0;
+ pStubMsg->ReuseBuffer = 1;
+ pStubMsg->pfnAllocate = pStubDescriptor->pfnAllocate;
+ pStubMsg->pfnFree = pStubDescriptor->pfnFree;
+ pStubMsg->StubDesc = pStubDescriptor;
+ pStubMsg->pRpcChannelBuffer = pRpcChannelBuffer;
+ pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
+ pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
+ pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
+ pStubMsg->Buffer = pStubMsg->BufferStart;
+}
+
+/***********************************************************************
+ * NdrStubGetBuffer [RPCRT4.@]
+ */
+void WINAPI NdrStubGetBuffer(LPRPCSTUBBUFFER This,
+ LPRPCCHANNELBUFFER pRpcChannelBuffer,
+ PMIDL_STUB_MESSAGE pStubMsg)
+{
+ TRACE("(%p,%p)\n", This, pStubMsg);
+ pStubMsg->pRpcChannelBuffer = pRpcChannelBuffer;
+ pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
+ I_RpcGetBuffer(pStubMsg->RpcMsg); /* ? */
+ pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
+ pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
+ pStubMsg->Buffer = pStubMsg->BufferStart;
+}
+
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/ndr_ole.c Thu Jun 13 17:17:39 2002
@@ -0,0 +1,319 @@
+/*
+ * OLE32 callouts, COM interface marshalling
+ *
+ * Copyright 2001 Ove K�en, TransGaming Technologies
+ *
+ * TODO:
+ * - figure out whether we *really* got this right
+ * - check for errors and throw exceptions
+ * - what's the marshalling functions supposed to return?
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+
+#include "wine/obj_base.h"
+#include "wine/obj_storage.h"
+#include "wine/obj_marshal.h"
+#include "wine/obj_channel.h"
+
+#include "rpcndr.h"
+
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+static HMODULE hOLE;
+
+static HRESULT WINAPI (*COM_GetMarshalSizeMax)(ULONG *,REFIID,LPUNKNOWN,DWORD,LPVOID,DWORD);
+static HRESULT WINAPI (*COM_MarshalInterface)(LPSTREAM,REFIID,LPUNKNOWN,DWORD,LPVOID,DWORD);
+static HRESULT WINAPI (*COM_UnmarshalInterface)(LPSTREAM,REFIID,LPVOID*);
+static HRESULT WINAPI (*COM_ReleaseMarshalData)(LPSTREAM);
+static HRESULT WINAPI (*COM_GetClassObject)(REFCLSID,DWORD,COSERVERINFO *,REFIID,LPVOID *);
+static HRESULT WINAPI (*COM_GetPSClsid)(REFIID,CLSID *);
+static LPVOID WINAPI (*COM_MemAlloc)(ULONG);
+static void WINAPI (*COM_MemFree)(LPVOID);
+
+static HMODULE LoadCOM(void)
+{
+ if (hOLE) return hOLE;
+ hOLE = LoadLibraryA("OLE32.DLL");
+ if (!hOLE) return 0;
+ COM_GetMarshalSizeMax = (LPVOID)GetProcAddress(hOLE, "CoGetMarshalSizeMax");
+ COM_MarshalInterface = (LPVOID)GetProcAddress(hOLE, "CoMarshalInterface");
+ COM_UnmarshalInterface = (LPVOID)GetProcAddress(hOLE, "CoUnmarshalInterface");
+ COM_ReleaseMarshalData = (LPVOID)GetProcAddress(hOLE, "CoReleaseMarshalData");
+ COM_GetClassObject = (LPVOID)GetProcAddress(hOLE, "CoGetClassObject");
+ COM_GetPSClsid = (LPVOID)GetProcAddress(hOLE, "CoGetPSClsid");
+ COM_MemAlloc = (LPVOID)GetProcAddress(hOLE, "CoTaskMemAlloc");
+ COM_MemFree = (LPVOID)GetProcAddress(hOLE, "CoTaskMemFree");
+ return hOLE;
+}
+
+/* CoMarshalInterface/CoUnmarshalInterface works on streams,
+ * so implement a simple stream on top of the RPC buffer
+ * (which also implements the MInterfacePointer structure) */
+typedef struct RpcStreamImpl
+{
+ ICOM_VFIELD(IStream);
+ DWORD RefCount;
+ PMIDL_STUB_MESSAGE pMsg;
+ LPDWORD size;
+ char *data;
+ DWORD pos;
+} RpcStreamImpl;
+
+static HRESULT WINAPI RpcStream_QueryInterface(LPSTREAM iface,
+ REFIID riid,
+ LPVOID *obj)
+{
+ ICOM_THIS(RpcStreamImpl, iface);
+ if (IsEqualGUID(&IID_IUnknown, riid) ||
+ IsEqualGUID(&IID_ISequentialStream, riid) ||
+ IsEqualGUID(&IID_IStream, riid)) {
+ *obj = This;
+ This->RefCount++;
+ return S_OK;
+ }
+ return E_NOINTERFACE;
+}
+
+static ULONG WINAPI RpcStream_AddRef(LPSTREAM iface)
+{
+ ICOM_THIS(RpcStreamImpl, iface);
+ return ++(This->RefCount);
+}
+
+static ULONG WINAPI RpcStream_Release(LPSTREAM iface)
+{
+ ICOM_THIS(RpcStreamImpl, iface);
+ if (!--(This->RefCount)) {
+ TRACE("size=%ld\n", *This->size);
+ This->pMsg->Buffer = This->data + *This->size;
+ HeapFree(GetProcessHeap(),0,This);
+ return 0;
+ }
+ return This->RefCount;
+}
+
+static HRESULT WINAPI RpcStream_Read(LPSTREAM iface,
+ void *pv,
+ ULONG cb,
+ ULONG *pcbRead)
+{
+ ICOM_THIS(RpcStreamImpl, iface);
+ if (This->pos + cb > *This->size) cb = *This->size - This->pos;
+ if (cb) {
+ memcpy(pv, This->data + This->pos, cb);
+ This->pos += cb;
+ }
+ if (pcbRead) *pcbRead = cb;
+ return S_OK;
+}
+
+static HRESULT WINAPI RpcStream_Write(LPSTREAM iface,
+ const void *pv,
+ ULONG cb,
+ ULONG *pcbWritten)
+{
+ ICOM_THIS(RpcStreamImpl, iface);
+ memcpy(This->data + This->pos, pv, cb);
+ This->pos += cb;
+ if (This->pos > *This->size) *This->size = This->pos;
+ if (pcbWritten) *pcbWritten = cb;
+ return S_OK;
+}
+
+static HRESULT WINAPI RpcStream_Seek(LPSTREAM iface,
+ LARGE_INTEGER move,
+ DWORD origin,
+ ULARGE_INTEGER *newPos)
+{
+ ICOM_THIS(RpcStreamImpl, iface);
+ switch (origin) {
+ case STREAM_SEEK_SET:
+ This->pos = move.s.LowPart;
+ break;
+ case STREAM_SEEK_CUR:
+ This->pos = This->pos + move.s.LowPart;
+ break;
+ case STREAM_SEEK_END:
+ This->pos = *This->size + move.s.LowPart;
+ break;
+ default:
+ return STG_E_INVALIDFUNCTION;
+ }
+ if (newPos) {
+ newPos->s.LowPart = This->pos;
+ newPos->s.HighPart = 0;
+ }
+ return S_OK;
+}
+
+static HRESULT WINAPI RpcStream_SetSize(LPSTREAM iface,
+ ULARGE_INTEGER newSize)
+{
+ ICOM_THIS(RpcStreamImpl, iface);
+ *This->size = newSize.s.LowPart;
+ return S_OK;
+}
+
+static ICOM_VTABLE(IStream) RpcStream_Vtbl =
+{
+ ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+ RpcStream_QueryInterface,
+ RpcStream_AddRef,
+ RpcStream_Release,
+ RpcStream_Read,
+ RpcStream_Write,
+ RpcStream_Seek,
+ RpcStream_SetSize,
+ NULL, /* CopyTo */
+ NULL, /* Commit */
+ NULL, /* Revert */
+ NULL, /* LockRegion */
+ NULL, /* UnlockRegion */
+ NULL, /* Stat */
+ NULL /* Clone */
+};
+
+static LPSTREAM RpcStream_Create(PMIDL_STUB_MESSAGE pStubMsg, BOOL init)
+{
+ RpcStreamImpl *This;
+ This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(RpcStreamImpl));
+ if (!This) return NULL;
+ This->lpVtbl = &RpcStream_Vtbl;
+ This->RefCount = 1;
+ This->pMsg = pStubMsg;
+ This->size = (LPDWORD)pStubMsg->Buffer;
+ This->data = (char*)(This->size + 1);
+ This->pos = 0;
+ if (init) *This->size = 0;
+ TRACE("init size=%ld\n", *This->size);
+ return (LPSTREAM)This;
+}
+
+/***********************************************************************
+ * NdrInterfacePointerMarshall [RPCRT4.@]
+ */
+unsigned char * WINAPI NdrInterfacePointerMarshall(PMIDL_STUB_MESSAGE pStubMsg,
+ unsigned char *pMemory,
+ PFORMAT_STRING pFormat)
+{
+ const IID *riid = (const IID *)pStubMsg->MaxCount;
+ LPSTREAM stream;
+ HRESULT hr;
+
+ TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
+ if (!riid) riid = &IID_IUnknown;
+ pStubMsg->MaxCount = 0;
+ if (!LoadCOM()) return NULL;
+ stream = RpcStream_Create(pStubMsg, TRUE);
+ hr = COM_MarshalInterface(stream, riid, (LPUNKNOWN)pMemory,
+ pStubMsg->dwDestContext, pStubMsg->pvDestContext,
+ MSHLFLAGS_NORMAL);
+ IStream_Release(stream);
+ return NULL;
+}
+
+/***********************************************************************
+ * NdrInterfacePointerUnmarshall [RPCRT4.@]
+ */
+unsigned char * WINAPI NdrInterfacePointerUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
+ unsigned char **ppMemory,
+ PFORMAT_STRING pFormat,
+ unsigned char fMustAlloc)
+{
+ LPSTREAM stream;
+ HRESULT hr;
+
+ TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
+ if (!LoadCOM()) return NULL;
+ *(LPVOID*)ppMemory = NULL;
+ stream = RpcStream_Create(pStubMsg, FALSE);
+ hr = COM_UnmarshalInterface(stream, &IID_NULL, (LPVOID*)ppMemory);
+ IStream_Release(stream);
+ return NULL;
+}
+
+/***********************************************************************
+ * NdrInterfacePointerBufferSize [RPCRT4.@]
+ */
+void WINAPI NdrInterfacePointerBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
+ unsigned char *pMemory,
+ PFORMAT_STRING pFormat)
+{
+ const IID *riid = (const IID *)pStubMsg->MaxCount;
+ ULONG size = 0;
+ HRESULT hr;
+
+ TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
+ if (!riid) riid = &IID_IUnknown;
+ if (!LoadCOM()) return;
+ hr = COM_GetMarshalSizeMax(&size, riid, (LPUNKNOWN)pMemory,
+ pStubMsg->dwDestContext, pStubMsg->pvDestContext,
+ MSHLFLAGS_NORMAL);
+ TRACE("size=%ld\n", size);
+ pStubMsg->BufferLength += sizeof(DWORD) + size;
+}
+
+/***********************************************************************
+ * NdrInterfacePointerMemorySize [RPCRT4.@]
+ */
+unsigned long WINAPI NdrInterfacePointerMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
+ PFORMAT_STRING pFormat)
+{
+ FIXME("(%p,%p): stub\n", pStubMsg, pFormat);
+ return 0;
+}
+
+/***********************************************************************
+ * NdrInterfacePointerFree [RPCRT4.@]
+ */
+void WINAPI NdrInterfacePointerFree(PMIDL_STUB_MESSAGE pStubMsg,
+ unsigned char *pMemory,
+ PFORMAT_STRING pFormat)
+{
+ LPUNKNOWN pUnk = (LPUNKNOWN)pMemory;
+ TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
+ if (pUnk) IUnknown_Release(pUnk);
+}
+
+/***********************************************************************
+ * NdrOleAllocate [RPCRT4.@]
+ */
+void * WINAPI NdrOleAllocate(size_t Size)
+{
+ if (!LoadCOM()) return NULL;
+ return COM_MemAlloc(Size);
+}
+
+/***********************************************************************
+ * NdrOleFree [RPCRT4.@]
+ */
+void WINAPI NdrOleFree(void *NodeToFree)
+{
+ if (!LoadCOM()) return;
+ COM_MemFree(NodeToFree);
+}
+
+/* internal */
+HRESULT RPCRT4_GetPSFactory(REFIID riid, LPPSFACTORYBUFFER *pPS)
+{
+ HRESULT hr;
+ CLSID clsid;
+
+ if (!LoadCOM()) return RPC_E_UNEXPECTED;
+ hr = COM_GetPSClsid(riid, &clsid);
+ if (FAILED(hr)) return hr;
+ hr = COM_GetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL,
+ &IID_IPSFactoryBuffer, (LPVOID *)pPS);
+ return hr;
+}
+
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/ndr_stubless.c Thu Jun 13 17:18:32 2002
@@ -0,0 +1,46 @@
+/*
+ * NDR client stuff
+ *
+ * Copyright 2001 Ove K�en, TransGaming Technologies
+ *
+ * TODO:
+ * - figure out whether we *really* got this right
+ * - check for errors and throw exceptions
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#include "wine/debug.h"
+
+#include "ndr_misc.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+LONG_PTR RPCRT4_NdrClientCall2(PMIDL_STUB_DESC pStubDesc,
+ PFORMAT_STRING pFormat,
+ LPVOID args)
+{
+ FIXME("(%p,%p,...)\n", pStubDesc, pFormat);
+ return 0;
+}
+
+/***********************************************************************
+ * NdrClientCall2 [RPCRT4.@]
+ */
+CLIENT_CALL_RETURN WINAPIV NdrClientCall2(PMIDL_STUB_DESC pStubDesc,
+ PFORMAT_STRING pFormat,
+ ...)
+{
+ TRACE("(%p,%p,...)\n", pStubDesc, pFormat);
+ return (CLIENT_CALL_RETURN)RPCRT4_NdrClientCall2(pStubDesc, pFormat, &pFormat + 1);
+}
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/rpc_binding.c Thu Jun 13 17:19:45 2002
@@ -0,0 +1,743 @@
+/*
+ * RPC binding API
+ *
+ * Copyright 2001 Ove K�en, TransGaming Technologies
+ *
+ * TODO:
+ * - a whole lot
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winnls.h"
+#include "winerror.h"
+#include "winreg.h"
+#include "wine/unicode.h"
+
+#include "rpc.h"
+
+#include "wine/debug.h"
+
+#include "rpc_binding.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+LPSTR RPCRT4_strdupAA(LPSTR src, INT slen)
+{
+ DWORD len;
+ LPSTR s;
+ if (!src) return NULL;
+ if (slen == -1) slen = strlen(src);
+ len = slen;
+ s = HeapAlloc(GetProcessHeap(), 0, len+1);
+ memcpy(s, src, len);
+ s[len] = 0;
+ return s;
+}
+
+LPSTR RPCRT4_strdupAW(LPWSTR src, INT slen)
+{
+ DWORD len;
+ LPSTR s;
+ if (!src) return NULL;
+ if (slen == -1) slen = strlenW(src);
+ len = WideCharToMultiByte(CP_ACP, 0, src, slen, NULL, 0, NULL, NULL);
+ s = HeapAlloc(GetProcessHeap(), 0, len+1);
+ WideCharToMultiByte(CP_ACP, 0, src, slen, s, len, NULL, NULL);
+ s[len] = 0;
+ return s;
+}
+
+LPWSTR RPCRT4_strdupWA(LPSTR src, INT slen)
+{
+ DWORD len;
+ LPWSTR s;
+ if (!src) return NULL;
+ if (slen == -1) slen = strlen(src);
+ len = MultiByteToWideChar(CP_ACP, 0, src, slen, NULL, 0);
+ s = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
+ MultiByteToWideChar(CP_ACP, 0, src, slen, s, len);
+ s[len] = 0;
+ return s;
+}
+
+LPWSTR RPCRT4_strdupWW(LPWSTR src, INT slen)
+{
+ DWORD len;
+ LPWSTR s;
+ if (!src) return NULL;
+ if (slen == -1) slen = strlenW(src);
+ len = slen;
+ s = HeapAlloc(GetProcessHeap(), 0, (len+1)*sizeof(WCHAR));
+ memcpy(s, src, len*sizeof(WCHAR));
+ s[len] = 0;
+ return s;
+}
+
+void RPCRT4_strfree(LPSTR src)
+{
+ if (src) HeapFree(GetProcessHeap(), 0, src);
+}
+
+RPC_STATUS RPCRT4_CreateBindingA(RpcBinding** Binding, BOOL server, LPSTR Protseq)
+{
+ RpcBinding* NewBinding;
+
+ NewBinding = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcBinding));
+ NewBinding->refs = 1;
+ NewBinding->server = server;
+ NewBinding->Protseq = RPCRT4_strdupA(Protseq);
+
+ TRACE("binding: %p\n", NewBinding);
+ *Binding = NewBinding;
+
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_CreateBindingW(RpcBinding** Binding, BOOL server, LPWSTR Protseq)
+{
+ RpcBinding* NewBinding;
+
+ NewBinding = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcBinding));
+ NewBinding->refs = 1;
+ NewBinding->server = server;
+ NewBinding->Protseq = RPCRT4_strdupW(Protseq);
+
+ TRACE("binding: %p\n", NewBinding);
+ *Binding = NewBinding;
+
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_CompleteBindingA(RpcBinding* Binding, LPSTR NetworkAddr, LPSTR Endpoint, LPSTR NetworkOptions)
+{
+ RPCRT4_strfree(Binding->NetworkAddr);
+ Binding->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
+ RPCRT4_strfree(Binding->Endpoint);
+ Binding->Endpoint = RPCRT4_strdupA(Endpoint);
+
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_CompleteBindingW(RpcBinding* Binding, LPWSTR NetworkAddr, LPWSTR Endpoint, LPWSTR NetworkOptions)
+{
+ RPCRT4_strfree(Binding->NetworkAddr);
+ Binding->NetworkAddr = RPCRT4_strdupW(NetworkAddr);
+ RPCRT4_strfree(Binding->Endpoint);
+ Binding->Endpoint = RPCRT4_strdupW(Endpoint);
+
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_ResolveBinding(RpcBinding* Binding, LPSTR Endpoint)
+{
+ RPCRT4_strfree(Binding->Endpoint);
+ Binding->Endpoint = RPCRT4_strdup(Endpoint);
+
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_SetBindingObject(RpcBinding* Binding, UUID* ObjectUuid)
+{
+ if (ObjectUuid) memcpy(&Binding->ObjectUuid, ObjectUuid, sizeof(UUID));
+ else UuidCreateNil(&Binding->ObjectUuid);
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_SpawnBinding(RpcBinding** Binding, RpcBinding* OldBinding)
+{
+ RpcBinding* NewBinding;
+
+ NewBinding = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcBinding));
+ NewBinding->refs = 1;
+ NewBinding->server = OldBinding->server;
+ NewBinding->Protseq = RPCRT4_strdup(OldBinding->Protseq);
+ NewBinding->NetworkAddr = RPCRT4_strdup(OldBinding->NetworkAddr);
+ NewBinding->Endpoint = RPCRT4_strdup(OldBinding->Endpoint);
+ /* because of the way named pipes work, we'll transfer the connected pipe
+ * to the child, then reopen the server binding to continue listening */
+ NewBinding->conn = OldBinding->conn;
+ NewBinding->ovl = OldBinding->ovl;
+ OldBinding->conn = 0;
+ memset(&OldBinding->ovl, 0, sizeof(OldBinding->ovl));
+ *Binding = NewBinding;
+ RPCRT4_OpenBinding(OldBinding);
+
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_ExportBinding(RpcBinding** Binding, RpcBinding* OldBinding)
+{
+ InterlockedIncrement(&OldBinding->refs);
+ *Binding = OldBinding;
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_DestroyBinding(RpcBinding* Binding)
+{
+ if (InterlockedDecrement(&Binding->refs))
+ return RPC_S_OK;
+
+ TRACE("binding: %p\n", Binding);
+ RPCRT4_CloseBinding(Binding);
+ RPCRT4_strfree(Binding->Endpoint);
+ RPCRT4_strfree(Binding->NetworkAddr);
+ RPCRT4_strfree(Binding->Protseq);
+ HeapFree(GetProcessHeap(), 0, Binding);
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_OpenBinding(RpcBinding* Binding)
+{
+ if (!Binding->conn) {
+ if (Binding->server) { /* server */
+ /* protseq=ncalrpc: supposed to use NT LPC ports,
+ * but we'll implement it with named pipes for now */
+ if (strcmp(Binding->Protseq, "ncalrpc") == 0) {
+ static LPSTR prefix = "\\\\.\\pipe\\lrpc\\";
+ LPSTR pname;
+ pname = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + strlen(Binding->Endpoint) + 1);
+ strcat(strcpy(pname, prefix), Binding->Endpoint);
+ TRACE("listening on %s\n", pname);
+ Binding->conn = CreateNamedPipeA(pname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+ 0, PIPE_UNLIMITED_INSTANCES, 0, 0, 5000, NULL);
+ HeapFree(GetProcessHeap(), 0, pname);
+ memset(&Binding->ovl, 0, sizeof(Binding->ovl));
+ Binding->ovl.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
+ if (!ConnectNamedPipe(Binding->conn, &Binding->ovl)) {
+ DWORD err = GetLastError();
+ if (err == ERROR_PIPE_CONNECTED) {
+ SetEvent(Binding->ovl.hEvent);
+ return RPC_S_OK;
+ }
+ return err;
+ }
+ }
+ /* protseq=ncacn_np: named pipes */
+ else if (strcmp(Binding->Protseq, "ncacn_np") == 0) {
+ static LPSTR prefix = "\\\\.";
+ LPSTR pname;
+ pname = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + strlen(Binding->Endpoint) + 1);
+ strcat(strcpy(pname, prefix), Binding->Endpoint);
+ TRACE("listening on %s\n", pname);
+ Binding->conn = CreateNamedPipeA(pname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+ 0, PIPE_UNLIMITED_INSTANCES, 0, 0, 5000, NULL);
+ HeapFree(GetProcessHeap(), 0, pname);
+ memset(&Binding->ovl, 0, sizeof(Binding->ovl));
+ Binding->ovl.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
+ if (!ConnectNamedPipe(Binding->conn, &Binding->ovl)) {
+ DWORD err = GetLastError();
+ if (err == ERROR_PIPE_CONNECTED) {
+ SetEvent(Binding->ovl.hEvent);
+ return RPC_S_OK;
+ }
+ return err;
+ }
+ }
+ else {
+ ERR("protseq %s not supported\n", Binding->Protseq);
+ return RPC_S_PROTSEQ_NOT_SUPPORTED;
+ }
+ }
+ else { /* client */
+ /* protseq=ncalrpc: supposed to use NT LPC ports,
+ * but we'll implement it with named pipes for now */
+ if (strcmp(Binding->Protseq, "ncalrpc") == 0) {
+ static LPSTR prefix = "\\\\.\\pipe\\lrpc\\";
+ LPSTR pname;
+ HANDLE conn;
+ DWORD err;
+
+ pname = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + strlen(Binding->Endpoint) + 1);
+ strcat(strcpy(pname, prefix), Binding->Endpoint);
+ TRACE("connecting to %s\n", pname);
+ while (TRUE) {
+ if (WaitNamedPipeA(pname, NMPWAIT_WAIT_FOREVER)) {
+ conn = CreateFileA(pname, GENERIC_READ|GENERIC_WRITE, 0, NULL,
+ OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
+ if (conn != INVALID_HANDLE_VALUE) break;
+ err = GetLastError();
+ if (err == ERROR_PIPE_BUSY) continue;
+ TRACE("connection failed, error=%lx\n", err);
+ HeapFree(GetProcessHeap(), 0, pname);
+ return err;
+ }
+ else {
+ err = GetLastError();
+ TRACE("connection failed, error=%lx\n", err);
+ HeapFree(GetProcessHeap(), 0, pname);
+ return err;
+ }
+ }
+
+ /* success */
+ HeapFree(GetProcessHeap(), 0, pname);
+ memset(&Binding->ovl, 0, sizeof(Binding->ovl));
+ Binding->ovl.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
+ Binding->conn = conn;
+ }
+ /* protseq=ncacn_np: named pipes */
+ else if (strcmp(Binding->Protseq, "ncacn_np") == 0) {
+ static LPSTR prefix = "\\\\.";
+ LPSTR pname;
+ HANDLE conn;
+ DWORD err;
+
+ pname = HeapAlloc(GetProcessHeap(), 0, strlen(prefix) + strlen(Binding->Endpoint) + 1);
+ strcat(strcpy(pname, prefix), Binding->Endpoint);
+ TRACE("connecting to %s\n", pname);
+ conn = CreateFileA(pname, GENERIC_READ|GENERIC_WRITE, 0, NULL,
+ OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
+ if (conn == INVALID_HANDLE_VALUE) {
+ err = GetLastError();
+ /* we don't need to handle ERROR_PIPE_BUSY here,
+ * the doc says that it is returned to the app */
+ TRACE("connection failed, error=%lx\n", err);
+ HeapFree(GetProcessHeap(), 0, pname);
+ return err;
+ }
+
+ /* success */
+ HeapFree(GetProcessHeap(), 0, pname);
+ memset(&Binding->ovl, 0, sizeof(Binding->ovl));
+ Binding->ovl.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
+ Binding->conn = conn;
+ }
+ else {
+ ERR("protseq %s not supported\n", Binding->Protseq);
+ return RPC_S_PROTSEQ_NOT_SUPPORTED;
+ }
+ }
+ }
+ return RPC_S_OK;
+}
+
+RPC_STATUS RPCRT4_CloseBinding(RpcBinding* Binding)
+{
+ if (Binding->conn) {
+ CancelIo(Binding->conn);
+ CloseHandle(Binding->conn);
+ Binding->conn = 0;
+ }
+ if (Binding->ovl.hEvent) {
+ CloseHandle(Binding->ovl.hEvent);
+ Binding->ovl.hEvent = 0;
+ }
+ return RPC_S_OK;
+}
+
+/* utility functions for string composing and parsing */
+static unsigned RPCRT4_strcopyA(LPSTR data, LPCSTR src)
+{
+ unsigned len = strlen(src);
+ memcpy(data, src, len*sizeof(CHAR));
+ return len;
+}
+
+static unsigned RPCRT4_strcopyW(LPWSTR data, LPCWSTR src)
+{
+ unsigned len = strlenW(src);
+ memcpy(data, src, len*sizeof(WCHAR));
+ return len;
+}
+
+static LPSTR RPCRT4_strconcatA(LPSTR dst, LPCSTR src)
+{
+ DWORD len = strlen(dst), slen = strlen(src);
+ LPSTR ndst = HeapReAlloc(GetProcessHeap(), 0, dst, (len+slen+2)*sizeof(CHAR));
+ if (!ndst) HeapFree(GetProcessHeap(), 0, dst);
+ ndst[len] = ',';
+ memcpy(ndst+len+1, src, slen*sizeof(CHAR));
+ ndst[len+slen+1] = 0;
+ return ndst;
+}
+
+static LPWSTR RPCRT4_strconcatW(LPWSTR dst, LPCWSTR src)
+{
+ DWORD len = strlenW(dst), slen = strlenW(src);
+ LPWSTR ndst = HeapReAlloc(GetProcessHeap(), 0, dst, (len+slen+2)*sizeof(WCHAR));
+ if (!ndst) HeapFree(GetProcessHeap(), 0, dst);
+ ndst[len] = ',';
+ memcpy(ndst+len+1, src, slen*sizeof(WCHAR));
+ ndst[len+slen+1] = 0;
+ return ndst;
+}
+
+#define RPC_STRING_BINDING_COMPOSE(char_t,strlen_t,strcopy_t) \
+ if (ObjUuid && *ObjUuid) len += strlen_t(ObjUuid) + 1; \
+ if (Protseq && *Protseq) len += strlen_t(Protseq) + 1; \
+ if (NetworkAddr && *NetworkAddr) len += strlen_t(NetworkAddr); \
+ if (Endpoint && *Endpoint) len += strlen_t(Endpoint) + 2; \
+ if (Options && *Options) len += strlen_t(Options) + 2; \
+ \
+ data = HeapAlloc(GetProcessHeap(), 0, len*sizeof(char_t)); \
+ *StringBinding = data; \
+ \
+ if (ObjUuid && *ObjUuid) { \
+ data += strcopy_t(data, ObjUuid); \
+ *data++ = '@'; \
+ } \
+ if (Protseq && *Protseq) { \
+ data += strcopy_t(data, Protseq); \
+ *data++ = ':'; \
+ } \
+ if (NetworkAddr && *NetworkAddr) { \
+ data += strcopy_t(data, NetworkAddr); \
+ } \
+ if ((Endpoint && *Endpoint) || \
+ (Options && *Options)) { \
+ *data++ = '['; \
+ if (Endpoint && *Endpoint) { \
+ data += strcopy_t(data, Endpoint); \
+ if (Options && *Options) *data++ = ','; \
+ } \
+ if (Options && *Options) { \
+ data += strcopy_t(data, Options); \
+ } \
+ *data++ = ']'; \
+ } \
+ *data = 0;
+
+/***********************************************************************
+ * RpcStringBindingComposeA (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcStringBindingComposeA( LPSTR ObjUuid, LPSTR Protseq,
+ LPSTR NetworkAddr, LPSTR Endpoint,
+ LPSTR Options, LPSTR* StringBinding )
+{
+ DWORD len = 1;
+ LPSTR data;
+
+ TRACE( "(%s,%s,%s,%s,%s,%p)\n",
+ debugstr_a( ObjUuid ), debugstr_a( Protseq ),
+ debugstr_a( NetworkAddr ), debugstr_a( Endpoint ),
+ debugstr_a( Options ), StringBinding );
+
+ RPC_STRING_BINDING_COMPOSE(CHAR,strlen,RPCRT4_strcopyA)
+
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * RpcStringBindingComposeW (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcStringBindingComposeW( LPWSTR ObjUuid, LPWSTR Protseq,
+ LPWSTR NetworkAddr, LPWSTR Endpoint,
+ LPWSTR Options, LPWSTR* StringBinding )
+{
+ DWORD len = 1;
+ LPWSTR data;
+
+ TRACE("(%s,%s,%s,%s,%s,%p)\n",
+ debugstr_w( ObjUuid ), debugstr_w( Protseq ),
+ debugstr_w( NetworkAddr ), debugstr_w( Endpoint ),
+ debugstr_w( Options ), StringBinding);
+
+ RPC_STRING_BINDING_COMPOSE(WCHAR,strlenW,RPCRT4_strcopyW)
+
+ return RPC_S_OK;
+}
+
+#define RPC_STRING_BINDING_PARSE(char_t,strlen_t,strchr_t,strncmp_t,strdup_t,strconc_t) \
+ if (ObjUuid) *ObjUuid = NULL; \
+ if (Protseq) *Protseq = NULL; \
+ if (NetworkAddr) *NetworkAddr = NULL; \
+ if (Endpoint) *Endpoint = NULL; \
+ if (Options) *Options = NULL; \
+ \
+ data = StringBinding; \
+ \
+ next = strchr_t(data, '@'); \
+ if (next) { \
+ if (ObjUuid) *ObjUuid = strdup_t(data, next - data); \
+ data = next+1; \
+ } \
+ \
+ next = strchr_t(data, ':'); \
+ if (next) { \
+ if (Protseq) *Protseq = strdup_t(data, next - data); \
+ data = next+1; \
+ } \
+ \
+ next = strchr_t(data, '['); \
+ if (next) { \
+ char_t *close, *opt; \
+ \
+ if (NetworkAddr) *NetworkAddr = strdup_t(data, next - data); \
+ data = next+1; \
+ close = strchr_t(data, ']'); \
+ if (!close) goto fail; \
+ \
+ /* tokenize options */ \
+ while (data < close) { \
+ next = strchr_t(data, ','); \
+ if (!next || next > close) next = close; \
+ /* FIXME: this is kind of inefficient */ \
+ opt = strdup_t(data, next - data); \
+ data = next+1; \
+ \
+ /* parse option */ \
+ next = strchr_t(opt, '='); \
+ if (!next) { \
+ /* not an option, must be an endpoint */ \
+ if (*Endpoint) goto fail; \
+ *Endpoint = opt; \
+ } \
+ else { \
+ if (strncmp_t(opt, ep_opt, strlen_t(ep_opt)) == 0) { \
+ /* endpoint option */ \
+ if (*Endpoint) goto fail; \
+ *Endpoint = strdup_t(next+1, strlen_t(next+1)); \
+ HeapFree(GetProcessHeap(), 0, opt); \
+ } \
+ else { \
+ /* network option */ \
+ if (*Options) { \
+ /* FIXME: this is kind of inefficient */ \
+ *Options = strconc_t(*Options, opt); \
+ HeapFree(GetProcessHeap(), 0, opt); \
+ } \
+ else *Options = opt; \
+ } \
+ } \
+ } \
+ \
+ data = close+1; \
+ if (*data) goto fail; \
+ } \
+ else if (NetworkAddr) *NetworkAddr = strdup_t(data, strlen_t(data)); \
+
+/***********************************************************************
+ * RpcStringBindingParseA (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcStringBindingParseA( LPSTR StringBinding, LPSTR *ObjUuid,
+ LPSTR *Protseq, LPSTR *NetworkAddr,
+ LPSTR *Endpoint, LPSTR *Options)
+{
+ CHAR *data, *next;
+ static CHAR ep_opt[] = {'e','n','d','p','o','i','n','t','=',0};
+
+ TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_a(StringBinding),
+ ObjUuid, Protseq, NetworkAddr, Endpoint, Options);
+
+ RPC_STRING_BINDING_PARSE(CHAR,strlen,strchr,strncmp,RPCRT4_strdupAA,RPCRT4_strconcatA)
+
+ return RPC_S_OK;
+fail:
+ if (ObjUuid) RpcStringFreeA(ObjUuid);
+ if (Protseq) RpcStringFreeA(Protseq);
+ if (NetworkAddr) RpcStringFreeA(NetworkAddr);
+ if (Endpoint) RpcStringFreeA(Endpoint);
+ if (Options) RpcStringFreeA(Options);
+ return RPC_S_INVALID_STRING_BINDING;
+}
+
+/***********************************************************************
+ * RpcStringBindingParseW (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcStringBindingParseW( LPWSTR StringBinding, LPWSTR *ObjUuid,
+ LPWSTR *Protseq, LPWSTR *NetworkAddr,
+ LPWSTR *Endpoint, LPWSTR *Options)
+{
+ WCHAR *data, *next;
+ static WCHAR ep_opt[] = {'e','n','d','p','o','i','n','t','=',0};
+
+ TRACE("(%s,%p,%p,%p,%p,%p)\n", debugstr_w(StringBinding),
+ ObjUuid, Protseq, NetworkAddr, Endpoint, Options);
+
+ RPC_STRING_BINDING_PARSE(WCHAR,strlenW,strchrW,strncmpW,RPCRT4_strdupWW,RPCRT4_strconcatW)
+
+ return RPC_S_OK;
+fail:
+ if (ObjUuid) RpcStringFreeW(ObjUuid);
+ if (Protseq) RpcStringFreeW(Protseq);
+ if (NetworkAddr) RpcStringFreeW(NetworkAddr);
+ if (Endpoint) RpcStringFreeW(Endpoint);
+ if (Options) RpcStringFreeW(Options);
+ return RPC_S_INVALID_STRING_BINDING;
+}
+
+/***********************************************************************
+ * RpcBindingFree (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcBindingFree( RPC_BINDING_HANDLE* Binding )
+{
+ RPC_STATUS status;
+ TRACE("(%p) = %p\n", Binding, *Binding);
+ status = RPCRT4_DestroyBinding(*Binding);
+ if (status == RPC_S_OK) *Binding = 0;
+ return status;
+}
+
+/***********************************************************************
+ * RpcBindingVectorFree (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcBindingVectorFree( RPC_BINDING_VECTOR** BindingVector )
+{
+ RPC_STATUS status;
+ unsigned long c;
+
+ TRACE("(%p)\n", BindingVector);
+ for (c=0; c<(*BindingVector)->Count; c++) {
+ status = RpcBindingFree(&(*BindingVector)->BindingH[c]);
+ }
+ HeapFree(GetProcessHeap(), 0, *BindingVector);
+ *BindingVector = NULL;
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * RpcBindingInqObject (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcBindingInqObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid )
+{
+ RpcBinding* bind = (RpcBinding*)Binding;
+
+ TRACE("(%p,%p) = %s\n", Binding, ObjectUuid, debugstr_guid(&bind->ObjectUuid));
+ memcpy(ObjectUuid, &bind->ObjectUuid, sizeof(UUID));
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * RpcBindingSetObject (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcBindingSetObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid )
+{
+ RpcBinding* bind = (RpcBinding*)Binding;
+
+ TRACE("(%p,%s)\n", Binding, debugstr_guid(ObjectUuid));
+ if (bind->server) return RPC_S_WRONG_KIND_OF_BINDING;
+ return RPCRT4_SetBindingObject(Binding, ObjectUuid);
+}
+
+/***********************************************************************
+ * RpcBindingFromStringBindingA (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcBindingFromStringBindingA( LPSTR StringBinding, RPC_BINDING_HANDLE* Binding )
+{
+ RPC_STATUS ret;
+ RpcBinding* bind = NULL;
+ LPSTR ObjectUuid, Protseq, NetworkAddr, Endpoint, Options;
+ UUID Uuid;
+
+ TRACE("(%s,%p)\n", debugstr_a(StringBinding), Binding);
+
+ ret = RpcStringBindingParseA(StringBinding, &ObjectUuid, &Protseq,
+ &NetworkAddr, &Endpoint, &Options);
+ if (ret != RPC_S_OK) return ret;
+
+ ret = UuidFromStringA(ObjectUuid, &Uuid);
+
+ if (ret == RPC_S_OK)
+ ret = RPCRT4_CreateBindingA(&bind, FALSE, Protseq);
+ if (ret == RPC_S_OK)
+ ret = RPCRT4_SetBindingObject(bind, &Uuid);
+ if (ret == RPC_S_OK)
+ ret = RPCRT4_CompleteBindingA(bind, NetworkAddr, Endpoint, Options);
+
+ RpcStringFreeA(&Options);
+ RpcStringFreeA(&Endpoint);
+ RpcStringFreeA(&NetworkAddr);
+ RpcStringFreeA(&Protseq);
+ RpcStringFreeA(&ObjectUuid);
+
+ if (ret == RPC_S_OK) *Binding = (RPC_BINDING_HANDLE)bind;
+ else RPCRT4_DestroyBinding(bind);
+
+ return ret;
+}
+
+/***********************************************************************
+ * RpcBindingFromStringBindingW (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcBindingFromStringBindingW( LPWSTR StringBinding, RPC_BINDING_HANDLE* Binding )
+{
+ RPC_STATUS ret;
+ RpcBinding* bind = NULL;
+ LPWSTR ObjectUuid, Protseq, NetworkAddr, Endpoint, Options;
+ UUID Uuid;
+
+ TRACE("(%s,%p)\n", debugstr_w(StringBinding), Binding);
+
+ ret = RpcStringBindingParseW(StringBinding, &ObjectUuid, &Protseq,
+ &NetworkAddr, &Endpoint, &Options);
+ if (ret != RPC_S_OK) return ret;
+
+ ret = UuidFromStringW(ObjectUuid, &Uuid);
+
+ if (ret == RPC_S_OK)
+ ret = RPCRT4_CreateBindingW(&bind, FALSE, Protseq);
+ if (ret == RPC_S_OK)
+ ret = RPCRT4_SetBindingObject(bind, &Uuid);
+ if (ret == RPC_S_OK)
+ ret = RPCRT4_CompleteBindingW(bind, NetworkAddr, Endpoint, Options);
+
+ RpcStringFreeW(&Options);
+ RpcStringFreeW(&Endpoint);
+ RpcStringFreeW(&NetworkAddr);
+ RpcStringFreeW(&Protseq);
+ RpcStringFreeW(&ObjectUuid);
+
+ if (ret == RPC_S_OK) *Binding = (RPC_BINDING_HANDLE)bind;
+ else RPCRT4_DestroyBinding(bind);
+
+ return ret;
+}
+
+/***********************************************************************
+ * RpcBindingToStringBindingA (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcBindingToStringBindingA( RPC_BINDING_HANDLE Binding, LPSTR* StringBinding )
+{
+ RPC_STATUS ret;
+ RpcBinding* bind = (RpcBinding*)Binding;
+ LPSTR ObjectUuid;
+
+ TRACE("(%p,%p)\n", Binding, StringBinding);
+
+ ret = UuidToStringA(&bind->ObjectUuid, &ObjectUuid);
+ if (ret != RPC_S_OK) return ret;
+
+ ret = RpcStringBindingComposeA(ObjectUuid, bind->Protseq, bind->NetworkAddr,
+ bind->Endpoint, NULL, StringBinding);
+
+ RpcStringFreeA(&ObjectUuid);
+
+ return ret;
+}
+
+/***********************************************************************
+ * RpcBindingToStringBindingW (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcBindingToStringBindingW( RPC_BINDING_HANDLE Binding, LPWSTR* StringBinding )
+{
+ RPC_STATUS ret;
+ LPSTR str = NULL;
+ TRACE("(%p,%p)\n", Binding, StringBinding);
+ ret = RpcBindingToStringBindingA(Binding, &str);
+ *StringBinding = RPCRT4_strdupWA(str, -1);
+ RpcStringFreeA(&str);
+ return ret;
+}
+
+/***********************************************************************
+ * I_RpcBindingSetAsync (RPCRT4.@)
+ * NOTES
+ * Exists in win9x and winNT, but with different number of arguments
+ * (9x version has 3 arguments, NT has 2).
+ */
+RPC_STATUS WINAPI I_RpcBindingSetAsync( RPC_BINDING_HANDLE Binding, RPC_BLOCKING_FN BlockingFn, unsigned long ServerTid )
+{
+ RpcBinding* bind = (RpcBinding*)Binding;
+
+ TRACE( "(%p,%p,%ld): stub\n", Binding, BlockingFn, ServerTid );
+
+ bind->BlockingFn = BlockingFn;
+ bind->ServerTid = ServerTid;
+
+ return RPC_S_OK;
+}
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/rpc_epmap.c Thu Jun 13 17:20:10 2002
@@ -0,0 +1,172 @@
+/*
+ * RPC endpoint mapper
+ *
+ * Copyright 2001 Ove K�en, TransGaming Technologies
+ *
+ * TODO:
+ * - actually do things right
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+
+#include "wine/server.h"
+#include "rpc.h"
+
+#include "wine/debug.h"
+
+#include "rpc_binding.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+/* The "real" RPC portmapper endpoints that I know of are:
+ *
+ * ncadg_ip_udp: 135
+ * ncacn_ip_tcp: 135
+ * ncacn_np: \\pipe\epmapper (?)
+ * ncalrpc: epmapper
+ *
+ * If the user's machine ran a DCE RPC daemon, it would
+ * probably be possible to connect to it, but there are many
+ * reasons not to, like:
+ * - the user probably does *not* run one, and probably
+ * shouldn't be forced to run one just for local COM
+ * - very few Unix systems use DCE RPC... if they run a RPC
+ * daemon at all, it's usually Sun RPC
+ * - DCE RPC registrations are persistent and saved on disk,
+ * while MS-RPC registrations are documented as non-persistent
+ * and stored only in RAM, and auto-destroyed when the process
+ * dies (something DCE RPC can't do)
+ *
+ * Of course, if the user *did* want to run a DCE RPC daemon anyway,
+ * there would be interoperability advantages, like the possibility
+ * of running a fully functional DCOM server using Wine...
+ *
+ * But for now, I'll just use the wineserver...
+ */
+
+/***********************************************************************
+ * RpcEpRegisterA (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcEpRegisterA( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
+ UUID_VECTOR* UuidVector, LPSTR Annotation )
+{
+ NTSTATUS ret;
+ PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
+ unsigned long c;
+
+ TRACE("(%p,%p,%p,%s)\n", IfSpec, BindingVector, UuidVector, debugstr_a(Annotation));
+ TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
+ for (c=0; c<BindingVector->Count; c++) {
+ RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[c]);
+ TRACE(" protseq[%ld]=%s\n", c, bind->Protseq);
+ TRACE(" endpoint[%ld]=%s\n", c, bind->Endpoint);
+ }
+ if (UuidVector) {
+ for (c=0; c<UuidVector->Count; c++)
+ TRACE(" obj[%ld]=%s\n", c, debugstr_guid(UuidVector->Uuid[c]));
+ }
+
+ SERVER_START_REQ( register_rpc_endpoints )
+ {
+ wine_server_add_data( req, &If->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER) );
+ if (UuidVector) {
+ req->objects = UuidVector->Count;
+ for (c=0; c<req->objects; c++)
+ wine_server_add_data( req, UuidVector->Uuid[c], sizeof(UUID) );
+ }
+ else req->objects = 0;
+ req->bindings = BindingVector->Count;
+ for (c=0; c<req->bindings; c++) {
+ RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[c]);
+ wine_server_add_data( req, bind->Protseq, strlen(bind->Protseq)+1 );
+ wine_server_add_data( req, bind->Endpoint, strlen(bind->Endpoint)+1 );
+ }
+ req->no_replace = 0;
+ /* FIXME: annotation */
+ ret = wine_server_call( req );
+ }
+ SERVER_END_REQ;
+
+ return RtlNtStatusToDosError(ret);
+}
+
+/***********************************************************************
+ * RpcEpUnregister (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcEpUnregister( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector,
+ UUID_VECTOR* UuidVector )
+{
+ NTSTATUS ret;
+ PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
+ unsigned long c;
+
+ TRACE("(%p,%p,%p)\n", IfSpec, BindingVector, UuidVector);
+ TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
+ for (c=0; c<BindingVector->Count; c++) {
+ RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[c]);
+ TRACE(" protseq[%ld]=%s\n", c, bind->Protseq);
+ TRACE(" endpoint[%ld]=%s\n", c, bind->Endpoint);
+ }
+ if (UuidVector) {
+ for (c=0; c<UuidVector->Count; c++)
+ TRACE(" obj[%ld]=%s\n", c, debugstr_guid(UuidVector->Uuid[c]));
+ }
+
+ SERVER_START_REQ( unregister_rpc_endpoints )
+ {
+ wine_server_add_data( req, &If->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER) );
+ if (UuidVector) {
+ req->objects = UuidVector->Count;
+ for (c=0; c<req->objects; c++)
+ wine_server_add_data( req, UuidVector->Uuid[c], sizeof(UUID) );
+ }
+ else req->objects = 0;
+ req->bindings = BindingVector->Count;
+ for (c=0; c<req->bindings; c++) {
+ RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[c]);
+ wine_server_add_data( req, bind->Protseq, strlen(bind->Protseq)+1 );
+ wine_server_add_data( req, bind->Endpoint, strlen(bind->Endpoint)+1 );
+ }
+ ret = wine_server_call( req );
+ }
+ SERVER_END_REQ;
+
+ return RtlNtStatusToDosError(ret);
+}
+
+/***********************************************************************
+ * RpcEpResolveBinding (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcEpResolveBinding( RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec )
+{
+ NTSTATUS ret;
+ PRPC_CLIENT_INTERFACE If = (PRPC_CLIENT_INTERFACE)IfSpec;
+ RpcBinding* bind = (RpcBinding*)Binding;
+ char Endpoint[64];
+
+ TRACE("(%p,%p)\n", Binding, IfSpec);
+ TRACE(" protseq=%s\n", bind->Protseq);
+ TRACE(" obj=%s\n", debugstr_guid(&bind->ObjectUuid));
+ TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
+
+ SERVER_START_REQ( resolve_rpc_endpoint )
+ {
+ wine_server_add_data( req, &If->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER) );
+ wine_server_add_data( req, &bind->ObjectUuid, sizeof(UUID) );
+ wine_server_add_data( req, bind->Protseq, strlen(bind->Protseq)+1 );
+ wine_server_set_reply( req, Endpoint, sizeof(Endpoint) );
+ ret = wine_server_call( req );
+ }
+ SERVER_END_REQ;
+
+ if (ret) return RtlNtStatusToDosError(ret);
+
+ return RPCRT4_ResolveBinding(Binding, Endpoint);
+}
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/rpc_message.c Thu Jun 13 17:26:16 2002
@@ -0,0 +1,166 @@
+/*
+ * RPC messages
+ *
+ * Copyright 2001-2002 Ove K�en, TransGaming Technologies
+ *
+ * TODO:
+ * - figure out whether we *really* got this right
+ * - check for errors and throw exceptions
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+
+#include "rpc.h"
+#include "rpcdcep.h"
+
+#include "wine/debug.h"
+
+#include "rpc_binding.h"
+#include "rpc_defs.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+/***********************************************************************
+ * I_RpcGetBuffer [RPCRT4.@]
+ */
+RPC_STATUS WINAPI I_RpcGetBuffer(PRPC_MESSAGE pMsg)
+{
+ void* buf;
+
+ TRACE("(%p)\n", pMsg);
+ buf = HeapReAlloc(GetProcessHeap(), 0, pMsg->Buffer, pMsg->BufferLength);
+ if (buf) pMsg->Buffer = buf;
+ /* FIXME: which errors to return? */
+ return buf ? S_OK : E_OUTOFMEMORY;
+}
+
+/***********************************************************************
+ * I_RpcFreeBuffer [RPCRT4.@]
+ */
+RPC_STATUS WINAPI I_RpcFreeBuffer(PRPC_MESSAGE pMsg)
+{
+ TRACE("(%p)\n", pMsg);
+ HeapFree(GetProcessHeap(), 0, pMsg->Buffer);
+ pMsg->Buffer = NULL;
+ return S_OK;
+}
+
+/***********************************************************************
+ * I_RpcSend [RPCRT4.@]
+ */
+RPC_STATUS WINAPI I_RpcSend(PRPC_MESSAGE pMsg)
+{
+ RpcBinding* bind = (RpcBinding*)pMsg->Handle;
+ RPC_CLIENT_INTERFACE* cif;
+ RPC_STATUS status;
+ RpcPktHdr hdr;
+
+ TRACE("(%p)\n", pMsg);
+ if (!bind) return RPC_S_INVALID_BINDING;
+
+ /* I'll only implement this for client handles for now */
+ if (bind->server) return RPC_S_WRONG_KIND_OF_BINDING;
+
+ cif = pMsg->RpcInterfaceInformation;
+ if (!cif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
+
+ status = RPCRT4_OpenBinding(bind);
+ if (status != RPC_S_OK) return status;
+
+ /* initialize packet header */
+ memset(&hdr, 0, sizeof(hdr));
+ hdr.rpc_ver = 4;
+ hdr.ptype = PKT_REQUEST;
+ hdr.object = bind->ObjectUuid;
+ hdr.if_id = cif->InterfaceId.SyntaxGUID;
+ hdr.if_vers = MAKELONG(cif->InterfaceId.SyntaxVersion.MinorVersion,
+ cif->InterfaceId.SyntaxVersion.MajorVersion);
+ hdr.opnum = pMsg->ProcNum;
+ hdr.len = pMsg->BufferLength;
+
+ /* transmit packet */
+ if (!WriteFile(bind->conn, &hdr, sizeof(hdr), NULL, NULL))
+ return GetLastError();
+ if (!WriteFile(bind->conn, pMsg->Buffer, pMsg->BufferLength, NULL, NULL))
+ return GetLastError();
+
+ /* success */
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * I_RpcReceive [RPCRT4.@]
+ */
+RPC_STATUS WINAPI I_RpcReceive(PRPC_MESSAGE pMsg)
+{
+ RpcBinding* bind = (RpcBinding*)pMsg->Handle;
+ RPC_STATUS status;
+ RpcPktHdr hdr;
+ DWORD dwRead;
+
+ TRACE("(%p)\n", pMsg);
+ if (!bind) return RPC_S_INVALID_BINDING;
+
+ /* I'll only implement this for client handles for now */
+ if (bind->server) return RPC_S_WRONG_KIND_OF_BINDING;
+
+ status = RPCRT4_OpenBinding(bind);
+ if (status != RPC_S_OK) return status;
+
+ /* read packet header */
+#ifdef OVERLAPPED_WORKS
+ if (!ReadFile(bind->conn, &hdr, sizeof(hdr), &dwRead, &bind->ovl)) {
+ DWORD err = GetLastError();
+ if (err != ERROR_IO_PENDING) {
+ return err;
+ }
+ if (!GetOverlappedResult(bind->conn, &bind->ovl, &dwRead, TRUE)) return GetLastError();
+ }
+#else
+ if (!ReadFile(bind->conn, &hdr, sizeof(hdr), &dwRead, NULL))
+ return GetLastError();
+#endif
+ if (dwRead != sizeof(hdr)) return RPC_S_PROTOCOL_ERROR;
+
+ /* read packet body */
+ pMsg->BufferLength = hdr.len;
+ status = I_RpcGetBuffer(pMsg);
+ if (status != RPC_S_OK) return status;
+#ifdef OVERLAPPED_WORKS
+ if (!ReadFile(bind->conn, pMsg->Buffer, hdr.len, &dwRead, &bind->ovl)) {
+ DWORD err = GetLastError();
+ if (err != ERROR_IO_PENDING) {
+ return err;
+ }
+ if (!GetOverlappedResult(bind->conn, &bind->ovl, &dwRead, TRUE)) return GetLastError();
+ }
+#else
+ if (!ReadFile(bind->conn, pMsg->Buffer, hdr.len, &dwRead, NULL))
+ return GetLastError();
+#endif
+ if (dwRead != hdr.len) return RPC_S_PROTOCOL_ERROR;
+
+ /* success */
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * I_RpcSendReceive [RPCRT4.@]
+ */
+RPC_STATUS WINAPI I_RpcSendReceive(PRPC_MESSAGE pMsg)
+{
+ RPC_STATUS status;
+
+ TRACE("(%p)\n", pMsg);
+ status = I_RpcSend(pMsg);
+ if (status == RPC_S_OK)
+ status = I_RpcReceive(pMsg);
+ return status;
+}
+
--- /dev/null Mon Mar 4 08:42:02 2002
+++ wine/dlls/rpcrt4/rpc_server.c Thu Jun 13 17:26:43 2002
@@ -0,0 +1,563 @@
+/*
+ * RPC server API
+ *
+ * Copyright 2001 Ove K�en, TransGaming Technologies
+ *
+ * TODO:
+ * - a whole lot
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+
+#include "rpc.h"
+
+#include "wine/debug.h"
+
+#include "rpc_server.h"
+#include "rpc_defs.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(ole);
+
+static RpcServerProtseq* protseqs;
+static RpcServerInterface* ifs;
+
+static CRITICAL_SECTION server_cs = CRITICAL_SECTION_INIT("RpcServer");
+static BOOL std_listen;
+static LONG listen_count = -1;
+static HANDLE mgr_event, server_thread;
+
+static RpcServerInterface* RPCRT4_find_interface(UUID* object, UUID* if_id)
+{
+ UUID* MgrType = NULL;
+ RpcServerInterface* cif = NULL;
+ RPC_STATUS status;
+
+ /* FIXME: object -> MgrType */
+ EnterCriticalSection(&server_cs);
+ cif = ifs;
+ while (cif) {
+ if (UuidEqual(if_id, &cif->If->InterfaceId.SyntaxGUID, &status) &&
+ UuidEqual(MgrType, &cif->MgrTypeUuid, &status) &&
+ (std_listen || (cif->Flags & RPC_IF_AUTOLISTEN))) break;
+ cif = cif->Next;
+ }
+ LeaveCriticalSection(&server_cs);
+ return cif;
+}
+
+static DWORD CALLBACK RPCRT4_io_thread(LPVOID the_arg)
+{
+ RpcBinding* bind = (RpcBinding*)the_arg;
+ RpcPktHdr hdr;
+ DWORD dwRead;
+ RPC_MESSAGE msg;
+ RpcServerInterface* sif;
+ RPC_DISPATCH_FUNCTION func;
+
+ memset(&msg, 0, sizeof(msg));
+ msg.Handle = (RPC_BINDING_HANDLE)bind;
+
+ for (;;) {
+ /* read packet header */
+#ifdef OVERLAPPED_WORKS
+ if (!ReadFile(bind->conn, &hdr, sizeof(hdr), &dwRead, &bind->ovl)) {
+ DWORD err = GetLastError();
+ if (err != ERROR_IO_PENDING) {
+ TRACE("connection lost, error=%08lx\n", err);
+ break;
+ }
+ if (!GetOverlappedResult(bind->conn, &bind->ovl, &dwRead, TRUE)) break;
+ }
+#else
+ if (!ReadFile(bind->conn, &hdr, sizeof(hdr), &dwRead, NULL)) {
+ TRACE("connection lost, error=%08lx\n", GetLastError());
+ break;
+ }
+#endif
+ if (dwRead != sizeof(hdr)) {
+ TRACE("protocol error\n");
+ break;
+ }
+
+ /* read packet body */
+ msg.BufferLength = hdr.len;
+ msg.Buffer = HeapAlloc(GetProcessHeap(), 0, msg.BufferLength);
+#ifdef OVERLAPPED_WORKS
+ if (!ReadFile(bind->conn, msg.Buffer, msg.BufferLength, &dwRead, &bind->ovl)) {
+ DWORD err = GetLastError();
+ if (err != ERROR_IO_PENDING) {
+ TRACE("connection lost, error=%08lx\n", err);
+ break;
+ }
+ if (!GetOverlappedResult(bind->conn, &bind->ovl, &dwRead, TRUE)) break;
+ }
+#else
+ if (!ReadFile(bind->conn, msg.Buffer, msg.BufferLength, &dwRead, NULL)) {
+ TRACE("connection lost, error=%08lx\n", GetLastError());
+ break;
+ }
+#endif
+ if (dwRead != hdr.len) {
+ TRACE("protocol error\n");
+ break;
+ }
+
+ sif = RPCRT4_find_interface(&hdr.object, &hdr.if_id);
+ if (sif) {
+ msg.RpcInterfaceInformation = sif->If;
+ /* associate object with binding (this is a bit of a hack...
+ * a new binding should probably be created for each object) */
+ RPCRT4_SetBindingObject(bind, &hdr.object);
+ /* process packet*/
+ switch (hdr.ptype) {
+ case PKT_REQUEST:
+ /* find dispatch function */
+ msg.ProcNum = hdr.opnum;
+ if (sif->Flags & RPC_IF_OLE) {
+ /* native ole32 always gives us a dispatch table with a single entry
+ * (I assume that's a wrapper for IRpcStubBuffer::Invoke) */
+ func = *sif->If->DispatchTable->DispatchTable;
+ } else {
+ if (msg.ProcNum >= sif->If->DispatchTable->DispatchTableCount) {
+ ERR("invalid procnum\n");
+ func = NULL;
+ }
+ func = sif->If->DispatchTable->DispatchTable[msg.ProcNum];
+ }
+
+ /* dispatch */
+ if (func) func(&msg);
+
+ /* prepare response packet */
+ hdr.ptype = PKT_RESPONSE;
+ break;
+ default:
+ ERR("unknown packet type\n");
+ goto no_reply;
+ }
+
+ /* write reply packet */
+ hdr.len = msg.BufferLength;
+ WriteFile(bind->conn, &hdr, sizeof(hdr), NULL, NULL);
+ WriteFile(bind->conn, msg.Buffer, msg.BufferLength, NULL, NULL);
+
+ no_reply:
+ /* un-associate object */
+ RPCRT4_SetBindingObject(bind, NULL);
+ msg.RpcInterfaceInformation = NULL;
+ }
+ else {
+ ERR("got RPC packet to unregistered interface %s\n", debugstr_guid(&hdr.if_id));
+ }
+
+ /* clean up */
+ HeapFree(GetProcessHeap(), 0, msg.Buffer);
+ msg.Buffer = NULL;
+ }
+ if (msg.Buffer) HeapFree(GetProcessHeap(), 0, msg.Buffer);
+ RPCRT4_DestroyBinding(bind);
+ return 0;
+}
+
+static void RPCRT4_new_client(RpcBinding* bind)
+{
+ bind->thread = CreateThread(NULL, 0, RPCRT4_io_thread, bind, 0, NULL);
+}
+
+static DWORD CALLBACK RPCRT4_server_thread(LPVOID the_arg)
+{
+ HANDLE m_event = mgr_event, b_handle;
+ HANDLE *objs = NULL;
+ DWORD count, res;
+ RpcServerProtseq* cps;
+ RpcBinding* bind;
+ RpcBinding* cbind;
+
+ for (;;) {
+ EnterCriticalSection(&server_cs);
+ /* open and count bindings */
+ count = 1;
+ cps = protseqs;
+ while (cps) {
+ bind = cps->bind;
+ while (bind) {
+ RPCRT4_OpenBinding(bind);
+ if (bind->ovl.hEvent) count++;
+ bind = bind->Next;
+ }
+ cps = cps->Next;
+ }
+ /* make array of bindings */
+ objs = HeapReAlloc(GetProcessHeap(), 0, objs, count*sizeof(HANDLE));
+ objs[0] = m_event;
+ count = 1;
+ cps = protseqs;
+ while (cps) {
+ bind = cps->bind;
+ while (bind) {
+ if (bind->ovl.hEvent) objs[count++] = bind->ovl.hEvent;
+ bind = bind->Next;
+ }
+ cps = cps->Next;
+ }
+ LeaveCriticalSection(&server_cs);
+
+ /* start waiting */
+ res = WaitForMultipleObjects(count, objs, FALSE, INFINITE);
+ if (res == WAIT_OBJECT_0) {
+ if (listen_count == -1) break;
+ }
+ else if (res == WAIT_FAILED) {
+ ERR("wait failed\n");
+ }
+ else {
+ b_handle = objs[res - WAIT_OBJECT_0];
+ /* find which binding got a RPC */
+ EnterCriticalSection(&server_cs);
+ bind = NULL;
+ cps = protseqs;
+ while (cps) {
+ bind = cps->bind;
+ while (bind) {
+ if (bind->ovl.hEvent == b_handle) break;
+ bind = bind->Next;
+ }
+ if (bind) break;
+ cps = cps->Next;
+ }
+ cbind = NULL;
+ if (bind) RPCRT4_SpawnBinding(&cbind, bind);
+ LeaveCriticalSection(&server_cs);
+ if (!bind) {
+ ERR("failed to locate binding for handle %d\n", b_handle);
+ }
+ if (cbind) RPCRT4_new_client(cbind);
+ }
+ }
+ HeapFree(GetProcessHeap(), 0, objs);
+ EnterCriticalSection(&server_cs);
+ /* close bindings */
+ cps = protseqs;
+ while (cps) {
+ bind = cps->bind;
+ while (bind) {
+ RPCRT4_CloseBinding(bind);
+ bind = bind->Next;
+ }
+ cps = cps->Next;
+ }
+ LeaveCriticalSection(&server_cs);
+ return 0;
+}
+
+static void RPCRT4_start_listen(void)
+{
+ if (!InterlockedIncrement(&listen_count)) {
+ mgr_event = CreateEventA(NULL, FALSE, FALSE, NULL);
+ server_thread = CreateThread(NULL, 0, RPCRT4_server_thread, NULL, 0, NULL);
+ }
+ else SetEvent(mgr_event);
+}
+
+static void RPCRT4_stop_listen(void)
+{
+ HANDLE m_event = mgr_event;
+ if (InterlockedDecrement(&listen_count) < 0)
+ SetEvent(m_event);
+}
+
+static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq* ps)
+{
+ RPCRT4_CreateBindingA(&ps->bind, TRUE, ps->Protseq);
+ RPCRT4_CompleteBindingA(ps->bind, NULL, ps->Endpoint, NULL);
+
+ EnterCriticalSection(&server_cs);
+ ps->Next = protseqs;
+ protseqs = ps;
+ LeaveCriticalSection(&server_cs);
+
+ if (listen_count >= 0) SetEvent(mgr_event);
+
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * RpcServerInqBindings (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerInqBindings( RPC_BINDING_VECTOR** BindingVector )
+{
+ RPC_STATUS status;
+ DWORD count;
+ RpcServerProtseq* ps;
+ RpcBinding* bind;
+
+ EnterCriticalSection(&server_cs);
+ /* count bindings */
+ count = 0;
+ ps = protseqs;
+ while (ps) {
+ bind = ps->bind;
+ while (bind) {
+ count++;
+ bind = bind->Next;
+ }
+ ps = ps->Next;
+ }
+ if (count) {
+ /* export bindings */
+ *BindingVector = HeapAlloc(GetProcessHeap(), 0,
+ sizeof(RPC_BINDING_VECTOR) +
+ sizeof(RPC_BINDING_HANDLE)*(count-1));
+ (*BindingVector)->Count = count;
+ count = 0;
+ ps = protseqs;
+ while (ps) {
+ bind = ps->bind;
+ while (bind) {
+ RPCRT4_ExportBinding((RpcBinding**)&(*BindingVector)->BindingH[count],
+ bind);
+ count++;
+ bind = bind->Next;
+ }
+ ps = ps->Next;
+ }
+ status = RPC_S_OK;
+ } else {
+ *BindingVector = NULL;
+ status = RPC_S_NO_BINDINGS;
+ }
+ LeaveCriticalSection(&server_cs);
+ return status;
+}
+
+/***********************************************************************
+ * RpcServerUseProtseqEpA (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerUseProtseqEpA( LPSTR Protseq, UINT MaxCalls, LPSTR Endpoint, LPVOID SecurityDescriptor )
+{
+ RPC_POLICY policy;
+
+ TRACE( "(%s,%u,%s,%p)\n", Protseq, MaxCalls, Endpoint, SecurityDescriptor );
+
+ /* This should provide the default behaviour */
+ policy.Length = sizeof( policy );
+ policy.EndpointFlags = 0;
+ policy.NICFlags = 0;
+
+ return RpcServerUseProtseqEpExA( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
+}
+
+/***********************************************************************
+ * RpcServerUseProtseqEpW (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerUseProtseqEpW( LPWSTR Protseq, UINT MaxCalls, LPWSTR Endpoint, LPVOID SecurityDescriptor )
+{
+ RPC_POLICY policy;
+
+ TRACE( "(%s,%u,%s,%p)\n", debugstr_w( Protseq ), MaxCalls, debugstr_w( Endpoint ), SecurityDescriptor );
+
+ /* This should provide the default behaviour */
+ policy.Length = sizeof( policy );
+ policy.EndpointFlags = 0;
+ policy.NICFlags = 0;
+
+ return RpcServerUseProtseqEpExW( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
+}
+
+/***********************************************************************
+ * RpcServerUseProtseqEpExA (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerUseProtseqEpExA( LPSTR Protseq, UINT MaxCalls, LPSTR Endpoint, LPVOID SecurityDescriptor,
+ PRPC_POLICY lpPolicy )
+{
+ RpcServerProtseq* ps;
+
+ TRACE("(%s,%u,%s,%p,{%u,%lu,%lu}): stub\n", debugstr_a( Protseq ), MaxCalls,
+ debugstr_a( Endpoint ), SecurityDescriptor,
+ lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
+
+ ps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcServerProtseq));
+ ps->MaxCalls = MaxCalls;
+ ps->Protseq = RPCRT4_strdupA(Protseq);
+ ps->Endpoint = RPCRT4_strdupA(Endpoint);
+
+ return RPCRT4_use_protseq(ps);
+}
+
+/***********************************************************************
+ * RpcServerUseProtseqEpExW (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerUseProtseqEpExW( LPWSTR Protseq, UINT MaxCalls, LPWSTR Endpoint, LPVOID SecurityDescriptor,
+ PRPC_POLICY lpPolicy )
+{
+ RpcServerProtseq* ps;
+
+ TRACE("(%s,%u,%s,%p,{%u,%lu,%lu}): stub\n", debugstr_w( Protseq ), MaxCalls,
+ debugstr_w( Endpoint ), SecurityDescriptor,
+ lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
+
+ ps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcServerProtseq));
+ ps->MaxCalls = MaxCalls;
+ ps->Protseq = RPCRT4_strdupW(Protseq);
+ ps->Endpoint = RPCRT4_strdupW(Endpoint);
+
+ return RPCRT4_use_protseq(ps);
+}
+
+/***********************************************************************
+ * RpcServerRegisterIf (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerRegisterIf( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv )
+{
+ TRACE("(%p,%s,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv);
+ return RpcServerRegisterIf2( IfSpec, MgrTypeUuid, MgrEpv, 0, RPC_C_LISTEN_MAX_CALLS_DEFAULT, (UINT)-1, NULL );
+}
+
+/***********************************************************************
+ * RpcServerRegisterIfEx (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerRegisterIfEx( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
+ UINT Flags, UINT MaxCalls, RPC_IF_CALLBACK_FN* IfCallbackFn )
+{
+ TRACE("(%p,%s,%p,%u,%u,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv, Flags, MaxCalls, IfCallbackFn);
+ return RpcServerRegisterIf2( IfSpec, MgrTypeUuid, MgrEpv, Flags, MaxCalls, (UINT)-1, IfCallbackFn );
+}
+
+/***********************************************************************
+ * RpcServerRegisterIf2 (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerRegisterIf2( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
+ UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN* IfCallbackFn )
+{
+ PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
+ RpcServerInterface* sif;
+ int i;
+
+ TRACE("(%p,%s,%p,%u,%u,%u,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv, Flags, MaxCalls,
+ MaxRpcSize, IfCallbackFn);
+ TRACE(" interface id: %s %d.%d\n", debugstr_guid(&If->InterfaceId.SyntaxGUID),
+ If->InterfaceId.SyntaxVersion.MajorVersion,
+ If->InterfaceId.SyntaxVersion.MinorVersion);
+ TRACE(" transfer syntax: %s %d.%d\n", debugstr_guid(&If->InterfaceId.SyntaxGUID),
+ If->InterfaceId.SyntaxVersion.MajorVersion,
+ If->InterfaceId.SyntaxVersion.MinorVersion);
+ TRACE(" dispatch table: %p\n", If->DispatchTable);
+ if (If->DispatchTable) {
+ TRACE(" dispatch table count: %d\n", If->DispatchTable->DispatchTableCount);
+ for (i=0; i<If->DispatchTable->DispatchTableCount; i++) {
+ TRACE(" entry %d: %p\n", i, If->DispatchTable->DispatchTable[i]);
+ }
+ TRACE(" reserved: %d\n", If->DispatchTable->Reserved);
+ }
+ TRACE(" protseq endpoint count: %d\n", If->RpcProtseqEndpointCount);
+ TRACE(" default manager epv: %p\n", If->DefaultManagerEpv);
+ TRACE(" interpreter info: %p\n", If->InterpreterInfo);
+ TRACE(" flags: %08x\n", If->Flags);
+
+ sif = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcServerInterface));
+ sif->If = If;
+ if (MgrTypeUuid)
+ memcpy(&sif->MgrTypeUuid, MgrTypeUuid, sizeof(UUID));
+ else
+ memset(&sif->MgrTypeUuid, 0, sizeof(UUID));
+ sif->MgrEpv = MgrEpv;
+ sif->Flags = Flags;
+ sif->MaxCalls = MaxCalls;
+ sif->MaxRpcSize = MaxRpcSize;
+ sif->IfCallbackFn = IfCallbackFn;
+
+ EnterCriticalSection(&server_cs);
+ sif->Next = ifs;
+ ifs = sif;
+ LeaveCriticalSection(&server_cs);
+
+ if (sif->Flags & RPC_IF_AUTOLISTEN) {
+ /* well, start listening, I think... */
+ RPCRT4_start_listen();
+ }
+
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * RpcServerRegisterAuthInfoA (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerRegisterAuthInfoA( LPSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
+ LPVOID Arg )
+{
+ FIXME( "(%s,%lu,%p,%p): stub\n", ServerPrincName, AuthnSvc, GetKeyFn, Arg );
+
+ return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
+}
+
+/***********************************************************************
+ * RpcServerRegisterAuthInfoW (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerRegisterAuthInfoW( LPWSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
+ LPVOID Arg )
+{
+ FIXME( "(%s,%lu,%p,%p): stub\n", debugstr_w( ServerPrincName ), AuthnSvc, GetKeyFn, Arg );
+
+ return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
+}
+
+/***********************************************************************
+ * RpcServerListen (RPCRT4.@)
+ */
+RPC_STATUS WINAPI RpcServerListen( UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait )
+{
+ TRACE("(%u,%u,%u)\n", MinimumCallThreads, MaxCalls, DontWait);
+
+ if (std_listen)
+ return RPC_S_ALREADY_LISTENING;
+
+ if (!protseqs)
+ return RPC_S_NO_PROTSEQS_REGISTERED;
+
+ std_listen = TRUE;
+ RPCRT4_start_listen();
+
+ if (DontWait) return RPC_S_OK;
+
+ /* RpcMgmtWaitServerListen(); */
+ FIXME("can't wait yet\n");
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * I_RpcServerStartListening (RPCRT4.@)
+ */
+RPC_STATUS WINAPI I_RpcServerStartListening( void* hWnd )
+{
+ FIXME( "(%p): stub\n", hWnd );
+
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * I_RpcServerStopListening (RPCRT4.@)
+ */
+RPC_STATUS WINAPI I_RpcServerStopListening( void )
+{
+ FIXME( "(): stub\n" );
+
+ return RPC_S_OK;
+}
+
+/***********************************************************************
+ * I_RpcWindowProc (RPCRT4.@)
+ */
+UINT WINAPI I_RpcWindowProc( void* hWnd, UINT Message, UINT wParam, ULONG lParam )
+{
+ FIXME( "(%p,%08x,%08x,%08lx): stub\n", hWnd, Message, wParam, lParam );
+
+ return 0;
+}
+
+
