60c425550ada2a0db713b1512f2623e6ee5aa716
[reactos.git] / reactos / dll / win32 / rpcrt4 / rpc_epmap.c
1 /*
2 * RPC endpoint mapper
3 *
4 * Copyright 2002 Greg Turner
5 * Copyright 2001 Ove Kåven, TransGaming Technologies
6 * Copyright 2008 Robert Shearman (for CodeWeavers)
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winerror.h"
28
29 #include "rpc.h"
30
31 #include "wine/debug.h"
32 #include "wine/exception.h"
33
34 #include "rpc_binding.h"
35 #include "epm.h"
36 #include "epm_towers.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(ole);
39
40 /* The "real" RPC portmapper endpoints that I know of are:
41 *
42 * ncadg_ip_udp: 135
43 * ncacn_ip_tcp: 135
44 * ncacn_np: \\pipe\epmapper
45 * ncalrpc: epmapper
46 * ncacn_http: 593
47 *
48 * If the user's machine ran a DCE RPC daemon, it would
49 * probably be possible to connect to it, but there are many
50 * reasons not to, like:
51 * - the user probably does *not* run one, and probably
52 * shouldn't be forced to run one just for local COM
53 * - very few Unix systems use DCE RPC... if they run a RPC
54 * daemon at all, it's usually Sun RPC
55 * - DCE RPC registrations are persistent and saved on disk,
56 * while MS-RPC registrations are documented as non-persistent
57 * and stored only in RAM, and auto-destroyed when the process
58 * dies (something DCE RPC can't do)
59 *
60 * Of course, if the user *did* want to run a DCE RPC daemon anyway,
61 * there would be interoperability advantages, like the possibility
62 * of running a fully functional DCOM server using Wine...
63 */
64
65 static const struct epm_endpoints
66 {
67 const char *protseq;
68 const char *endpoint;
69 } epm_endpoints[] =
70 {
71 { "ncacn_np", "\\pipe\\epmapper" },
72 { "ncacn_ip_tcp", "135" },
73 { "ncacn_ip_udp", "135" },
74 { "ncalrpc", "epmapper" },
75 { "ncacn_http", "593" },
76 };
77
78 static BOOL start_rpcss(void)
79 {
80 PROCESS_INFORMATION pi;
81 STARTUPINFOW si;
82 static WCHAR cmd[6];
83 static const WCHAR rpcss[] = {'r','p','c','s','s',0};
84 BOOL rslt;
85
86 TRACE("\n");
87
88 ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
89 ZeroMemory(&si, sizeof(STARTUPINFOA));
90 si.cb = sizeof(STARTUPINFOA);
91
92 memcpy(cmd, rpcss, sizeof(rpcss));
93
94 rslt = CreateProcessW(
95 NULL, /* executable */
96 cmd, /* command line */
97 NULL, /* process security attributes */
98 NULL, /* primary thread security attributes */
99 FALSE, /* inherit handles */
100 0, /* creation flags */
101 NULL, /* use parent's environment */
102 NULL, /* use parent's current directory */
103 &si, /* STARTUPINFO pointer */
104 &pi /* PROCESS_INFORMATION */
105 );
106
107 if (rslt)
108 {
109 CloseHandle(pi.hProcess);
110 CloseHandle(pi.hThread);
111 Sleep(100);
112 }
113
114 return rslt;
115 }
116
117 static inline BOOL is_epm_destination_local(RPC_BINDING_HANDLE handle)
118 {
119 RpcBinding *bind = handle;
120 const char *protseq = bind->Protseq;
121 const char *network_addr = bind->NetworkAddr;
122
123 return ((!strcmp(protseq, "ncalrpc") && !network_addr) ||
124 (!strcmp(protseq, "ncacn_np") &&
125 (!network_addr || !strcmp(network_addr, "."))));
126 }
127
128 static RPC_STATUS get_epm_handle_client(RPC_BINDING_HANDLE handle, RPC_BINDING_HANDLE *epm_handle)
129 {
130 RpcBinding *bind = handle;
131 const char * pszEndpoint = NULL;
132 RPC_STATUS status;
133 RpcBinding* epm_bind;
134 unsigned int i;
135
136 if (bind->server)
137 return RPC_S_INVALID_BINDING;
138
139 for (i = 0; i < sizeof(epm_endpoints)/sizeof(epm_endpoints[0]); i++)
140 if (!strcmp(bind->Protseq, epm_endpoints[i].protseq))
141 pszEndpoint = epm_endpoints[i].endpoint;
142
143 if (!pszEndpoint)
144 {
145 FIXME("no endpoint for the endpoint-mapper found for protseq %s\n", debugstr_a(bind->Protseq));
146 return RPC_S_PROTSEQ_NOT_SUPPORTED;
147 }
148
149 status = RpcBindingCopy(handle, epm_handle);
150 if (status != RPC_S_OK) return status;
151
152 epm_bind = *epm_handle;
153 if (epm_bind->AuthInfo)
154 {
155 /* don't bother with authenticating against the EPM by default
156 * (see EnableAuthEpResolution registry value) */
157 RpcAuthInfo_Release(epm_bind->AuthInfo);
158 epm_bind->AuthInfo = NULL;
159 }
160 RPCRT4_ResolveBinding(epm_bind, pszEndpoint);
161 TRACE("RPC_S_OK\n");
162 return RPC_S_OK;
163 }
164
165 static RPC_STATUS get_epm_handle_server(RPC_BINDING_HANDLE *epm_handle)
166 {
167 unsigned char string_binding[] = "ncacn_np:.[\\\\pipe\\\\epmapper]";
168
169 return RpcBindingFromStringBindingA(string_binding, epm_handle);
170 }
171
172 static LONG WINAPI rpc_filter(EXCEPTION_POINTERS *__eptr)
173 {
174 switch (GetExceptionCode())
175 {
176 case EXCEPTION_ACCESS_VIOLATION:
177 case EXCEPTION_ILLEGAL_INSTRUCTION:
178 return EXCEPTION_CONTINUE_SEARCH;
179 default:
180 return EXCEPTION_EXECUTE_HANDLER;
181 }
182 }
183
184 /***********************************************************************
185 * RpcEpRegisterA (RPCRT4.@)
186 */
187 RPC_STATUS WINAPI RpcEpRegisterA( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR *BindingVector,
188 UUID_VECTOR *UuidVector, RPC_CSTR Annotation )
189 {
190 PRPC_SERVER_INTERFACE If = IfSpec;
191 ULONG i;
192 RPC_STATUS status = RPC_S_OK;
193 error_status_t status2;
194 ept_entry_t *entries;
195 handle_t handle;
196
197 TRACE("(%p,%p,%p,%s)\n", IfSpec, BindingVector, UuidVector, debugstr_a((char*)Annotation));
198 TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
199 for (i=0; i<BindingVector->Count; i++) {
200 RpcBinding* bind = BindingVector->BindingH[i];
201 TRACE(" protseq[%d]=%s\n", i, debugstr_a(bind->Protseq));
202 TRACE(" endpoint[%d]=%s\n", i, debugstr_a(bind->Endpoint));
203 }
204 if (UuidVector) {
205 for (i=0; i<UuidVector->Count; i++)
206 TRACE(" obj[%d]=%s\n", i, debugstr_guid(UuidVector->Uuid[i]));
207 }
208
209 if (!BindingVector->Count) return RPC_S_OK;
210
211 entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*entries) * BindingVector->Count * (UuidVector ? UuidVector->Count : 1));
212 if (!entries)
213 return RPC_S_OUT_OF_MEMORY;
214
215 status = get_epm_handle_server(&handle);
216 if (status != RPC_S_OK)
217 {
218 HeapFree(GetProcessHeap(), 0, entries);
219 return status;
220 }
221
222 for (i = 0; i < BindingVector->Count; i++)
223 {
224 unsigned j;
225 RpcBinding* bind = BindingVector->BindingH[i];
226 for (j = 0; j < (UuidVector ? UuidVector->Count : 1); j++)
227 {
228 status = TowerConstruct(&If->InterfaceId, &If->TransferSyntax,
229 bind->Protseq, bind->Endpoint,
230 bind->NetworkAddr,
231 &entries[i*(UuidVector ? UuidVector->Count : 1) + j].tower);
232 if (status != RPC_S_OK) break;
233
234 if (UuidVector)
235 memcpy(&entries[i * UuidVector->Count].object, &UuidVector->Uuid[j], sizeof(GUID));
236 else
237 memset(&entries[i].object, 0, sizeof(entries[i].object));
238 if (Annotation)
239 memcpy(entries[i].annotation, Annotation,
240 min(strlen((char *)Annotation) + 1, ept_max_annotation_size));
241 }
242 }
243
244 if (status == RPC_S_OK)
245 {
246 while (TRUE)
247 {
248 __TRY
249 {
250 ept_insert(handle, BindingVector->Count * (UuidVector ? UuidVector->Count : 1),
251 entries, TRUE, &status2);
252 }
253 __EXCEPT(rpc_filter)
254 {
255 status2 = GetExceptionCode();
256 }
257 __ENDTRY
258 if (status2 == RPC_S_SERVER_UNAVAILABLE &&
259 is_epm_destination_local(handle))
260 {
261 if (start_rpcss())
262 continue;
263 }
264 if (status2 != RPC_S_OK)
265 ERR("ept_insert failed with error %d\n", status2);
266 status = status2; /* FIXME: convert status? */
267 break;
268 }
269 }
270 RpcBindingFree(&handle);
271
272 for (i = 0; i < BindingVector->Count; i++)
273 {
274 unsigned j;
275 for (j = 0; j < (UuidVector ? UuidVector->Count : 1); j++)
276 I_RpcFree(entries[i*(UuidVector ? UuidVector->Count : 1) + j].tower);
277 }
278
279 HeapFree(GetProcessHeap(), 0, entries);
280
281 return status;
282 }
283
284 /***********************************************************************
285 * RpcEpRegisterW (RPCRT4.@)
286 */
287 RPC_STATUS WINAPI RpcEpRegisterW( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR *BindingVector,
288 UUID_VECTOR *UuidVector, RPC_WSTR Annotation )
289 {
290 LPSTR annA = RPCRT4_strdupWtoA(Annotation);
291 RPC_STATUS status;
292
293 status = RpcEpRegisterA(IfSpec, BindingVector, UuidVector, (RPC_CSTR)annA);
294
295 HeapFree(GetProcessHeap(), 0, annA);
296 return status;
297 }
298
299 /***********************************************************************
300 * RpcEpUnregister (RPCRT4.@)
301 */
302 RPC_STATUS WINAPI RpcEpUnregister( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR *BindingVector,
303 UUID_VECTOR *UuidVector )
304 {
305 PRPC_SERVER_INTERFACE If = IfSpec;
306 ULONG i;
307 RPC_STATUS status = RPC_S_OK;
308 error_status_t status2;
309 ept_entry_t *entries;
310 handle_t handle;
311
312 TRACE("(%p,%p,%p)\n", IfSpec, BindingVector, UuidVector);
313 TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
314 for (i=0; i<BindingVector->Count; i++) {
315 RpcBinding* bind = BindingVector->BindingH[i];
316 TRACE(" protseq[%d]=%s\n", i, debugstr_a(bind->Protseq));
317 TRACE(" endpoint[%d]=%s\n", i, debugstr_a(bind->Endpoint));
318 }
319 if (UuidVector) {
320 for (i=0; i<UuidVector->Count; i++)
321 TRACE(" obj[%d]=%s\n", i, debugstr_guid(UuidVector->Uuid[i]));
322 }
323
324 entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*entries) * BindingVector->Count * (UuidVector ? UuidVector->Count : 1));
325 if (!entries)
326 return RPC_S_OUT_OF_MEMORY;
327
328 status = get_epm_handle_server(&handle);
329 if (status != RPC_S_OK)
330 {
331 HeapFree(GetProcessHeap(), 0, entries);
332 return status;
333 }
334
335 for (i = 0; i < BindingVector->Count; i++)
336 {
337 unsigned j;
338 RpcBinding* bind = BindingVector->BindingH[i];
339 for (j = 0; j < (UuidVector ? UuidVector->Count : 1); j++)
340 {
341 status = TowerConstruct(&If->InterfaceId, &If->TransferSyntax,
342 bind->Protseq, bind->Endpoint,
343 bind->NetworkAddr,
344 &entries[i*(UuidVector ? UuidVector->Count : 1) + j].tower);
345 if (status != RPC_S_OK) break;
346
347 if (UuidVector)
348 memcpy(&entries[i * UuidVector->Count + j].object, &UuidVector->Uuid[j], sizeof(GUID));
349 else
350 memset(&entries[i].object, 0, sizeof(entries[i].object));
351 }
352 }
353
354 if (status == RPC_S_OK)
355 {
356 __TRY
357 {
358 ept_insert(handle, BindingVector->Count * (UuidVector ? UuidVector->Count : 1),
359 entries, TRUE, &status2);
360 }
361 __EXCEPT(rpc_filter)
362 {
363 status2 = GetExceptionCode();
364 }
365 __ENDTRY
366 if (status2 == RPC_S_SERVER_UNAVAILABLE)
367 status2 = EPT_S_NOT_REGISTERED;
368 if (status2 != RPC_S_OK)
369 ERR("ept_insert failed with error %d\n", status2);
370 status = status2; /* FIXME: convert status? */
371 }
372 RpcBindingFree(&handle);
373
374 for (i = 0; i < BindingVector->Count; i++)
375 {
376 unsigned j;
377 for (j = 0; j < (UuidVector ? UuidVector->Count : 1); j++)
378 I_RpcFree(entries[i*(UuidVector ? UuidVector->Count : 1) + j].tower);
379 }
380
381 HeapFree(GetProcessHeap(), 0, entries);
382
383 return status;
384 }
385
386 /***********************************************************************
387 * RpcEpResolveBinding (RPCRT4.@)
388 */
389 RPC_STATUS WINAPI RpcEpResolveBinding( RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec )
390 {
391 PRPC_CLIENT_INTERFACE If = IfSpec;
392 RpcBinding* bind = Binding;
393 RPC_STATUS status;
394 error_status_t status2;
395 handle_t handle;
396 ept_lookup_handle_t entry_handle = NULL;
397 twr_t *tower;
398 twr_t *towers[4] = { NULL };
399 unsigned32 num_towers, i;
400 GUID uuid = GUID_NULL;
401 char *resolved_endpoint = NULL;
402
403 TRACE("(%p,%p)\n", Binding, IfSpec);
404 TRACE(" protseq=%s\n", debugstr_a(bind->Protseq));
405 TRACE(" obj=%s\n", debugstr_guid(&bind->ObjectUuid));
406 TRACE(" networkaddr=%s\n", debugstr_a(bind->NetworkAddr));
407 TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
408
409 /* just return for fully bound handles */
410 if (bind->Endpoint && (bind->Endpoint[0] != '\0'))
411 return RPC_S_OK;
412
413 status = get_epm_handle_client(Binding, &handle);
414 if (status != RPC_S_OK) return status;
415
416 status = TowerConstruct(&If->InterfaceId, &If->TransferSyntax, bind->Protseq,
417 ((RpcBinding *)handle)->Endpoint,
418 bind->NetworkAddr, &tower);
419 if (status != RPC_S_OK)
420 {
421 WARN("couldn't get tower\n");
422 RpcBindingFree(&handle);
423 return status;
424 }
425
426 while (TRUE)
427 {
428 __TRY
429 {
430 ept_map(handle, &uuid, tower, &entry_handle, sizeof(towers)/sizeof(towers[0]), &num_towers, towers, &status2);
431 /* FIXME: translate status2? */
432 }
433 __EXCEPT(rpc_filter)
434 {
435 status2 = GetExceptionCode();
436 }
437 __ENDTRY
438 if (status2 == RPC_S_SERVER_UNAVAILABLE &&
439 is_epm_destination_local(handle))
440 {
441 if (start_rpcss())
442 continue;
443 }
444 break;
445 };
446
447 RpcBindingFree(&handle);
448 I_RpcFree(tower);
449
450 if (status2 != RPC_S_OK)
451 {
452 ERR("ept_map failed for ifid %s, protseq %s, networkaddr %s\n", debugstr_guid(&If->TransferSyntax.SyntaxGUID), bind->Protseq, bind->NetworkAddr);
453 return status2;
454 }
455
456 for (i = 0; i < num_towers; i++)
457 {
458 /* only parse the tower if we haven't already found a suitable
459 * endpoint, otherwise just free the tower */
460 if (!resolved_endpoint)
461 {
462 status = TowerExplode(towers[i], NULL, NULL, NULL, &resolved_endpoint, NULL);
463 TRACE("status = %d\n", status);
464 }
465 I_RpcFree(towers[i]);
466 }
467
468 if (resolved_endpoint)
469 {
470 RPCRT4_ResolveBinding(Binding, resolved_endpoint);
471 I_RpcFree(resolved_endpoint);
472 return RPC_S_OK;
473 }
474
475 WARN("couldn't find an endpoint\n");
476 return EPT_S_NOT_REGISTERED;
477 }
478
479 /*****************************************************************************
480 * TowerExplode (RPCRT4.@)
481 */
482 RPC_STATUS WINAPI TowerExplode(
483 const twr_t *tower, PRPC_SYNTAX_IDENTIFIER object, PRPC_SYNTAX_IDENTIFIER syntax,
484 char **protseq, char **endpoint, char **address)
485 {
486 size_t tower_size;
487 RPC_STATUS status;
488 const unsigned char *p;
489 u_int16 floor_count;
490 const twr_uuid_floor_t *object_floor;
491 const twr_uuid_floor_t *syntax_floor;
492
493 TRACE("(%p, %p, %p, %p, %p, %p)\n", tower, object, syntax, protseq,
494 endpoint, address);
495
496 if (protseq)
497 *protseq = NULL;
498 if (endpoint)
499 *endpoint = NULL;
500 if (address)
501 *address = NULL;
502
503 tower_size = tower->tower_length;
504
505 if (tower_size < sizeof(u_int16))
506 return EPT_S_NOT_REGISTERED;
507
508 p = &tower->tower_octet_string[0];
509
510 floor_count = *(const u_int16 *)p;
511 p += sizeof(u_int16);
512 tower_size -= sizeof(u_int16);
513 TRACE("floor_count: %d\n", floor_count);
514 /* FIXME: should we do something with the floor count? at the moment we don't */
515
516 if (tower_size < sizeof(*object_floor) + sizeof(*syntax_floor))
517 return EPT_S_NOT_REGISTERED;
518
519 object_floor = (const twr_uuid_floor_t *)p;
520 p += sizeof(*object_floor);
521 tower_size -= sizeof(*object_floor);
522 syntax_floor = (const twr_uuid_floor_t *)p;
523 p += sizeof(*syntax_floor);
524 tower_size -= sizeof(*syntax_floor);
525
526 if ((object_floor->count_lhs != sizeof(object_floor->protid) +
527 sizeof(object_floor->uuid) + sizeof(object_floor->major_version)) ||
528 (object_floor->protid != EPM_PROTOCOL_UUID) ||
529 (object_floor->count_rhs != sizeof(object_floor->minor_version)))
530 return EPT_S_NOT_REGISTERED;
531
532 if ((syntax_floor->count_lhs != sizeof(syntax_floor->protid) +
533 sizeof(syntax_floor->uuid) + sizeof(syntax_floor->major_version)) ||
534 (syntax_floor->protid != EPM_PROTOCOL_UUID) ||
535 (syntax_floor->count_rhs != sizeof(syntax_floor->minor_version)))
536 return EPT_S_NOT_REGISTERED;
537
538 status = RpcTransport_ParseTopOfTower(p, tower_size, protseq, address, endpoint);
539 if ((status == RPC_S_OK) && syntax && object)
540 {
541 syntax->SyntaxGUID = syntax_floor->uuid;
542 syntax->SyntaxVersion.MajorVersion = syntax_floor->major_version;
543 syntax->SyntaxVersion.MinorVersion = syntax_floor->minor_version;
544 object->SyntaxGUID = object_floor->uuid;
545 object->SyntaxVersion.MajorVersion = object_floor->major_version;
546 object->SyntaxVersion.MinorVersion = object_floor->minor_version;
547 }
548 return status;
549 }
550
551 /***********************************************************************
552 * TowerConstruct (RPCRT4.@)
553 */
554 RPC_STATUS WINAPI TowerConstruct(
555 const RPC_SYNTAX_IDENTIFIER *object, const RPC_SYNTAX_IDENTIFIER *syntax,
556 const char *protseq, const char *endpoint, const char *address,
557 twr_t **tower)
558 {
559 size_t tower_size;
560 RPC_STATUS status;
561 unsigned char *p;
562 twr_uuid_floor_t *object_floor;
563 twr_uuid_floor_t *syntax_floor;
564
565 TRACE("(%p, %p, %s, %s, %s, %p)\n", object, syntax, debugstr_a(protseq),
566 debugstr_a(endpoint), debugstr_a(address), tower);
567
568 *tower = NULL;
569
570 status = RpcTransport_GetTopOfTower(NULL, &tower_size, protseq, address, endpoint);
571
572 if (status != RPC_S_OK)
573 return status;
574
575 tower_size += sizeof(u_int16) + sizeof(*object_floor) + sizeof(*syntax_floor);
576 *tower = I_RpcAllocate(FIELD_OFFSET(twr_t, tower_octet_string[tower_size]));
577 if (!*tower)
578 return RPC_S_OUT_OF_RESOURCES;
579
580 (*tower)->tower_length = tower_size;
581 p = &(*tower)->tower_octet_string[0];
582 *(u_int16 *)p = 5; /* number of floors */
583 p += sizeof(u_int16);
584 object_floor = (twr_uuid_floor_t *)p;
585 p += sizeof(*object_floor);
586 syntax_floor = (twr_uuid_floor_t *)p;
587 p += sizeof(*syntax_floor);
588
589 object_floor->count_lhs = sizeof(object_floor->protid) + sizeof(object_floor->uuid) +
590 sizeof(object_floor->major_version);
591 object_floor->protid = EPM_PROTOCOL_UUID;
592 object_floor->count_rhs = sizeof(object_floor->minor_version);
593 object_floor->uuid = object->SyntaxGUID;
594 object_floor->major_version = object->SyntaxVersion.MajorVersion;
595 object_floor->minor_version = object->SyntaxVersion.MinorVersion;
596
597 syntax_floor->count_lhs = sizeof(syntax_floor->protid) + sizeof(syntax_floor->uuid) +
598 sizeof(syntax_floor->major_version);
599 syntax_floor->protid = EPM_PROTOCOL_UUID;
600 syntax_floor->count_rhs = sizeof(syntax_floor->minor_version);
601 syntax_floor->uuid = syntax->SyntaxGUID;
602 syntax_floor->major_version = syntax->SyntaxVersion.MajorVersion;
603 syntax_floor->minor_version = syntax->SyntaxVersion.MinorVersion;
604
605 status = RpcTransport_GetTopOfTower(p, &tower_size, protseq, address, endpoint);
606 if (status != RPC_S_OK)
607 {
608 I_RpcFree(*tower);
609 *tower = NULL;
610 return status;
611 }
612 return RPC_S_OK;
613 }
614
615 void __RPC_FAR * __RPC_USER MIDL_user_allocate(SIZE_T len)
616 {
617 return HeapAlloc(GetProcessHeap(), 0, len);
618 }
619
620 void __RPC_USER MIDL_user_free(void __RPC_FAR * ptr)
621 {
622 HeapFree(GetProcessHeap(), 0, ptr);
623 }