ReactOS  0.4.14-dev-358-gbef841c
ndr_es.c
Go to the documentation of this file.
1 /*
2  * NDR Serialization Services
3  *
4  * Copyright (c) 2007 Robert Shearman for CodeWeavers
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20 
21 #include <stdarg.h>
22 #include <stdio.h>
23 
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27 #include "rpc.h"
28 #include "midles.h"
29 #include "ndrtypes.h"
30 
31 #include "ndr_misc.h"
32 #include "ndr_stubless.h"
33 
34 #include "wine/debug.h"
35 
37 
38 static inline void init_MIDL_ES_MESSAGE(MIDL_ES_MESSAGE *pEsMsg)
39 {
40  memset(pEsMsg, 0, sizeof(*pEsMsg));
41  /* even if we are unmarshalling, as we don't want pointers to be pointed
42  * to buffer memory */
43  pEsMsg->StubMsg.IsClient = TRUE;
44  pEsMsg->MesVersion = 1;
45 }
46 
47 /***********************************************************************
48  * MesEncodeIncrementalHandleCreate [RPCRT4.@]
49  */
51  void *UserState, MIDL_ES_ALLOC AllocFn, MIDL_ES_WRITE WriteFn,
52  handle_t *pHandle)
53 {
54  MIDL_ES_MESSAGE *pEsMsg;
55 
56  TRACE("(%p, %p, %p, %p)\n", UserState, AllocFn, WriteFn, pHandle);
57 
58  pEsMsg = HeapAlloc(GetProcessHeap(), 0, sizeof(*pEsMsg));
59  if (!pEsMsg)
60  return RPC_S_OUT_OF_MEMORY;
61 
62  init_MIDL_ES_MESSAGE(pEsMsg);
63 
64  pEsMsg->Operation = MES_ENCODE;
65  pEsMsg->UserState = UserState;
67  pEsMsg->Alloc = AllocFn;
68  pEsMsg->Write = WriteFn;
69 
70  *pHandle = (handle_t)pEsMsg;
71 
72  return RPC_S_OK;
73 }
74 
75 /***********************************************************************
76  * MesDecodeIncrementalHandleCreate [RPCRT4.@]
77  */
79  void *UserState, MIDL_ES_READ ReadFn, handle_t *pHandle)
80 {
81  MIDL_ES_MESSAGE *pEsMsg;
82 
83  TRACE("(%p, %p, %p)\n", UserState, ReadFn, pHandle);
84 
85  pEsMsg = HeapAlloc(GetProcessHeap(), 0, sizeof(*pEsMsg));
86  if (!pEsMsg)
87  return RPC_S_OUT_OF_MEMORY;
88 
89  init_MIDL_ES_MESSAGE(pEsMsg);
90 
91  pEsMsg->Operation = MES_DECODE;
92  pEsMsg->UserState = UserState;
94  pEsMsg->Read = ReadFn;
95 
96  *pHandle = (handle_t)pEsMsg;
97 
98  return RPC_S_OK;
99 }
100 
101 /***********************************************************************
102  * MesIncrementalHandleReset [RPCRT4.@]
103  */
105  handle_t Handle, void *UserState, MIDL_ES_ALLOC AllocFn,
107 {
108  MIDL_ES_MESSAGE *pEsMsg = Handle;
109 
110  TRACE("(%p, %p, %p, %p, %p, %d)\n", Handle, UserState, AllocFn,
111  WriteFn, ReadFn, Operation);
112 
113  init_MIDL_ES_MESSAGE(pEsMsg);
114 
115  pEsMsg->Operation = Operation;
116  pEsMsg->UserState = UserState;
118  pEsMsg->Alloc = AllocFn;
119  pEsMsg->Write = WriteFn;
120  pEsMsg->Read = ReadFn;
121 
122  return RPC_S_OK;
123 }
124 
125 /***********************************************************************
126  * MesBufferHandleReset [RPCRT4.@]
127  */
129  MIDL_ES_CODE Operation, char **Buffer, ULONG BufferSize, ULONG *EncodedSize)
130 {
132 
133  TRACE("(%p, %u, %d, %p, %u, %p)\n", Handle, HandleStyle, Operation, Buffer,
134  BufferSize, EncodedSize);
135 
136  if (!Handle || !Buffer || !EncodedSize)
137  return RPC_S_INVALID_ARG;
138 
140  return RPC_S_INVALID_ARG;
141 
142  if (HandleStyle != MES_FIXED_BUFFER_HANDLE && HandleStyle != MES_DYNAMIC_BUFFER_HANDLE)
143  return RPC_S_INVALID_ARG;
144 
145  init_MIDL_ES_MESSAGE(pEsMsg);
146 
147  pEsMsg->Operation = Operation;
148  pEsMsg->HandleStyle = HandleStyle;
149  if (HandleStyle == MES_FIXED_BUFFER_HANDLE)
150  pEsMsg->Buffer = (unsigned char*)*Buffer;
151  else
152  pEsMsg->pDynBuffer = (unsigned char**)Buffer;
153  pEsMsg->BufferSize = BufferSize;
154  pEsMsg->pEncodedSize = EncodedSize;
155 
156  return RPC_S_OK;
157 }
158 
159 /***********************************************************************
160  * MesHandleFree [RPCRT4.@]
161  */
163 {
164  TRACE("(%p)\n", Handle);
166  return RPC_S_OK;
167 }
168 
170 {
171  if (!Buffer)
172  return RPC_S_INVALID_ARG;
173 
174  if (((ULONG_PTR)Buffer & 7) != 0)
175  return RPC_X_INVALID_BUFFER;
176 
177  return RPC_S_OK;
178 }
179 
180 /***********************************************************************
181  * MesEncodeFixedBufferHandleCreate [RPCRT4.@]
182  */
184  char *Buffer, ULONG BufferSize, ULONG *pEncodedSize, handle_t *pHandle)
185 {
186  MIDL_ES_MESSAGE *pEsMsg;
188 
189  TRACE("(%p, %d, %p, %p)\n", Buffer, BufferSize, pEncodedSize, pHandle);
190 
192  return status;
193 
194  if (!pEncodedSize)
195  return RPC_S_INVALID_ARG;
196 
197  /* FIXME: check BufferSize too */
198 
199  pEsMsg = HeapAlloc(GetProcessHeap(), 0, sizeof(*pEsMsg));
200  if (!pEsMsg)
201  return RPC_S_OUT_OF_MEMORY;
202 
203  init_MIDL_ES_MESSAGE(pEsMsg);
204 
205  pEsMsg->Operation = MES_ENCODE;
207  pEsMsg->Buffer = (unsigned char *)Buffer;
208  pEsMsg->BufferSize = BufferSize;
209  pEsMsg->pEncodedSize = pEncodedSize;
210 
211  *pHandle = (handle_t)pEsMsg;
212 
213  return RPC_S_OK;
214 }
215 
216 /***********************************************************************
217  * MesEncodeDynBufferHandleCreate [RPCRT4.@]
218  */
220  ULONG *pEncodedSize, handle_t *pHandle)
221 {
222  MIDL_ES_MESSAGE *pEsMsg;
223 
224  TRACE("(%p, %p, %p)\n", Buffer, pEncodedSize, pHandle);
225 
226  if (!pEncodedSize)
227  return RPC_S_INVALID_ARG;
228 
229  pEsMsg = HeapAlloc(GetProcessHeap(), 0, sizeof(*pEsMsg));
230  if (!pEsMsg)
231  return RPC_S_OUT_OF_MEMORY;
232 
233  init_MIDL_ES_MESSAGE(pEsMsg);
234 
235  pEsMsg->Operation = MES_ENCODE;
237  pEsMsg->pDynBuffer = (unsigned char **)Buffer;
238  pEsMsg->pEncodedSize = pEncodedSize;
239 
240  *pHandle = (handle_t)pEsMsg;
241 
242  return RPC_S_OK;
243 }
244 
245 /***********************************************************************
246  * MesDecodeBufferHandleCreate [RPCRT4.@]
247  */
249  char *Buffer, ULONG BufferSize, handle_t *pHandle)
250 {
251  MIDL_ES_MESSAGE *pEsMsg;
253 
254  TRACE("(%p, %d, %p)\n", Buffer, BufferSize, pHandle);
255 
257  return status;
258 
259  pEsMsg = HeapAlloc(GetProcessHeap(), 0, sizeof(*pEsMsg));
260  if (!pEsMsg)
261  return RPC_S_OUT_OF_MEMORY;
262 
263  init_MIDL_ES_MESSAGE(pEsMsg);
264 
265  pEsMsg->Operation = MES_DECODE;
267  pEsMsg->Buffer = (unsigned char *)Buffer;
268  pEsMsg->BufferSize = BufferSize;
269 
270  *pHandle = (handle_t)pEsMsg;
271 
272  return RPC_S_OK;
273 }
274 
276 {
277  if (pEsMsg->HandleStyle == MES_INCREMENTAL_HANDLE)
278  {
279  unsigned int tmpsize = size;
280  TRACE("%d with incremental handle\n", size);
281  pEsMsg->Alloc(pEsMsg->UserState, (char **)&pEsMsg->StubMsg.Buffer, &tmpsize);
282  if (tmpsize < size)
283  {
284  ERR("not enough bytes allocated - requested %d, got %d\n", size, tmpsize);
286  }
287  }
288  else if (pEsMsg->HandleStyle == MES_FIXED_BUFFER_HANDLE)
289  {
290  TRACE("%d with fixed buffer handle\n", size);
291  pEsMsg->StubMsg.Buffer = pEsMsg->Buffer;
292  }
293  pEsMsg->StubMsg.RpcMsg->Buffer = pEsMsg->StubMsg.BufferStart = pEsMsg->StubMsg.Buffer;
294 }
295 
296 static void es_data_read(MIDL_ES_MESSAGE *pEsMsg, ULONG size)
297 {
298  if (pEsMsg->HandleStyle == MES_INCREMENTAL_HANDLE)
299  {
300  unsigned int tmpsize = size;
301  TRACE("%d from incremental handle\n", size);
302  pEsMsg->Read(pEsMsg->UserState, (char **)&pEsMsg->StubMsg.Buffer, &tmpsize);
303  if (tmpsize < size)
304  {
305  ERR("not enough bytes read - requested %d, got %d\n", size, tmpsize);
307  }
308  }
309  else
310  {
311  TRACE("%d from fixed or dynamic buffer handle\n", size);
312  /* FIXME: validate BufferSize? */
313  pEsMsg->StubMsg.Buffer = pEsMsg->Buffer;
314  pEsMsg->Buffer += size;
315  pEsMsg->BufferSize -= size;
316  }
317  pEsMsg->StubMsg.BufferLength = size;
318  pEsMsg->StubMsg.RpcMsg->Buffer = pEsMsg->StubMsg.BufferStart = pEsMsg->StubMsg.Buffer;
319  pEsMsg->StubMsg.BufferEnd = pEsMsg->StubMsg.Buffer + size;
320 }
321 
323 {
324  if (pEsMsg->HandleStyle == MES_INCREMENTAL_HANDLE)
325  {
326  TRACE("%d to incremental handle\n", size);
327  pEsMsg->Write(pEsMsg->UserState, (char *)pEsMsg->StubMsg.BufferStart, size);
328  }
329  else
330  {
331  TRACE("%d to dynamic or fixed buffer handle\n", size);
332  *pEsMsg->pEncodedSize += size;
333  }
334 }
335 
337 {
338  return 4 + 2*sizeof(RPC_SYNTAX_IDENTIFIER) + 12;
339 }
340 
342 {
343  const RPC_CLIENT_INTERFACE *client_interface = pEsMsg->StubMsg.StubDesc->RpcInterfaceInformation;
344  *(WORD *)pEsMsg->StubMsg.Buffer = 0x0101;
345  pEsMsg->StubMsg.Buffer += 2;
346  *(WORD *)pEsMsg->StubMsg.Buffer = 0xcccc;
347  pEsMsg->StubMsg.Buffer += 2;
348  memcpy(pEsMsg->StubMsg.Buffer, &client_interface->TransferSyntax, sizeof(RPC_SYNTAX_IDENTIFIER));
349  pEsMsg->StubMsg.Buffer += sizeof(RPC_SYNTAX_IDENTIFIER);
350  memcpy(pEsMsg->StubMsg.Buffer, &pEsMsg->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER));
351  pEsMsg->StubMsg.Buffer += sizeof(RPC_SYNTAX_IDENTIFIER);
352  *(DWORD *)pEsMsg->StubMsg.Buffer = pEsMsg->ProcNumber;
353  pEsMsg->StubMsg.Buffer += 4;
354  *(DWORD *)pEsMsg->StubMsg.Buffer = 0x00000001;
355  pEsMsg->StubMsg.Buffer += 4;
356  *(DWORD *)pEsMsg->StubMsg.Buffer = pEsMsg->ByteCount;
357  pEsMsg->StubMsg.Buffer += 4;
358 }
359 
361 {
362  const RPC_CLIENT_INTERFACE *client_interface = pEsMsg->StubMsg.StubDesc->RpcInterfaceInformation;
363 
365 
366  if (*(WORD *)pEsMsg->StubMsg.Buffer != 0x0101)
367  {
368  FIXME("unknown value at Buffer[0] 0x%04x\n", *(WORD *)pEsMsg->StubMsg.Buffer);
370  }
371  pEsMsg->StubMsg.Buffer += 2;
372  if (*(WORD *)pEsMsg->StubMsg.Buffer != 0xcccc)
373  FIXME("unknown value at Buffer[2] 0x%04x\n", *(WORD *)pEsMsg->StubMsg.Buffer);
374  pEsMsg->StubMsg.Buffer += 2;
375  if (memcmp(pEsMsg->StubMsg.Buffer, &client_interface->TransferSyntax, sizeof(RPC_SYNTAX_IDENTIFIER)))
376  {
377  const RPC_SYNTAX_IDENTIFIER *AlienTransferSyntax = (const RPC_SYNTAX_IDENTIFIER *)pEsMsg->StubMsg.Buffer;
378  ERR("bad transfer syntax %s {%d.%d}\n", debugstr_guid(&AlienTransferSyntax->SyntaxGUID),
379  AlienTransferSyntax->SyntaxVersion.MajorVersion,
380  AlienTransferSyntax->SyntaxVersion.MinorVersion);
382  }
383  pEsMsg->StubMsg.Buffer += sizeof(RPC_SYNTAX_IDENTIFIER);
384  memcpy(&pEsMsg->InterfaceId, pEsMsg->StubMsg.Buffer, sizeof(RPC_SYNTAX_IDENTIFIER));
385  pEsMsg->StubMsg.Buffer += sizeof(RPC_SYNTAX_IDENTIFIER);
386  pEsMsg->ProcNumber = *(DWORD *)pEsMsg->StubMsg.Buffer;
387  pEsMsg->StubMsg.Buffer += 4;
388  if (*(DWORD *)pEsMsg->StubMsg.Buffer != 0x00000001)
389  FIXME("unknown value 0x%08x, expected 0x00000001\n", *(DWORD *)pEsMsg->StubMsg.Buffer);
390  pEsMsg->StubMsg.Buffer += 4;
391  pEsMsg->ByteCount = *(DWORD *)pEsMsg->StubMsg.Buffer;
392  pEsMsg->StubMsg.Buffer += 4;
393  if (pEsMsg->ByteCount + mes_proc_header_buffer_size() < pEsMsg->ByteCount)
395 }
396 
397 /***********************************************************************
398  * NdrMesProcEncodeDecode [RPCRT4.@]
399  */
401 {
402  /* pointer to start of stack where arguments start */
403  RPC_MESSAGE rpcMsg;
404  MIDL_ES_MESSAGE *pEsMsg = Handle;
405  /* size of stack */
406  unsigned short stack_size;
407  /* header for procedure string */
408  const NDR_PROC_HEADER *pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
409  const RPC_CLIENT_INTERFACE *client_interface;
411  unsigned int number_of_params;
412  ULONG_PTR arg_buffer[256];
413 
414  TRACE("Handle %p, pStubDesc %p, pFormat %p, ...\n", Handle, pStubDesc, pFormat);
415 
416  /* Later NDR language versions probably won't be backwards compatible */
417  if (pStubDesc->Version > 0x50002)
418  {
419  FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
421  }
422 
423  client_interface = pStubDesc->RpcInterfaceInformation;
424  pEsMsg->InterfaceId = client_interface->InterfaceId;
425 
426  if (pProcHeader->Oi_flags & Oi_HAS_RPCFLAGS)
427  {
428  const NDR_PROC_HEADER_RPC *header_rpc = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
429  stack_size = header_rpc->stack_size;
430  pEsMsg->ProcNumber = header_rpc->proc_num;
431  pFormat += sizeof(NDR_PROC_HEADER_RPC);
432  }
433  else
434  {
435  stack_size = pProcHeader->stack_size;
436  pEsMsg->ProcNumber = pProcHeader->proc_num;
437  pFormat += sizeof(NDR_PROC_HEADER);
438  }
439 
440  if (pProcHeader->handle_type == 0)
441  {
442  switch (*pFormat) /* handle_type */
443  {
444  case FC_BIND_PRIMITIVE: /* explicit primitive */
445  pFormat += sizeof(NDR_EHD_PRIMITIVE);
446  break;
447  case FC_BIND_GENERIC: /* explicit generic */
448  pFormat += sizeof(NDR_EHD_GENERIC);
449  break;
450  case FC_BIND_CONTEXT: /* explicit context */
451  pFormat += sizeof(NDR_EHD_CONTEXT);
452  break;
453  default:
454  ERR("bad explicit binding handle type (0x%02x)\n", pProcHeader->handle_type);
456  }
457  }
458 
459  TRACE("stack size: 0x%x\n", stack_size);
460  TRACE("proc num: %d\n", pEsMsg->ProcNumber);
461 
462  memset(&rpcMsg, 0, sizeof(rpcMsg));
463  pEsMsg->StubMsg.RpcMsg = &rpcMsg;
464  pEsMsg->StubMsg.StubDesc = pStubDesc;
465  pEsMsg->StubMsg.pfnAllocate = pStubDesc->pfnAllocate;
466  pEsMsg->StubMsg.pfnFree = pStubDesc->pfnFree;
467 
468  /* create the full pointer translation tables, if requested */
469  if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
471 
472  TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
473  TRACE("stubdesc version = 0x%x\n", pStubDesc->Version);
474  TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
475 
476  /* needed for conformance of top-level objects */
477  __ms_va_start( args, pFormat );
478  pEsMsg->StubMsg.StackTop = va_arg( args, unsigned char * );
479  __ms_va_end( args );
480 
481  pFormat = convert_old_args( &pEsMsg->StubMsg, pFormat, stack_size, FALSE,
482  arg_buffer, sizeof(arg_buffer), &number_of_params );
483 
484  switch (pEsMsg->Operation)
485  {
486  case MES_ENCODE:
488 
489  client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_CALCSIZE, NULL, number_of_params, NULL );
490 
492  es_data_alloc(pEsMsg, pEsMsg->StubMsg.BufferLength);
493 
494  mes_proc_header_marshal(pEsMsg);
495 
496  client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_MARSHAL, NULL, number_of_params, NULL );
497 
498  es_data_write(pEsMsg, pEsMsg->ByteCount);
499  break;
500  case MES_DECODE:
502 
503  es_data_read(pEsMsg, pEsMsg->ByteCount);
504 
505  client_do_args( &pEsMsg->StubMsg, pFormat, STUBLESS_UNMARSHAL, NULL, number_of_params, NULL );
506  break;
507  default:
509  return;
510  }
511  /* free the full pointer translation tables */
512  if (pProcHeader->Oi_flags & Oi_FULL_PTR_USED)
514 }
515 
517  const MIDL_STUB_DESC *pStubDesc, PFORMAT_STRING pFormatString, void *pObject)
518 {
519  FIXME("(%p, %p, %p, %p, %p)\n", Handle, pPicklingInfo, pStubDesc, pFormatString, pObject);
520 }
521 
523  const MIDL_STUB_DESC *pStubDesc, PFORMAT_STRING pFormatString, const void *pObject)
524 {
525  FIXME("(%p, %p, %p, %p, %p)\n", Handle, pPicklingInfo, pStubDesc, pFormatString, pObject);
526 }
527 
529  const MIDL_STUB_DESC *pStubDesc, PFORMAT_STRING pFormatString, void *pObject)
530 {
531  FIXME("(%p, %p, %p, %p, %p)\n", Handle, pPicklingInfo, pStubDesc, pFormatString, pObject);
532 }
unsigned short stack_size
Definition: ndr_stubless.h:93
void * RpcInterfaceInformation
Definition: rpcndr.h:362
void client_do_args(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, enum stubless_phase phase, void **fpu_args, unsigned short number_of_params, unsigned char *pRetVal)
Definition: ndr_stubless.c:469
#define RPC_S_UNSUPPORTED_TRANS_SYN
Definition: winerror.h:1040
#define TRUE
Definition: types.h:120
#define RPC_S_INVALID_BOUND
Definition: winerror.h:1043
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
RPC_STATUS WINAPI MesHandleFree(handle_t Handle)
Definition: ndr_es.c:162
ULONG HandleStyle
Definition: midles.h:54
static static const char __ms_va_list
Definition: printf.c:76
RPC_BINDING_HANDLE handle_t
Definition: rpcdce.h:51
struct _NDR_EHD_GENERIC NDR_EHD_GENERIC
unsigned short MajorVersion
Definition: rpcdcep.h:27
ULONG * pEncodedSize
Definition: midles.h:63
void WINAPI NdrFullPointerXlatFree(PFULL_PTR_XLAT_TABLES pXlatTables)
void(__RPC_USER * MIDL_ES_WRITE)(void *, char *, unsigned int)
Definition: midles.h:45
void DECLSPEC_NORETURN WINAPI RpcRaiseException(RPC_STATUS exception)
Definition: rpcrt4_main.c:189
ULONG ProcNumber
Definition: midles.h:65
unsigned char * Buffer
Definition: rpcndr.h:203
void(__RPC_USER * MIDL_ES_ALLOC)(void *, char **, unsigned int *)
Definition: midles.h:44
#define RPC_S_INVALID_ARG
Definition: rpcnterr.h:23
RPC_STATUS WINAPI MesIncrementalHandleReset(handle_t Handle, void *UserState, MIDL_ES_ALLOC AllocFn, MIDL_ES_WRITE WriteFn, MIDL_ES_READ ReadFn, MIDL_ES_CODE Operation)
Definition: ndr_es.c:104
struct _FULL_PTR_XLAT_TABLES * FullPtrXlatTables
Definition: rpcndr.h:231
RPC_STATUS WINAPI MesDecodeIncrementalHandleCreate(void *UserState, MIDL_ES_READ ReadFn, handle_t *pHandle)
Definition: ndr_es.c:78
RPC_STATUS RPC_ENTRY MesEncodeDynBufferHandleCreate(char **Buffer, ULONG *pEncodedSize, handle_t *pHandle)
Definition: ndr_es.c:219
const struct _MIDL_STUB_DESC * StubDesc
Definition: rpcndr.h:230
static void mes_proc_header_marshal(MIDL_ES_MESSAGE *pEsMsg)
Definition: ndr_es.c:341
static ULONG mes_proc_header_buffer_size(void)
Definition: ndr_es.c:336
PRPC_MESSAGE RpcMsg
Definition: rpcndr.h:202
unsigned char * Buffer
Definition: midles.h:60
Definition: match.c:390
static void init_MIDL_ES_MESSAGE(MIDL_ES_MESSAGE *pEsMsg)
Definition: ndr_es.c:38
#define RPC_X_INVALID_BUFFER
Definition: rpcnterr.h:40
uint32_t ULONG_PTR
Definition: typedefs.h:63
long RPC_STATUS
Definition: rpc.h:52
void * Buffer
Definition: rpcdcep.h:40
MIDL_ES_READ Read
Definition: midles.h:59
#define RPC_S_OUT_OF_MEMORY
Definition: rpcnterr.h:24
void WINAPIV NdrMesProcEncodeDecode(handle_t Handle, const MIDL_STUB_DESC *pStubDesc, PFORMAT_STRING pFormat,...)
Definition: ndr_es.c:400
#define FIXME(fmt,...)
Definition: debug.h:110
unsigned short proc_num
Definition: ndr_stubless.h:67
WINE_DEFAULT_DEBUG_CHANNEL(ole)
RPC_VERSION SyntaxVersion
Definition: rpcdcep.h:33
smooth NULL
Definition: ftsmooth.c:416
unsigned short proc_num
Definition: ndr_stubless.h:92
MIDL_ES_ALLOC Alloc
Definition: midles.h:57
Definition: bufpool.h:45
#define Oi_FULL_PTR_USED
Definition: ndrtypes.h:290
PFORMAT_STRING convert_old_args(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat, unsigned int stack_size, BOOL object_proc, void *buffer, unsigned int size, unsigned int *count)
Definition: ndr_stubless.c:581
static void es_data_alloc(MIDL_ES_MESSAGE *pEsMsg, ULONG size)
Definition: ndr_es.c:275
#define debugstr_guid
Definition: kernel32.h:35
RPC_STATUS WINAPI MesBufferHandleReset(handle_t Handle, ULONG HandleStyle, MIDL_ES_CODE Operation, char **Buffer, ULONG BufferSize, ULONG *EncodedSize)
Definition: ndr_es.c:128
struct _NDR_EHD_CONTEXT NDR_EHD_CONTEXT
_In_ HANDLE Handle
Definition: extypes.h:390
#define TRACE(s)
Definition: solgame.cpp:4
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned char handle_type
Definition: ndr_stubless.h:43
struct _NDR_PROC_HEADER NDR_PROC_HEADER
MIDL_ES_WRITE Write
Definition: midles.h:58
if(!(yy_init))
Definition: macro.lex.yy.c:714
const unsigned char * PFORMAT_STRING
Definition: rpcndr.h:176
#define WINAPI
Definition: msvc.h:8
#define BufferSize
Definition: classpnp.h:419
unsigned short WORD
Definition: ntddk_ex.h:93
LONG MIDLVersion
Definition: rpcndr.h:378
unsigned long DWORD
Definition: ntddk_ex.h:95
RPC_STATUS RPC_ENTRY MesDecodeBufferHandleCreate(char *Buffer, ULONG BufferSize, handle_t *pHandle)
Definition: ndr_es.c:248
#define Oi_HAS_RPCFLAGS
Definition: ndrtypes.h:293
unsigned char * BufferStart
Definition: rpcndr.h:204
ULONG BufferLength
Definition: rpcndr.h:207
unsigned char * BufferEnd
Definition: rpcndr.h:205
RPC_STATUS WINAPI MesEncodeIncrementalHandleCreate(void *UserState, MIDL_ES_ALLOC AllocFn, MIDL_ES_WRITE WriteFn, handle_t *pHandle)
Definition: ndr_es.c:50
unsigned short MinorVersion
Definition: rpcdcep.h:28
ULONG MesVersion
Definition: midles.h:53
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned char Oi_flags
Definition: ndr_stubless.h:64
RPC_SYNTAX_IDENTIFIER TransferSyntax
Definition: rpcdcep.h:118
#define RPC_S_INTERNAL_ERROR
Definition: winerror.h:1074
static RPC_STATUS validate_mes_buffer_pointer(const char *Buffer)
Definition: ndr_es.c:169
#define WINAPIV
Definition: sdbpapi.h:64
#define ERR(fmt,...)
Definition: debug.h:109
unsigned short stack_size
Definition: ndr_stubless.h:71
unsigned char ** pDynBuffer
Definition: midles.h:62
RPC_SYNTAX_IDENTIFIER InterfaceId
Definition: midles.h:64
#define va_arg(ap, T)
Definition: acmsvcex.h:89
PFULL_PTR_XLAT_TABLES WINAPI NdrFullPointerXlatInit(ULONG NumberOfPointers, XLAT_SIDE XlatSide)
MIDL_ES_CODE
Definition: midles.h:30
unsigned char IsClient
Definition: rpcndr.h:210
#define RPC_X_WRONG_ES_VERSION
Definition: winerror.h:1135
struct _NDR_PROC_HEADER_RPC NDR_PROC_HEADER_RPC
struct _RPC_SYNTAX_IDENTIFIER RPC_SYNTAX_IDENTIFIER
unsigned char * StackTop
Definition: rpcndr.h:226
MIDL_ES_CODE Operation
Definition: midles.h:51
ULONG Version
Definition: rpcndr.h:376
#define RPC_ENTRY
Definition: rpc.h:67
#define RPC_X_WRONG_STUB_VERSION
Definition: winerror.h:1136
#define __ms_va_end(list)
Definition: windef.h:443
void RPC_ENTRY NdrMesTypeEncode2(handle_t Handle, const MIDL_TYPE_PICKLING_INFO *pPicklingInfo, const MIDL_STUB_DESC *pStubDesc, PFORMAT_STRING pFormatString, const void *pObject)
Definition: ndr_es.c:522
RPC_STATUS RPC_ENTRY MesEncodeFixedBufferHandleCreate(char *Buffer, ULONG BufferSize, ULONG *pEncodedSize, handle_t *pHandle)
Definition: ndr_es.c:183
void RPC_ENTRY NdrMesTypeFree2(handle_t Handle, const MIDL_TYPE_PICKLING_INFO *pPicklingInfo, const MIDL_STUB_DESC *pStubDesc, PFORMAT_STRING pFormatString, void *pObject)
Definition: ndr_es.c:528
void(__RPC_USER * MIDL_ES_READ)(void *, char **, unsigned int *)
Definition: midles.h:46
#define __ms_va_start(list, arg)
Definition: windef.h:442
struct _NDR_EHD_PRIMITIVE NDR_EHD_PRIMITIVE
#define RPC_X_BAD_STUB_DATA
Definition: winerror.h:1090
static void mes_proc_header_unmarshal(MIDL_ES_MESSAGE *pEsMsg)
Definition: ndr_es.c:360
unsigned int ULONG
Definition: retypes.h:1
_In_ FLT_SET_CONTEXT_OPERATION Operation
Definition: fltkernel.h:1468
ULONG ByteCount
Definition: midles.h:68
#define memset(x, y, z)
Definition: compat.h:39
RPC_SYNTAX_IDENTIFIER InterfaceId
Definition: rpcdcep.h:117
static SERVICE_STATUS status
Definition: service.c:31
#define args
Definition: format.c:66
ULONG BufferSize
Definition: midles.h:61
void RPC_ENTRY NdrMesTypeDecode2(handle_t Handle, const MIDL_TYPE_PICKLING_INFO *pPicklingInfo, const MIDL_STUB_DESC *pStubDesc, PFORMAT_STRING pFormatString, void *pObject)
Definition: ndr_es.c:516
void * UserState
Definition: midles.h:52
#define HeapFree(x, y, z)
Definition: compat.h:402
static void es_data_write(MIDL_ES_MESSAGE *pEsMsg, ULONG size)
Definition: ndr_es.c:322
static void es_data_read(MIDL_ES_MESSAGE *pEsMsg, ULONG size)
Definition: ndr_es.c:296
#define RPC_S_OK
Definition: rpcnterr.h:22
MIDL_STUB_MESSAGE StubMsg
Definition: midles.h:50
Definition: ps.c:97