1 /*
2 * RPCRT4
3 *
4 * Copyright 2000 Huw D M Davies 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 * WINE RPC TODO's (and a few TODONT's)
21 *
22 * - Statistics: we are supposed to be keeping various counters. we aren't.
23 *
24 * - Async RPC: Unimplemented.
25 *
26 * - The NT "ports" API, aka LPC. Greg claims this is on his radar. Might (or
27 * might not) enable users to get some kind of meaningful result out of
28 * NT-based native rpcrt4's. Commonly-used transport for self-to-self RPC's.
29 */
30
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35
36 #include "ntstatus.h"
37 #define WIN32_NO_STATUS
38 #include "windef.h"
39 #include "winerror.h"
40 #include "winbase.h"
41 #include "winuser.h"
42 #include "winnt.h"
43 #include "wine/winternl.h"
44 #include "ntsecapi.h"
45 #include "iptypes.h"
46 #include "iphlpapi.h"
47 #include "rpc.h"
48
49 #include "ole2.h"
50 #include "rpcndr.h"
51 #include "rpcproxy.h"
52
53 #include "rpc_binding.h"
54 #include "rpc_server.h"
55
56 #include "wine/debug.h"
57
58 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
59
60 static UUID uuid_nil;
61
62 static CRITICAL_SECTION uuid_cs;
63 static CRITICAL_SECTION_DEBUG critsect_debug =
64 {
65 0, 0, &uuid_cs,
66 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
67 0, 0, { (DWORD_PTR)(__FILE__ ": uuid_cs") }
68 };
69 static CRITICAL_SECTION uuid_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
70
71 static CRITICAL_SECTION threaddata_cs;
72 static CRITICAL_SECTION_DEBUG threaddata_cs_debug =
73 {
74 0, 0, &threaddata_cs,
75 { &threaddata_cs_debug.ProcessLocksList, &threaddata_cs_debug.ProcessLocksList },
76 0, 0, { (DWORD_PTR)(__FILE__ ": threaddata_cs") }
77 };
78 static CRITICAL_SECTION threaddata_cs = { &threaddata_cs_debug, -1, 0, 0, 0, 0 };
79
80 static struct list threaddata_list = LIST_INIT(threaddata_list);
81
82 struct context_handle_list
83 {
84 struct context_handle_list *next;
85 NDR_SCONTEXT context_handle;
86 };
87
88 struct threaddata
89 {
90 struct list entry;
91 CRITICAL_SECTION cs;
92 DWORD thread_id;
93 RpcConnection *connection;
94 RpcBinding *server_binding;
95 struct context_handle_list *context_handle_list;
96 };
97
98 /***********************************************************************
99 * DllMain
100 *
101 * PARAMS
102 * hinstDLL [I] handle to the DLL's instance
103 * fdwReason [I]
104 * lpvReserved [I] reserved, must be NULL
105 *
106 * RETURNS
107 * Success: TRUE
108 * Failure: FALSE
109 */
110
DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved)111 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
112 {
113 struct threaddata *tdata;
114
115 switch (fdwReason) {
116 case DLL_PROCESS_ATTACH:
117 break;
118
119 case DLL_THREAD_DETACH:
120 tdata = NtCurrentTeb()->ReservedForNtRpc;
121 if (tdata)
122 {
123 EnterCriticalSection(&threaddata_cs);
124 list_remove(&tdata->entry);
125 LeaveCriticalSection(&threaddata_cs);
126
127 tdata->cs.DebugInfo->Spare[0] = 0;
128 DeleteCriticalSection(&tdata->cs);
129 if (tdata->connection)
130 ERR("tdata->connection should be NULL but is still set to %p\n", tdata->connection);
131 if (tdata->server_binding)
132 ERR("tdata->server_binding should be NULL but is still set to %p\n", tdata->server_binding);
133 HeapFree(GetProcessHeap(), 0, tdata);
134 }
135 break;
136
137 case DLL_PROCESS_DETACH:
138 if (lpvReserved) break; /* do nothing if process is shutting down */
139 RPCRT4_destroy_all_protseqs();
140 RPCRT4_ServerFreeAllRegisteredAuthInfo();
141 DeleteCriticalSection(&uuid_cs);
142 DeleteCriticalSection(&threaddata_cs);
143 break;
144 }
145
146 return TRUE;
147 }
148
149 /*************************************************************************
150 * RpcStringFreeA [RPCRT4.@]
151 *
152 * Frees a character string allocated by the RPC run-time library.
153 *
154 * RETURNS
155 *
156 * S_OK if successful.
157 */
RpcStringFreeA(RPC_CSTR * String)158 RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR* String)
159 {
160 HeapFree( GetProcessHeap(), 0, *String);
161 if (String) *String = NULL;
162
163 return RPC_S_OK;
164 }
165
166 /*************************************************************************
167 * RpcStringFreeW [RPCRT4.@]
168 *
169 * Frees a character string allocated by the RPC run-time library.
170 *
171 * RETURNS
172 *
173 * S_OK if successful.
174 */
RpcStringFreeW(RPC_WSTR * String)175 RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR* String)
176 {
177 HeapFree( GetProcessHeap(), 0, *String);
178 if (String) *String = NULL;
179
180 return RPC_S_OK;
181 }
182
183 /*************************************************************************
184 * RpcRaiseException [RPCRT4.@]
185 *
186 * Raises an exception.
187 */
RpcRaiseException(RPC_STATUS exception)188 void DECLSPEC_NORETURN WINAPI RpcRaiseException(RPC_STATUS exception)
189 {
190 /* shouldn't return */
191 RaiseException(exception, 0, 0, NULL);
192 ERR("handler continued execution\n");
193 ExitProcess(1);
194 }
195
196 /*************************************************************************
197 * UuidCompare [RPCRT4.@]
198 *
199 * PARAMS
200 * UUID *Uuid1 [I] Uuid to compare
201 * UUID *Uuid2 [I] Uuid to compare
202 * RPC_STATUS *Status [O] returns RPC_S_OK
203 *
204 * RETURNS
205 * -1 if Uuid1 is less than Uuid2
206 * 0 if Uuid1 and Uuid2 are equal
207 * 1 if Uuid1 is greater than Uuid2
208 */
UuidCompare(UUID * Uuid1,UUID * Uuid2,RPC_STATUS * Status)209 int WINAPI UuidCompare(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
210 {
211 int i;
212
213 TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
214
215 *Status = RPC_S_OK;
216
217 if (!Uuid1) Uuid1 = &uuid_nil;
218 if (!Uuid2) Uuid2 = &uuid_nil;
219
220 if (Uuid1 == Uuid2) return 0;
221
222 if (Uuid1->Data1 != Uuid2->Data1)
223 return Uuid1->Data1 < Uuid2->Data1 ? -1 : 1;
224
225 if (Uuid1->Data2 != Uuid2->Data2)
226 return Uuid1->Data2 < Uuid2->Data2 ? -1 : 1;
227
228 if (Uuid1->Data3 != Uuid2->Data3)
229 return Uuid1->Data3 < Uuid2->Data3 ? -1 : 1;
230
231 for (i = 0; i < 8; i++) {
232 if (Uuid1->Data4[i] < Uuid2->Data4[i])
233 return -1;
234 if (Uuid1->Data4[i] > Uuid2->Data4[i])
235 return 1;
236 }
237
238 return 0;
239 }
240
241 /*************************************************************************
242 * UuidEqual [RPCRT4.@]
243 *
244 * PARAMS
245 * UUID *Uuid1 [I] Uuid to compare
246 * UUID *Uuid2 [I] Uuid to compare
247 * RPC_STATUS *Status [O] returns RPC_S_OK
248 *
249 * RETURNS
250 * TRUE/FALSE
251 */
UuidEqual(UUID * Uuid1,UUID * Uuid2,RPC_STATUS * Status)252 int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
253 {
254 TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
255 return !UuidCompare(Uuid1, Uuid2, Status);
256 }
257
258 /*************************************************************************
259 * UuidIsNil [RPCRT4.@]
260 *
261 * PARAMS
262 * UUID *Uuid [I] Uuid to compare
263 * RPC_STATUS *Status [O] returns RPC_S_OK
264 *
265 * RETURNS
266 * TRUE/FALSE
267 */
UuidIsNil(UUID * Uuid,RPC_STATUS * Status)268 int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
269 {
270 TRACE("(%s)\n", debugstr_guid(Uuid));
271 if (!Uuid) return TRUE;
272 return !UuidCompare(Uuid, &uuid_nil, Status);
273 }
274
275 /*************************************************************************
276 * UuidCreateNil [RPCRT4.@]
277 *
278 * PARAMS
279 * UUID *Uuid [O] returns a nil UUID
280 *
281 * RETURNS
282 * RPC_S_OK
283 */
UuidCreateNil(UUID * Uuid)284 RPC_STATUS WINAPI UuidCreateNil(UUID *Uuid)
285 {
286 *Uuid = uuid_nil;
287 return RPC_S_OK;
288 }
289
290 /*************************************************************************
291 * UuidCreate [RPCRT4.@]
292 *
293 * Creates a 128bit UUID.
294 *
295 * RETURNS
296 *
297 * RPC_S_OK if successful.
298 * RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
299 *
300 * NOTES
301 *
302 * Follows RFC 4122, section 4.4 (Algorithms for Creating a UUID from
303 * Truly Random or Pseudo-Random Numbers)
304 */
UuidCreate(UUID * Uuid)305 RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
306 {
307 RtlGenRandom(Uuid, sizeof(*Uuid));
308 /* Clear the version bits and set the version (4) */
309 Uuid->Data3 &= 0x0fff;
310 Uuid->Data3 |= (4 << 12);
311 /* Set the topmost bits of Data4 (clock_seq_hi_and_reserved) as
312 * specified in RFC 4122, section 4.4.
313 */
314 Uuid->Data4[0] &= 0x3f;
315 Uuid->Data4[0] |= 0x80;
316
317 TRACE("%s\n", debugstr_guid(Uuid));
318
319 return RPC_S_OK;
320 }
321
322 /* Number of 100ns ticks per clock tick. To be safe, assume that the clock
323 resolution is at least 1000 * 100 * (1/1000000) = 1/10 of a second */
324 #define TICKS_PER_CLOCK_TICK 1000
325 #define SECSPERDAY 86400
326 #define TICKSPERSEC 10000000
327 /* UUID system time starts at October 15, 1582 */
328 #define SECS_15_OCT_1582_TO_1601 ((17 + 30 + 31 + 365 * 18 + 5) * SECSPERDAY)
329 #define TICKS_15_OCT_1582_TO_1601 ((ULONGLONG)SECS_15_OCT_1582_TO_1601 * TICKSPERSEC)
330
RPC_UuidGetSystemTime(ULONGLONG * time)331 static void RPC_UuidGetSystemTime(ULONGLONG *time)
332 {
333 FILETIME ft;
334
335 GetSystemTimeAsFileTime(&ft);
336
337 *time = ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
338 *time += TICKS_15_OCT_1582_TO_1601;
339 }
340
341 /* Assume that a hardware address is at least 6 bytes long */
342 #define ADDRESS_BYTES_NEEDED 6
343
RPC_UuidGetNodeAddress(BYTE * address)344 static RPC_STATUS RPC_UuidGetNodeAddress(BYTE *address)
345 {
346 int i;
347 DWORD status = RPC_S_OK;
348
349 ULONG buflen = sizeof(IP_ADAPTER_INFO);
350 PIP_ADAPTER_INFO adapter = HeapAlloc(GetProcessHeap(), 0, buflen);
351
352 if (GetAdaptersInfo(adapter, &buflen) == ERROR_BUFFER_OVERFLOW) {
353 HeapFree(GetProcessHeap(), 0, adapter);
354 adapter = HeapAlloc(GetProcessHeap(), 0, buflen);
355 }
356
357 if (GetAdaptersInfo(adapter, &buflen) == NO_ERROR) {
358 for (i = 0; i < ADDRESS_BYTES_NEEDED; i++) {
359 address[i] = adapter->Address[i];
360 }
361 }
362 /* We can't get a hardware address, just use random numbers.
363 Set the multicast bit to prevent conflicts with real cards. */
364 else {
365 RtlGenRandom(address, ADDRESS_BYTES_NEEDED);
366 address[0] |= 0x01;
367 status = RPC_S_UUID_LOCAL_ONLY;
368 }
369
370 HeapFree(GetProcessHeap(), 0, adapter);
371 return status;
372 }
373
374 /*************************************************************************
375 * UuidCreateSequential [RPCRT4.@]
376 *
377 * Creates a 128bit UUID.
378 *
379 * RETURNS
380 *
381 * RPC_S_OK if successful.
382 * RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
383 *
384 * FIXME: No compensation for changes across reloading
385 * this dll or across reboots (e.g. clock going
386 * backwards and swapped network cards). The RFC
387 * suggests using NVRAM for storing persistent
388 * values.
389 */
UuidCreateSequential(UUID * Uuid)390 RPC_STATUS WINAPI UuidCreateSequential(UUID *Uuid)
391 {
392 static BOOL initialised;
393 static int count;
394
395 ULONGLONG time;
396 static ULONGLONG timelast;
397 static WORD sequence;
398
399 static DWORD status;
400 static BYTE address[MAX_ADAPTER_ADDRESS_LENGTH];
401
402 EnterCriticalSection(&uuid_cs);
403
404 if (!initialised) {
405 RPC_UuidGetSystemTime(&timelast);
406 count = TICKS_PER_CLOCK_TICK;
407
408 sequence = ((rand() & 0xff) << 8) + (rand() & 0xff);
409 sequence &= 0x1fff;
410
411 status = RPC_UuidGetNodeAddress(address);
412 initialised = TRUE;
413 }
414
415 /* Generate time element of the UUID. Account for going faster
416 than our clock as well as the clock going backwards. */
417 while (1) {
418 RPC_UuidGetSystemTime(&time);
419 if (time > timelast) {
420 count = 0;
421 break;
422 }
423 if (time < timelast) {
424 sequence = (sequence + 1) & 0x1fff;
425 count = 0;
426 break;
427 }
428 if (count < TICKS_PER_CLOCK_TICK) {
429 count++;
430 break;
431 }
432 }
433
434 timelast = time;
435 time += count;
436
437 /* Pack the information into the UUID structure. */
438
439 Uuid->Data1 = (ULONG)(time & 0xffffffff);
440 Uuid->Data2 = (unsigned short)((time >> 32) & 0xffff);
441 Uuid->Data3 = (unsigned short)((time >> 48) & 0x0fff);
442
443 /* This is a version 1 UUID */
444 Uuid->Data3 |= (1 << 12);
445
446 Uuid->Data4[0] = sequence & 0xff;
447 Uuid->Data4[1] = (sequence & 0x3f00) >> 8;
448 Uuid->Data4[1] |= 0x80;
449 memcpy(&Uuid->Data4[2], address, ADDRESS_BYTES_NEEDED);
450
451 LeaveCriticalSection(&uuid_cs);
452
453 TRACE("%s\n", debugstr_guid(Uuid));
454
455 return status;
456 }
457
458 /*************************************************************************
459 * I_UuidCreate [RPCRT4.@]
460 *
461 * See UuidCreateSequential()
462 */
I_UuidCreate(UUID * Uuid)463 RPC_STATUS WINAPI I_UuidCreate(UUID *Uuid)
464 {
465 return UuidCreateSequential(Uuid);
466 }
467
468 /*************************************************************************
469 * UuidHash [RPCRT4.@]
470 *
471 * Generates a hash value for a given UUID
472 *
473 * Code based on FreeDCE implementation
474 *
475 */
UuidHash(UUID * uuid,RPC_STATUS * Status)476 unsigned short WINAPI UuidHash(UUID *uuid, RPC_STATUS *Status)
477 {
478 BYTE *data = (BYTE*)uuid;
479 short c0 = 0, c1 = 0, x, y;
480 unsigned int i;
481
482 if (!uuid) data = (BYTE*)(uuid = &uuid_nil);
483
484 TRACE("(%s)\n", debugstr_guid(uuid));
485
486 for (i=0; i<sizeof(UUID); i++) {
487 c0 += data[i];
488 c1 += c0;
489 }
490
491 x = -c1 % 255;
492 if (x < 0) x += 255;
493
494 y = (c1 - c0) % 255;
495 if (y < 0) y += 255;
496
497 *Status = RPC_S_OK;
498 return y*256 + x;
499 }
500
501 /*************************************************************************
502 * UuidToStringA [RPCRT4.@]
503 *
504 * Converts a UUID to a string.
505 *
506 * UUID format is 8 hex digits, followed by a hyphen then three groups of
507 * 4 hex digits each followed by a hyphen and then 12 hex digits
508 *
509 * RETURNS
510 *
511 * S_OK if successful.
512 * S_OUT_OF_MEMORY if unsuccessful.
513 */
UuidToStringA(UUID * Uuid,RPC_CSTR * StringUuid)514 RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, RPC_CSTR* StringUuid)
515 {
516 *StringUuid = HeapAlloc( GetProcessHeap(), 0, sizeof(char) * 37);
517
518 if(!(*StringUuid))
519 return RPC_S_OUT_OF_MEMORY;
520
521 if (!Uuid) Uuid = &uuid_nil;
522
523 sprintf( (char*)*StringUuid, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
524 Uuid->Data1, Uuid->Data2, Uuid->Data3,
525 Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
526 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
527 Uuid->Data4[6], Uuid->Data4[7] );
528
529 return RPC_S_OK;
530 }
531
532 /*************************************************************************
533 * UuidToStringW [RPCRT4.@]
534 *
535 * Converts a UUID to a string.
536 *
537 * S_OK if successful.
538 * S_OUT_OF_MEMORY if unsuccessful.
539 */
UuidToStringW(UUID * Uuid,RPC_WSTR * StringUuid)540 RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, RPC_WSTR* StringUuid)
541 {
542 char buf[37];
543
544 if (!Uuid) Uuid = &uuid_nil;
545
546 sprintf(buf, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
547 Uuid->Data1, Uuid->Data2, Uuid->Data3,
548 Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
549 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
550 Uuid->Data4[6], Uuid->Data4[7] );
551
552 *StringUuid = RPCRT4_strdupAtoW(buf);
553
554 if(!(*StringUuid))
555 return RPC_S_OUT_OF_MEMORY;
556
557 return RPC_S_OK;
558 }
559
560 static const BYTE hex2bin[] =
561 {
562 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */
563 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */
564 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */
565 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */
566 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */
567 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */
568 0,10,11,12,13,14,15 /* 0x60 */
569 };
570
571 /***********************************************************************
572 * UuidFromStringA (RPCRT4.@)
573 */
UuidFromStringA(RPC_CSTR s,UUID * uuid)574 RPC_STATUS WINAPI UuidFromStringA(RPC_CSTR s, UUID *uuid)
575 {
576 int i;
577
578 if (!s) return UuidCreateNil( uuid );
579
580 if (strlen((char*)s) != 36) return RPC_S_INVALID_STRING_UUID;
581
582 if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
583 return RPC_S_INVALID_STRING_UUID;
584
585 for (i=0; i<36; i++)
586 {
587 if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
588 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
589 }
590
591 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
592
593 uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
594 hex2bin[s[4]] << 12 | hex2bin[s[5]] << 8 | hex2bin[s[6]] << 4 | hex2bin[s[7]]);
595 uuid->Data2 = hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
596 uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
597
598 /* these are just sequential bytes */
599 uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
600 uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
601 uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
602 uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
603 uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
604 uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
605 uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
606 uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
607 return RPC_S_OK;
608 }
609
610
611 /***********************************************************************
612 * UuidFromStringW (RPCRT4.@)
613 */
UuidFromStringW(RPC_WSTR s,UUID * uuid)614 RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
615 {
616 int i;
617
618 if (!s) return UuidCreateNil( uuid );
619
620 if (lstrlenW(s) != 36) return RPC_S_INVALID_STRING_UUID;
621
622 if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
623 return RPC_S_INVALID_STRING_UUID;
624
625 for (i=0; i<36; i++)
626 {
627 if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
628 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
629 }
630
631 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
632
633 uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
634 hex2bin[s[4]] << 12 | hex2bin[s[5]] << 8 | hex2bin[s[6]] << 4 | hex2bin[s[7]]);
635 uuid->Data2 = hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
636 uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
637
638 /* these are just sequential bytes */
639 uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
640 uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
641 uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
642 uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
643 uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
644 uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
645 uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
646 uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
647 return RPC_S_OK;
648 }
649
650 /***********************************************************************
651 * DllRegisterServer (RPCRT4.@)
652 */
653
DllRegisterServer(void)654 HRESULT WINAPI DllRegisterServer( void )
655 {
656 FIXME( "(): stub\n" );
657 return S_OK;
658 }
659
660 #define MAX_RPC_ERROR_TEXT 256
661
662 /******************************************************************************
663 * DceErrorInqTextW (rpcrt4.@)
664 *
665 * Notes
666 * 1. On passing a NULL pointer the code does bomb out.
667 * 2. The size of the required buffer is not defined in the documentation.
668 * It appears to be 256.
669 * 3. The function is defined to return RPC_S_INVALID_ARG but I don't know
670 * of any value for which it does.
671 * 4. The MSDN documentation currently declares that the second argument is
672 * unsigned char *, even for the W version. I don't believe it.
673 */
DceErrorInqTextW(RPC_STATUS e,RPC_WSTR buffer)674 RPC_STATUS RPC_ENTRY DceErrorInqTextW (RPC_STATUS e, RPC_WSTR buffer)
675 {
676 DWORD count;
677 count = FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
678 FORMAT_MESSAGE_IGNORE_INSERTS,
679 NULL, e, 0, buffer, MAX_RPC_ERROR_TEXT, NULL);
680 if (!count)
681 {
682 count = FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
683 FORMAT_MESSAGE_IGNORE_INSERTS,
684 NULL, RPC_S_NOT_RPC_ERROR, 0, buffer, MAX_RPC_ERROR_TEXT, NULL);
685 if (!count)
686 {
687 ERR ("Failed to translate error\n");
688 return RPC_S_INVALID_ARG;
689 }
690 }
691 return RPC_S_OK;
692 }
693
694 /******************************************************************************
695 * DceErrorInqTextA (rpcrt4.@)
696 */
DceErrorInqTextA(RPC_STATUS e,RPC_CSTR buffer)697 RPC_STATUS RPC_ENTRY DceErrorInqTextA (RPC_STATUS e, RPC_CSTR buffer)
698 {
699 RPC_STATUS status;
700 WCHAR bufferW [MAX_RPC_ERROR_TEXT];
701 if ((status = DceErrorInqTextW (e, bufferW)) == RPC_S_OK)
702 {
703 if (!WideCharToMultiByte(CP_ACP, 0, bufferW, -1, (LPSTR)buffer, MAX_RPC_ERROR_TEXT,
704 NULL, NULL))
705 {
706 ERR ("Failed to translate error\n");
707 status = RPC_S_INVALID_ARG;
708 }
709 }
710 return status;
711 }
712
713 /******************************************************************************
714 * I_RpcAllocate (rpcrt4.@)
715 */
I_RpcAllocate(unsigned int Size)716 void * WINAPI I_RpcAllocate(unsigned int Size)
717 {
718 return HeapAlloc(GetProcessHeap(), 0, Size);
719 }
720
721 /******************************************************************************
722 * I_RpcFree (rpcrt4.@)
723 */
I_RpcFree(void * Object)724 void WINAPI I_RpcFree(void *Object)
725 {
726 HeapFree(GetProcessHeap(), 0, Object);
727 }
728
729 /******************************************************************************
730 * I_RpcMapWin32Status (rpcrt4.@)
731 *
732 * Maps Win32 RPC error codes to NT statuses.
733 *
734 * PARAMS
735 * status [I] Win32 RPC error code.
736 *
737 * RETURNS
738 * Appropriate translation into an NT status code.
739 */
I_RpcMapWin32Status(RPC_STATUS status)740 LONG WINAPI I_RpcMapWin32Status(RPC_STATUS status)
741 {
742 TRACE("(%d)\n", status);
743 switch (status)
744 {
745 case ERROR_ACCESS_DENIED: return STATUS_ACCESS_DENIED;
746 case ERROR_INVALID_HANDLE: return RPC_NT_SS_CONTEXT_MISMATCH;
747 case ERROR_OUTOFMEMORY: return STATUS_NO_MEMORY;
748 case ERROR_INVALID_PARAMETER: return STATUS_INVALID_PARAMETER;
749 case ERROR_INSUFFICIENT_BUFFER: return STATUS_BUFFER_TOO_SMALL;
750 case ERROR_MAX_THRDS_REACHED: return STATUS_NO_MEMORY;
751 case ERROR_NOACCESS: return STATUS_ACCESS_VIOLATION;
752 case ERROR_NOT_ENOUGH_SERVER_MEMORY: return STATUS_INSUFF_SERVER_RESOURCES;
753 case ERROR_WRONG_PASSWORD: return STATUS_WRONG_PASSWORD;
754 case ERROR_INVALID_LOGON_HOURS: return STATUS_INVALID_LOGON_HOURS;
755 case ERROR_PASSWORD_EXPIRED: return STATUS_PASSWORD_EXPIRED;
756 case ERROR_ACCOUNT_DISABLED: return STATUS_ACCOUNT_DISABLED;
757 case ERROR_INVALID_SECURITY_DESCR: return STATUS_INVALID_SECURITY_DESCR;
758 case RPC_S_INVALID_STRING_BINDING: return RPC_NT_INVALID_STRING_BINDING;
759 case RPC_S_WRONG_KIND_OF_BINDING: return RPC_NT_WRONG_KIND_OF_BINDING;
760 case RPC_S_INVALID_BINDING: return RPC_NT_INVALID_BINDING;
761 case RPC_S_PROTSEQ_NOT_SUPPORTED: return RPC_NT_PROTSEQ_NOT_SUPPORTED;
762 case RPC_S_INVALID_RPC_PROTSEQ: return RPC_NT_INVALID_RPC_PROTSEQ;
763 case RPC_S_INVALID_STRING_UUID: return RPC_NT_INVALID_STRING_UUID;
764 case RPC_S_INVALID_ENDPOINT_FORMAT: return RPC_NT_INVALID_ENDPOINT_FORMAT;
765 case RPC_S_INVALID_NET_ADDR: return RPC_NT_INVALID_NET_ADDR;
766 case RPC_S_NO_ENDPOINT_FOUND: return RPC_NT_NO_ENDPOINT_FOUND;
767 case RPC_S_INVALID_TIMEOUT: return RPC_NT_INVALID_TIMEOUT;
768 case RPC_S_OBJECT_NOT_FOUND: return RPC_NT_OBJECT_NOT_FOUND;
769 case RPC_S_ALREADY_REGISTERED: return RPC_NT_ALREADY_REGISTERED;
770 case RPC_S_TYPE_ALREADY_REGISTERED: return RPC_NT_TYPE_ALREADY_REGISTERED;
771 case RPC_S_ALREADY_LISTENING: return RPC_NT_ALREADY_LISTENING;
772 case RPC_S_NO_PROTSEQS_REGISTERED: return RPC_NT_NO_PROTSEQS_REGISTERED;
773 case RPC_S_NOT_LISTENING: return RPC_NT_NOT_LISTENING;
774 case RPC_S_UNKNOWN_MGR_TYPE: return RPC_NT_UNKNOWN_MGR_TYPE;
775 case RPC_S_UNKNOWN_IF: return RPC_NT_UNKNOWN_IF;
776 case RPC_S_NO_BINDINGS: return RPC_NT_NO_BINDINGS;
777 case RPC_S_NO_PROTSEQS: return RPC_NT_NO_PROTSEQS;
778 case RPC_S_CANT_CREATE_ENDPOINT: return RPC_NT_CANT_CREATE_ENDPOINT;
779 case RPC_S_OUT_OF_RESOURCES: return RPC_NT_OUT_OF_RESOURCES;
780 case RPC_S_SERVER_UNAVAILABLE: return RPC_NT_SERVER_UNAVAILABLE;
781 case RPC_S_SERVER_TOO_BUSY: return RPC_NT_SERVER_TOO_BUSY;
782 case RPC_S_INVALID_NETWORK_OPTIONS: return RPC_NT_INVALID_NETWORK_OPTIONS;
783 case RPC_S_NO_CALL_ACTIVE: return RPC_NT_NO_CALL_ACTIVE;
784 case RPC_S_CALL_FAILED: return RPC_NT_CALL_FAILED;
785 case RPC_S_CALL_FAILED_DNE: return RPC_NT_CALL_FAILED_DNE;
786 case RPC_S_PROTOCOL_ERROR: return RPC_NT_PROTOCOL_ERROR;
787 case RPC_S_UNSUPPORTED_TRANS_SYN: return RPC_NT_UNSUPPORTED_TRANS_SYN;
788 case RPC_S_UNSUPPORTED_TYPE: return RPC_NT_UNSUPPORTED_TYPE;
789 case RPC_S_INVALID_TAG: return RPC_NT_INVALID_TAG;
790 case RPC_S_INVALID_BOUND: return RPC_NT_INVALID_BOUND;
791 case RPC_S_NO_ENTRY_NAME: return RPC_NT_NO_ENTRY_NAME;
792 case RPC_S_INVALID_NAME_SYNTAX: return RPC_NT_INVALID_NAME_SYNTAX;
793 case RPC_S_UNSUPPORTED_NAME_SYNTAX: return RPC_NT_UNSUPPORTED_NAME_SYNTAX;
794 case RPC_S_UUID_NO_ADDRESS: return RPC_NT_UUID_NO_ADDRESS;
795 case RPC_S_DUPLICATE_ENDPOINT: return RPC_NT_DUPLICATE_ENDPOINT;
796 case RPC_S_UNKNOWN_AUTHN_TYPE: return RPC_NT_UNKNOWN_AUTHN_TYPE;
797 case RPC_S_MAX_CALLS_TOO_SMALL: return RPC_NT_MAX_CALLS_TOO_SMALL;
798 case RPC_S_STRING_TOO_LONG: return RPC_NT_STRING_TOO_LONG;
799 case RPC_S_PROTSEQ_NOT_FOUND: return RPC_NT_PROTSEQ_NOT_FOUND;
800 case RPC_S_PROCNUM_OUT_OF_RANGE: return RPC_NT_PROCNUM_OUT_OF_RANGE;
801 case RPC_S_BINDING_HAS_NO_AUTH: return RPC_NT_BINDING_HAS_NO_AUTH;
802 case RPC_S_UNKNOWN_AUTHN_SERVICE: return RPC_NT_UNKNOWN_AUTHN_SERVICE;
803 case RPC_S_UNKNOWN_AUTHN_LEVEL: return RPC_NT_UNKNOWN_AUTHN_LEVEL;
804 case RPC_S_INVALID_AUTH_IDENTITY: return RPC_NT_INVALID_AUTH_IDENTITY;
805 case RPC_S_UNKNOWN_AUTHZ_SERVICE: return RPC_NT_UNKNOWN_AUTHZ_SERVICE;
806 case EPT_S_INVALID_ENTRY: return EPT_NT_INVALID_ENTRY;
807 case EPT_S_CANT_PERFORM_OP: return EPT_NT_CANT_PERFORM_OP;
808 case EPT_S_NOT_REGISTERED: return EPT_NT_NOT_REGISTERED;
809 case EPT_S_CANT_CREATE: return EPT_NT_CANT_CREATE;
810 case RPC_S_NOTHING_TO_EXPORT: return RPC_NT_NOTHING_TO_EXPORT;
811 case RPC_S_INCOMPLETE_NAME: return RPC_NT_INCOMPLETE_NAME;
812 case RPC_S_INVALID_VERS_OPTION: return RPC_NT_INVALID_VERS_OPTION;
813 case RPC_S_NO_MORE_MEMBERS: return RPC_NT_NO_MORE_MEMBERS;
814 case RPC_S_NOT_ALL_OBJS_UNEXPORTED: return RPC_NT_NOT_ALL_OBJS_UNEXPORTED;
815 case RPC_S_INTERFACE_NOT_FOUND: return RPC_NT_INTERFACE_NOT_FOUND;
816 case RPC_S_ENTRY_ALREADY_EXISTS: return RPC_NT_ENTRY_ALREADY_EXISTS;
817 case RPC_S_ENTRY_NOT_FOUND: return RPC_NT_ENTRY_NOT_FOUND;
818 case RPC_S_NAME_SERVICE_UNAVAILABLE: return RPC_NT_NAME_SERVICE_UNAVAILABLE;
819 case RPC_S_INVALID_NAF_ID: return RPC_NT_INVALID_NAF_ID;
820 case RPC_S_CANNOT_SUPPORT: return RPC_NT_CANNOT_SUPPORT;
821 case RPC_S_NO_CONTEXT_AVAILABLE: return RPC_NT_NO_CONTEXT_AVAILABLE;
822 case RPC_S_INTERNAL_ERROR: return RPC_NT_INTERNAL_ERROR;
823 case RPC_S_ZERO_DIVIDE: return RPC_NT_ZERO_DIVIDE;
824 case RPC_S_ADDRESS_ERROR: return RPC_NT_ADDRESS_ERROR;
825 case RPC_S_FP_DIV_ZERO: return RPC_NT_FP_DIV_ZERO;
826 case RPC_S_FP_UNDERFLOW: return RPC_NT_FP_UNDERFLOW;
827 case RPC_S_FP_OVERFLOW: return RPC_NT_FP_OVERFLOW;
828 case RPC_S_CALL_IN_PROGRESS: return RPC_NT_CALL_IN_PROGRESS;
829 case RPC_S_NO_MORE_BINDINGS: return RPC_NT_NO_MORE_BINDINGS;
830 case RPC_S_CALL_CANCELLED: return RPC_NT_CALL_CANCELLED;
831 case RPC_S_INVALID_OBJECT: return RPC_NT_INVALID_OBJECT;
832 case RPC_S_INVALID_ASYNC_HANDLE: return RPC_NT_INVALID_ASYNC_HANDLE;
833 case RPC_S_INVALID_ASYNC_CALL: return RPC_NT_INVALID_ASYNC_CALL;
834 case RPC_S_GROUP_MEMBER_NOT_FOUND: return RPC_NT_GROUP_MEMBER_NOT_FOUND;
835 case RPC_X_NO_MORE_ENTRIES: return RPC_NT_NO_MORE_ENTRIES;
836 case RPC_X_SS_CHAR_TRANS_OPEN_FAIL: return RPC_NT_SS_CHAR_TRANS_OPEN_FAIL;
837 case RPC_X_SS_CHAR_TRANS_SHORT_FILE: return RPC_NT_SS_CHAR_TRANS_SHORT_FILE;
838 case RPC_X_SS_IN_NULL_CONTEXT: return RPC_NT_SS_IN_NULL_CONTEXT;
839 case RPC_X_SS_CONTEXT_DAMAGED: return RPC_NT_SS_CONTEXT_DAMAGED;
840 case RPC_X_SS_HANDLES_MISMATCH: return RPC_NT_SS_HANDLES_MISMATCH;
841 case RPC_X_SS_CANNOT_GET_CALL_HANDLE: return RPC_NT_SS_CANNOT_GET_CALL_HANDLE;
842 case RPC_X_NULL_REF_POINTER: return RPC_NT_NULL_REF_POINTER;
843 case RPC_X_ENUM_VALUE_OUT_OF_RANGE: return RPC_NT_ENUM_VALUE_OUT_OF_RANGE;
844 case RPC_X_BYTE_COUNT_TOO_SMALL: return RPC_NT_BYTE_COUNT_TOO_SMALL;
845 case RPC_X_BAD_STUB_DATA: return RPC_NT_BAD_STUB_DATA;
846 case RPC_X_PIPE_CLOSED: return RPC_NT_PIPE_CLOSED;
847 case RPC_X_PIPE_DISCIPLINE_ERROR: return RPC_NT_PIPE_DISCIPLINE_ERROR;
848 case RPC_X_PIPE_EMPTY: return RPC_NT_PIPE_EMPTY;
849 case ERROR_PASSWORD_MUST_CHANGE: return STATUS_PASSWORD_MUST_CHANGE;
850 case ERROR_ACCOUNT_LOCKED_OUT: return STATUS_ACCOUNT_LOCKED_OUT;
851 default: return status;
852 }
853 }
854
855 /******************************************************************************
856 * RpcExceptionFilter (rpcrt4.@)
857 * I_RpcExceptionFilter (rpcrt4.@)
858 */
RpcExceptionFilter(ULONG ExceptionCode)859 int WINAPI RpcExceptionFilter(ULONG ExceptionCode)
860 {
861 TRACE("0x%x\n", ExceptionCode);
862 switch (ExceptionCode)
863 {
864 case STATUS_DATATYPE_MISALIGNMENT:
865 case STATUS_BREAKPOINT:
866 case STATUS_ACCESS_VIOLATION:
867 case STATUS_ILLEGAL_INSTRUCTION:
868 case STATUS_PRIVILEGED_INSTRUCTION:
869 case STATUS_INSTRUCTION_MISALIGNMENT:
870 case STATUS_STACK_OVERFLOW:
871 case STATUS_POSSIBLE_DEADLOCK:
872 return EXCEPTION_CONTINUE_SEARCH;
873 default:
874 return EXCEPTION_EXECUTE_HANDLER;
875 }
876 }
877
878 /******************************************************************************
879 * RpcErrorStartEnumeration (rpcrt4.@)
880 */
RpcErrorStartEnumeration(RPC_ERROR_ENUM_HANDLE * EnumHandle)881 RPC_STATUS RPC_ENTRY RpcErrorStartEnumeration(RPC_ERROR_ENUM_HANDLE* EnumHandle)
882 {
883 FIXME("(%p): stub\n", EnumHandle);
884 return RPC_S_ENTRY_NOT_FOUND;
885 }
886
887 /******************************************************************************
888 * RpcErrorEndEnumeration (rpcrt4.@)
889 */
RpcErrorEndEnumeration(RPC_ERROR_ENUM_HANDLE * EnumHandle)890 RPC_STATUS RPC_ENTRY RpcErrorEndEnumeration(RPC_ERROR_ENUM_HANDLE* EnumHandle)
891 {
892 FIXME("(%p): stub\n", EnumHandle);
893 return RPC_S_OK;
894 }
895
896 /******************************************************************************
897 * RpcErrorSaveErrorInfo (rpcrt4.@)
898 */
RpcErrorSaveErrorInfo(RPC_ERROR_ENUM_HANDLE * EnumHandle,void ** ErrorBlob,SIZE_T * BlobSize)899 RPC_STATUS RPC_ENTRY RpcErrorSaveErrorInfo(RPC_ERROR_ENUM_HANDLE *EnumHandle, void **ErrorBlob, SIZE_T *BlobSize)
900 {
901 FIXME("(%p %p %p): stub\n", EnumHandle, ErrorBlob, BlobSize);
902 return ERROR_CALL_NOT_IMPLEMENTED;
903 }
904
905 /******************************************************************************
906 * RpcErrorLoadErrorInfo (rpcrt4.@)
907 */
RpcErrorLoadErrorInfo(void * ErrorBlob,SIZE_T BlobSize,RPC_ERROR_ENUM_HANDLE * EnumHandle)908 RPC_STATUS RPC_ENTRY RpcErrorLoadErrorInfo(void *ErrorBlob, SIZE_T BlobSize, RPC_ERROR_ENUM_HANDLE *EnumHandle)
909 {
910 FIXME("(%p %lu %p): stub\n", ErrorBlob, BlobSize, EnumHandle);
911 return ERROR_CALL_NOT_IMPLEMENTED;
912 }
913
914 /******************************************************************************
915 * RpcErrorGetNextRecord (rpcrt4.@)
916 */
RpcErrorGetNextRecord(RPC_ERROR_ENUM_HANDLE * EnumHandle,BOOL CopyStrings,RPC_EXTENDED_ERROR_INFO * ErrorInfo)917 RPC_STATUS RPC_ENTRY RpcErrorGetNextRecord(RPC_ERROR_ENUM_HANDLE *EnumHandle, BOOL CopyStrings, RPC_EXTENDED_ERROR_INFO *ErrorInfo)
918 {
919 FIXME("(%p %x %p): stub\n", EnumHandle, CopyStrings, ErrorInfo);
920 return RPC_S_ENTRY_NOT_FOUND;
921 }
922
923 /******************************************************************************
924 * RpcMgmtSetCancelTimeout (rpcrt4.@)
925 */
RpcMgmtSetCancelTimeout(LONG Timeout)926 RPC_STATUS RPC_ENTRY RpcMgmtSetCancelTimeout(LONG Timeout)
927 {
928 FIXME("(%d): stub\n", Timeout);
929 return RPC_S_OK;
930 }
931
get_or_create_threaddata(void)932 static struct threaddata *get_or_create_threaddata(void)
933 {
934 struct threaddata *tdata = NtCurrentTeb()->ReservedForNtRpc;
935 if (!tdata)
936 {
937 tdata = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*tdata));
938 if (!tdata) return NULL;
939
940 InitializeCriticalSection(&tdata->cs);
941 tdata->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": threaddata.cs");
942 tdata->thread_id = GetCurrentThreadId();
943
944 EnterCriticalSection(&threaddata_cs);
945 list_add_tail(&threaddata_list, &tdata->entry);
946 LeaveCriticalSection(&threaddata_cs);
947
948 NtCurrentTeb()->ReservedForNtRpc = tdata;
949 return tdata;
950 }
951 return tdata;
952 }
953
RPCRT4_SetThreadCurrentConnection(RpcConnection * Connection)954 void RPCRT4_SetThreadCurrentConnection(RpcConnection *Connection)
955 {
956 struct threaddata *tdata = get_or_create_threaddata();
957 if (!tdata) return;
958
959 EnterCriticalSection(&tdata->cs);
960 tdata->connection = Connection;
961 LeaveCriticalSection(&tdata->cs);
962 }
963
RPCRT4_SetThreadCurrentCallHandle(RpcBinding * Binding)964 void RPCRT4_SetThreadCurrentCallHandle(RpcBinding *Binding)
965 {
966 struct threaddata *tdata = get_or_create_threaddata();
967 if (!tdata) return;
968
969 tdata->server_binding = Binding;
970 }
971
RPCRT4_GetThreadCurrentCallHandle(void)972 RpcBinding *RPCRT4_GetThreadCurrentCallHandle(void)
973 {
974 struct threaddata *tdata = get_or_create_threaddata();
975 if (!tdata) return NULL;
976
977 return tdata->server_binding;
978 }
979
RPCRT4_PushThreadContextHandle(NDR_SCONTEXT SContext)980 void RPCRT4_PushThreadContextHandle(NDR_SCONTEXT SContext)
981 {
982 struct threaddata *tdata = get_or_create_threaddata();
983 struct context_handle_list *context_handle_list;
984
985 if (!tdata) return;
986
987 context_handle_list = HeapAlloc(GetProcessHeap(), 0, sizeof(*context_handle_list));
988 if (!context_handle_list) return;
989
990 context_handle_list->context_handle = SContext;
991 context_handle_list->next = tdata->context_handle_list;
992 tdata->context_handle_list = context_handle_list;
993 }
994
RPCRT4_RemoveThreadContextHandle(NDR_SCONTEXT SContext)995 void RPCRT4_RemoveThreadContextHandle(NDR_SCONTEXT SContext)
996 {
997 struct threaddata *tdata = get_or_create_threaddata();
998 struct context_handle_list *current, *prev;
999
1000 if (!tdata) return;
1001
1002 for (current = tdata->context_handle_list, prev = NULL; current; prev = current, current = current->next)
1003 {
1004 if (current->context_handle == SContext)
1005 {
1006 if (prev)
1007 prev->next = current->next;
1008 else
1009 tdata->context_handle_list = current->next;
1010 HeapFree(GetProcessHeap(), 0, current);
1011 return;
1012 }
1013 }
1014 }
1015
RPCRT4_PopThreadContextHandle(void)1016 NDR_SCONTEXT RPCRT4_PopThreadContextHandle(void)
1017 {
1018 struct threaddata *tdata = get_or_create_threaddata();
1019 struct context_handle_list *context_handle_list;
1020 NDR_SCONTEXT context_handle;
1021
1022 if (!tdata) return NULL;
1023
1024 context_handle_list = tdata->context_handle_list;
1025 if (!context_handle_list) return NULL;
1026 tdata->context_handle_list = context_handle_list->next;
1027
1028 context_handle = context_handle_list->context_handle;
1029 HeapFree(GetProcessHeap(), 0, context_handle_list);
1030 return context_handle;
1031 }
1032
rpc_cancel_thread(DWORD target_tid)1033 static RPC_STATUS rpc_cancel_thread(DWORD target_tid)
1034 {
1035 struct threaddata *tdata;
1036
1037 EnterCriticalSection(&threaddata_cs);
1038 LIST_FOR_EACH_ENTRY(tdata, &threaddata_list, struct threaddata, entry)
1039 if (tdata->thread_id == target_tid)
1040 {
1041 EnterCriticalSection(&tdata->cs);
1042 if (tdata->connection) rpcrt4_conn_cancel_call(tdata->connection);
1043 LeaveCriticalSection(&tdata->cs);
1044 break;
1045 }
1046 LeaveCriticalSection(&threaddata_cs);
1047
1048 return RPC_S_OK;
1049 }
1050
1051 /******************************************************************************
1052 * RpcCancelThread (rpcrt4.@)
1053 */
RpcCancelThread(void * ThreadHandle)1054 RPC_STATUS RPC_ENTRY RpcCancelThread(void* ThreadHandle)
1055 {
1056 TRACE("(%p)\n", ThreadHandle);
1057 return RpcCancelThreadEx(ThreadHandle, 0);
1058 }
1059
1060 /******************************************************************************
1061 * RpcCancelThreadEx (rpcrt4.@)
1062 */
RpcCancelThreadEx(void * ThreadHandle,LONG Timeout)1063 RPC_STATUS RPC_ENTRY RpcCancelThreadEx(void* ThreadHandle, LONG Timeout)
1064 {
1065 DWORD target_tid;
1066
1067 FIXME("(%p, %d)\n", ThreadHandle, Timeout);
1068
1069 target_tid = GetThreadId(ThreadHandle);
1070 if (!target_tid)
1071 return RPC_S_INVALID_ARG;
1072
1073 if (Timeout)
1074 {
1075 FIXME("(%p, %d)\n", ThreadHandle, Timeout);
1076 return RPC_S_OK;
1077 }
1078 else
1079 return rpc_cancel_thread(target_tid);
1080 }
1081