47af519df5f2fb0e75901171a9dea5c20bf66b99
[reactos.git] / reactos / lib / rpcrt4 / ndr_midl.c
1 /*
2 * MIDL proxy/stub stuff
3 *
4 * Copyright 2002 Ove Kåven, TransGaming Technologies
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * TODO:
21 * - figure out whether we *really* got this right
22 * - check for errors and throw exceptions
23 */
24
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include <string.h>
28 #include <assert.h>
29
30 #define COBJMACROS
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winerror.h"
35 #include "winreg.h"
36
37 #include "objbase.h"
38
39 #include "rpcproxy.h"
40
41 #include "wine/debug.h"
42
43 #include "cpsf.h"
44 #include "ndr_misc.h"
45 #include "rpcndr.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
48
49 /***********************************************************************
50 * NdrProxyInitialize [RPCRT4.@]
51 */
52 void WINAPI NdrProxyInitialize(void *This,
53 PRPC_MESSAGE pRpcMsg,
54 PMIDL_STUB_MESSAGE pStubMsg,
55 PMIDL_STUB_DESC pStubDescriptor,
56 unsigned int ProcNum)
57 {
58 HRESULT hr;
59
60 TRACE("(%p,%p,%p,%p,%d)\n", This, pRpcMsg, pStubMsg, pStubDescriptor, ProcNum);
61 NdrClientInitializeNew(pRpcMsg, pStubMsg, pStubDescriptor, ProcNum);
62 if (This) StdProxy_GetChannel(This, &pStubMsg->pRpcChannelBuffer);
63 if (pStubMsg->pRpcChannelBuffer) {
64 hr = IRpcChannelBuffer_GetDestCtx(pStubMsg->pRpcChannelBuffer,
65 &pStubMsg->dwDestContext,
66 &pStubMsg->pvDestContext);
67 }
68 TRACE("channel=%p\n", pStubMsg->pRpcChannelBuffer);
69 }
70
71 /***********************************************************************
72 * NdrProxyGetBuffer [RPCRT4.@]
73 */
74 void WINAPI NdrProxyGetBuffer(void *This,
75 PMIDL_STUB_MESSAGE pStubMsg)
76 {
77 HRESULT hr;
78 const IID *riid = NULL;
79
80 TRACE("(%p,%p)\n", This, pStubMsg);
81 pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
82 pStubMsg->dwStubPhase = PROXY_GETBUFFER;
83 hr = StdProxy_GetIID(This, &riid);
84 hr = IRpcChannelBuffer_GetBuffer(pStubMsg->pRpcChannelBuffer,
85 (RPCOLEMESSAGE*)pStubMsg->RpcMsg,
86 riid);
87 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
88 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
89 pStubMsg->Buffer = pStubMsg->BufferStart;
90 pStubMsg->dwStubPhase = PROXY_MARSHAL;
91 }
92
93 /***********************************************************************
94 * NdrProxySendReceive [RPCRT4.@]
95 */
96 void WINAPI NdrProxySendReceive(void *This,
97 PMIDL_STUB_MESSAGE pStubMsg)
98 {
99 ULONG Status = 0;
100 HRESULT hr;
101
102 TRACE("(%p,%p)\n", This, pStubMsg);
103
104 if (!pStubMsg->pRpcChannelBuffer)
105 {
106 WARN("Trying to use disconnected proxy %p\n", This);
107 RpcRaiseException(RPC_E_DISCONNECTED);
108 }
109
110 pStubMsg->dwStubPhase = PROXY_SENDRECEIVE;
111 hr = IRpcChannelBuffer_SendReceive(pStubMsg->pRpcChannelBuffer,
112 (RPCOLEMESSAGE*)pStubMsg->RpcMsg,
113 &Status);
114 pStubMsg->dwStubPhase = PROXY_UNMARSHAL;
115 pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
116 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
117 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
118 pStubMsg->Buffer = pStubMsg->BufferStart;
119
120 /* raise exception if call failed */
121 if (hr == RPC_S_CALL_FAILED) RpcRaiseException(*(DWORD*)pStubMsg->Buffer);
122 else if (FAILED(hr)) RpcRaiseException(hr);
123 }
124
125 /***********************************************************************
126 * NdrProxyFreeBuffer [RPCRT4.@]
127 */
128 void WINAPI NdrProxyFreeBuffer(void *This,
129 PMIDL_STUB_MESSAGE pStubMsg)
130 {
131 HRESULT hr;
132
133 TRACE("(%p,%p)\n", This, pStubMsg);
134 hr = IRpcChannelBuffer_FreeBuffer(pStubMsg->pRpcChannelBuffer,
135 (RPCOLEMESSAGE*)pStubMsg->RpcMsg);
136 }
137
138 /***********************************************************************
139 * NdrProxyErrorHandler [RPCRT4.@]
140 */
141 HRESULT WINAPI NdrProxyErrorHandler(DWORD dwExceptionCode)
142 {
143 FIXME("(0x%08lx): semi-stub\n", dwExceptionCode);
144 return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_RPC, RPC_S_CALL_FAILED);
145 }
146
147 /***********************************************************************
148 * NdrStubInitialize [RPCRT4.@]
149 */
150 void WINAPI NdrStubInitialize(PRPC_MESSAGE pRpcMsg,
151 PMIDL_STUB_MESSAGE pStubMsg,
152 PMIDL_STUB_DESC pStubDescriptor,
153 LPRPCCHANNELBUFFER pRpcChannelBuffer)
154 {
155 TRACE("(%p,%p,%p,%p)\n", pRpcMsg, pStubMsg, pStubDescriptor, pRpcChannelBuffer);
156 NdrServerInitializeNew(pRpcMsg, pStubMsg, pStubDescriptor);
157 pStubMsg->pRpcChannelBuffer = pRpcChannelBuffer;
158 }
159
160 /***********************************************************************
161 * NdrStubGetBuffer [RPCRT4.@]
162 */
163 void WINAPI NdrStubGetBuffer(LPRPCSTUBBUFFER This,
164 LPRPCCHANNELBUFFER pRpcChannelBuffer,
165 PMIDL_STUB_MESSAGE pStubMsg)
166 {
167 TRACE("(%p,%p)\n", This, pStubMsg);
168 pStubMsg->pRpcChannelBuffer = pRpcChannelBuffer;
169 pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
170 I_RpcGetBuffer(pStubMsg->RpcMsg); /* ? */
171 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
172 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
173 pStubMsg->Buffer = pStubMsg->BufferStart;
174 }
175
176 /************************************************************************
177 * NdrClientInitializeNew [RPCRT4.@]
178 */
179 void WINAPI NdrClientInitializeNew( PRPC_MESSAGE pRpcMessage, PMIDL_STUB_MESSAGE pStubMsg,
180 PMIDL_STUB_DESC pStubDesc, unsigned int ProcNum )
181 {
182 TRACE("(pRpcMessage == ^%p, pStubMsg == ^%p, pStubDesc == ^%p, ProcNum == %d)\n",
183 pRpcMessage, pStubMsg, pStubDesc, ProcNum);
184
185 assert( pRpcMessage && pStubMsg && pStubDesc );
186
187 memset(pRpcMessage, 0, sizeof(RPC_MESSAGE));
188 pRpcMessage->DataRepresentation = NDR_LOCAL_DATA_REPRESENTATION;
189
190 /* not everyone allocates stack space for w2kReserved */
191 memset(pStubMsg, 0, FIELD_OFFSET(MIDL_STUB_MESSAGE,pCSInfo));
192
193 pStubMsg->ReuseBuffer = FALSE;
194 pStubMsg->IsClient = TRUE;
195 pStubMsg->StubDesc = pStubDesc;
196 pStubMsg->pfnAllocate = pStubDesc->pfnAllocate;
197 pStubMsg->pfnFree = pStubDesc->pfnFree;
198 pStubMsg->RpcMsg = pRpcMessage;
199
200 pRpcMessage->ProcNum = ProcNum;
201 pRpcMessage->RpcInterfaceInformation = pStubDesc->RpcInterfaceInformation;
202 }
203
204 /***********************************************************************
205 * NdrServerInitializeNew [RPCRT4.@]
206 */
207 unsigned char* WINAPI NdrServerInitializeNew( PRPC_MESSAGE pRpcMsg, PMIDL_STUB_MESSAGE pStubMsg,
208 PMIDL_STUB_DESC pStubDesc )
209 {
210 TRACE("(pRpcMsg == ^%p, pStubMsg == ^%p, pStubDesc == ^%p)\n", pRpcMsg, pStubMsg, pStubDesc);
211
212 assert( pRpcMsg && pStubMsg && pStubDesc );
213
214 /* not everyone allocates stack space for w2kReserved */
215 memset(pStubMsg, 0, FIELD_OFFSET(MIDL_STUB_MESSAGE,pCSInfo));
216
217 pStubMsg->ReuseBuffer = TRUE;
218 pStubMsg->IsClient = FALSE;
219 pStubMsg->StubDesc = pStubDesc;
220 pStubMsg->pfnAllocate = pStubDesc->pfnAllocate;
221 pStubMsg->pfnFree = pStubDesc->pfnFree;
222 pStubMsg->RpcMsg = pRpcMsg;
223 pStubMsg->Buffer = pStubMsg->BufferStart = pRpcMsg->Buffer;
224 pStubMsg->BufferLength = pRpcMsg->BufferLength;
225 pStubMsg->BufferEnd = pStubMsg->Buffer + pStubMsg->BufferLength;
226
227 /* FIXME: determine the proper return value */
228 return NULL;
229 }
230
231 /***********************************************************************
232 * NdrGetBuffer [RPCRT4.@]
233 */
234 unsigned char *WINAPI NdrGetBuffer(MIDL_STUB_MESSAGE *stubmsg, unsigned long buflen, RPC_BINDING_HANDLE handle)
235 {
236 TRACE("(stubmsg == ^%p, buflen == %lu, handle == %p): wild guess.\n", stubmsg, buflen, handle);
237
238 assert( stubmsg && stubmsg->RpcMsg );
239
240 /* I guess this is our chance to put the binding handle into the RPC_MESSAGE */
241 stubmsg->RpcMsg->Handle = handle;
242
243 stubmsg->RpcMsg->BufferLength = buflen;
244 if (I_RpcGetBuffer(stubmsg->RpcMsg) != S_OK)
245 return NULL;
246
247 stubmsg->Buffer = stubmsg->BufferStart = stubmsg->RpcMsg->Buffer;
248 stubmsg->BufferLength = stubmsg->RpcMsg->BufferLength;
249 stubmsg->BufferEnd = stubmsg->Buffer + stubmsg->BufferLength;
250 return (stubmsg->Buffer = (unsigned char *)stubmsg->RpcMsg->Buffer);
251 }
252
253 /***********************************************************************
254 * NdrFreeBuffer [RPCRT4.@]
255 */
256 void WINAPI NdrFreeBuffer(MIDL_STUB_MESSAGE *pStubMsg)
257 {
258 TRACE("(pStubMsg == ^%p): wild guess.\n", pStubMsg);
259 I_RpcFreeBuffer(pStubMsg->RpcMsg);
260 pStubMsg->BufferLength = 0;
261 pStubMsg->Buffer = pStubMsg->BufferEnd = (unsigned char *)(pStubMsg->RpcMsg->Buffer = NULL);
262 }
263
264 /************************************************************************
265 * NdrSendReceive [RPCRT4.@]
266 */
267 unsigned char *WINAPI NdrSendReceive( MIDL_STUB_MESSAGE *pStubMsg, unsigned char *buffer )
268 {
269 TRACE("(pStubMsg == ^%p, buffer == ^%p)\n", pStubMsg, buffer);
270
271 /* FIXME: how to handle errors? (raise exception?) */
272 if (!pStubMsg) {
273 ERR("NULL stub message. No action taken.\n");
274 return NULL;
275 }
276 if (!pStubMsg->RpcMsg) {
277 ERR("RPC Message not present in stub message. No action taken.\n");
278 return NULL;
279 }
280
281 if (I_RpcSendReceive(pStubMsg->RpcMsg) != RPC_S_OK) {
282 WARN("I_RpcSendReceive did not return success.\n");
283 /* FIXME: raise exception? */
284 return NULL;
285 }
286
287 pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
288 pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
289 pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
290 pStubMsg->Buffer = pStubMsg->BufferStart;
291
292 /* FIXME: is this the right return value? */
293 return NULL;
294 }
295
296 /************************************************************************
297 * NdrMapCommAndFaultStatus [RPCRT4.@]
298 */
299 RPC_STATUS RPC_ENTRY NdrMapCommAndFaultStatus( PMIDL_STUB_MESSAGE pStubMsg,
300 unsigned long *pCommStatus,
301 unsigned long *pFaultStatus,
302 RPC_STATUS Status )
303 {
304 FIXME("(%p, %p, %p, %ld): stub\n", pStubMsg, pCommStatus, pFaultStatus, Status);
305
306 *pCommStatus = 0;
307 *pFaultStatus = 0;
308
309 return RPC_S_OK;
310 }