dwrite: Implement CreateFontFaceFromHdc().
[wine.git] / dlls / rpcrt4 / rpcrt4_main.c
blobef78b03839b1e46dba20077cef4cd31d78cf465b
1 /*
2 * RPCRT4
4 * Copyright 2000 Huw D M Davies for CodeWeavers
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.
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.
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
20 * WINE RPC TODO's (and a few TODONT's)
22 * - Statistics: we are supposed to be keeping various counters. we aren't.
24 * - Async RPC: Unimplemented.
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.
31 #include "config.h"
33 #include <stdarg.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
38 #include "ntstatus.h"
39 #define WIN32_NO_STATUS
40 #include "windef.h"
41 #include "winerror.h"
42 #include "winbase.h"
43 #include "winuser.h"
44 #include "winnt.h"
45 #include "winternl.h"
46 #include "ntsecapi.h"
47 #include "iptypes.h"
48 #include "iphlpapi.h"
49 #include "wine/unicode.h"
50 #include "rpc.h"
52 #include "ole2.h"
53 #include "rpcndr.h"
54 #include "rpcproxy.h"
56 #include "rpc_binding.h"
57 #include "rpc_server.h"
59 #include "wine/debug.h"
61 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
63 static UUID uuid_nil;
65 static CRITICAL_SECTION uuid_cs;
66 static CRITICAL_SECTION_DEBUG critsect_debug =
68 0, 0, &uuid_cs,
69 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
70 0, 0, { (DWORD_PTR)(__FILE__ ": uuid_cs") }
72 static CRITICAL_SECTION uuid_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
74 static CRITICAL_SECTION threaddata_cs;
75 static CRITICAL_SECTION_DEBUG threaddata_cs_debug =
77 0, 0, &threaddata_cs,
78 { &threaddata_cs_debug.ProcessLocksList, &threaddata_cs_debug.ProcessLocksList },
79 0, 0, { (DWORD_PTR)(__FILE__ ": threaddata_cs") }
81 static CRITICAL_SECTION threaddata_cs = { &threaddata_cs_debug, -1, 0, 0, 0, 0 };
83 static struct list threaddata_list = LIST_INIT(threaddata_list);
85 struct context_handle_list
87 struct context_handle_list *next;
88 NDR_SCONTEXT context_handle;
91 struct threaddata
93 struct list entry;
94 CRITICAL_SECTION cs;
95 DWORD thread_id;
96 RpcConnection *connection;
97 RpcBinding *server_binding;
98 struct context_handle_list *context_handle_list;
101 /***********************************************************************
102 * DllMain
104 * PARAMS
105 * hinstDLL [I] handle to the DLL's instance
106 * fdwReason [I]
107 * lpvReserved [I] reserved, must be NULL
109 * RETURNS
110 * Success: TRUE
111 * Failure: FALSE
114 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
116 struct threaddata *tdata;
118 switch (fdwReason) {
119 case DLL_PROCESS_ATTACH:
120 break;
122 case DLL_THREAD_DETACH:
123 tdata = NtCurrentTeb()->ReservedForNtRpc;
124 if (tdata)
126 EnterCriticalSection(&threaddata_cs);
127 list_remove(&tdata->entry);
128 LeaveCriticalSection(&threaddata_cs);
130 tdata->cs.DebugInfo->Spare[0] = 0;
131 DeleteCriticalSection(&tdata->cs);
132 if (tdata->connection)
133 ERR("tdata->connection should be NULL but is still set to %p\n", tdata->connection);
134 if (tdata->server_binding)
135 ERR("tdata->server_binding should be NULL but is still set to %p\n", tdata->server_binding);
136 HeapFree(GetProcessHeap(), 0, tdata);
138 break;
140 case DLL_PROCESS_DETACH:
141 if (lpvReserved) break; /* do nothing if process is shutting down */
142 RPCRT4_destroy_all_protseqs();
143 RPCRT4_ServerFreeAllRegisteredAuthInfo();
144 DeleteCriticalSection(&uuid_cs);
145 DeleteCriticalSection(&threaddata_cs);
146 break;
149 return TRUE;
152 /*************************************************************************
153 * RpcStringFreeA [RPCRT4.@]
155 * Frees a character string allocated by the RPC run-time library.
157 * RETURNS
159 * S_OK if successful.
161 RPC_STATUS WINAPI RpcStringFreeA(RPC_CSTR* String)
163 HeapFree( GetProcessHeap(), 0, *String);
165 return RPC_S_OK;
168 /*************************************************************************
169 * RpcStringFreeW [RPCRT4.@]
171 * Frees a character string allocated by the RPC run-time library.
173 * RETURNS
175 * S_OK if successful.
177 RPC_STATUS WINAPI RpcStringFreeW(RPC_WSTR* String)
179 HeapFree( GetProcessHeap(), 0, *String);
181 return RPC_S_OK;
184 /*************************************************************************
185 * RpcRaiseException [RPCRT4.@]
187 * Raises an exception.
189 void DECLSPEC_NORETURN WINAPI RpcRaiseException(RPC_STATUS exception)
191 /* shouldn't return */
192 RaiseException(exception, 0, 0, NULL);
193 ERR("handler continued execution\n");
194 ExitProcess(1);
197 /*************************************************************************
198 * UuidCompare [RPCRT4.@]
200 * PARAMS
201 * UUID *Uuid1 [I] Uuid to compare
202 * UUID *Uuid2 [I] Uuid to compare
203 * RPC_STATUS *Status [O] returns RPC_S_OK
205 * RETURNS
206 * -1 if Uuid1 is less than Uuid2
207 * 0 if Uuid1 and Uuid2 are equal
208 * 1 if Uuid1 is greater than Uuid2
210 int WINAPI UuidCompare(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
212 int i;
214 TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
216 *Status = RPC_S_OK;
218 if (!Uuid1) Uuid1 = &uuid_nil;
219 if (!Uuid2) Uuid2 = &uuid_nil;
221 if (Uuid1 == Uuid2) return 0;
223 if (Uuid1->Data1 != Uuid2->Data1)
224 return Uuid1->Data1 < Uuid2->Data1 ? -1 : 1;
226 if (Uuid1->Data2 != Uuid2->Data2)
227 return Uuid1->Data2 < Uuid2->Data2 ? -1 : 1;
229 if (Uuid1->Data3 != Uuid2->Data3)
230 return Uuid1->Data3 < Uuid2->Data3 ? -1 : 1;
232 for (i = 0; i < 8; i++) {
233 if (Uuid1->Data4[i] < Uuid2->Data4[i])
234 return -1;
235 if (Uuid1->Data4[i] > Uuid2->Data4[i])
236 return 1;
239 return 0;
242 /*************************************************************************
243 * UuidEqual [RPCRT4.@]
245 * PARAMS
246 * UUID *Uuid1 [I] Uuid to compare
247 * UUID *Uuid2 [I] Uuid to compare
248 * RPC_STATUS *Status [O] returns RPC_S_OK
250 * RETURNS
251 * TRUE/FALSE
253 int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
255 TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
256 return !UuidCompare(Uuid1, Uuid2, Status);
259 /*************************************************************************
260 * UuidIsNil [RPCRT4.@]
262 * PARAMS
263 * UUID *Uuid [I] Uuid to compare
264 * RPC_STATUS *Status [O] returns RPC_S_OK
266 * RETURNS
267 * TRUE/FALSE
269 int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
271 TRACE("(%s)\n", debugstr_guid(Uuid));
272 if (!Uuid) return TRUE;
273 return !UuidCompare(Uuid, &uuid_nil, Status);
276 /*************************************************************************
277 * UuidCreateNil [RPCRT4.@]
279 * PARAMS
280 * UUID *Uuid [O] returns a nil UUID
282 * RETURNS
283 * RPC_S_OK
285 RPC_STATUS WINAPI UuidCreateNil(UUID *Uuid)
287 *Uuid = uuid_nil;
288 return RPC_S_OK;
291 /*************************************************************************
292 * UuidCreate [RPCRT4.@]
294 * Creates a 128bit UUID.
296 * RETURNS
298 * RPC_S_OK if successful.
299 * RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
301 * NOTES
303 * Follows RFC 4122, section 4.4 (Algorithms for Creating a UUID from
304 * Truly Random or Pseudo-Random Numbers)
306 RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
308 RtlGenRandom(Uuid, sizeof(*Uuid));
309 /* Clear the version bits and set the version (4) */
310 Uuid->Data3 &= 0x0fff;
311 Uuid->Data3 |= (4 << 12);
312 /* Set the topmost bits of Data4 (clock_seq_hi_and_reserved) as
313 * specified in RFC 4122, section 4.4.
315 Uuid->Data4[0] &= 0x3f;
316 Uuid->Data4[0] |= 0x80;
318 TRACE("%s\n", debugstr_guid(Uuid));
320 return RPC_S_OK;
323 /* Number of 100ns ticks per clock tick. To be safe, assume that the clock
324 resolution is at least 1000 * 100 * (1/1000000) = 1/10 of a second */
325 #define TICKS_PER_CLOCK_TICK 1000
326 #define SECSPERDAY 86400
327 #define TICKSPERSEC 10000000
328 /* UUID system time starts at October 15, 1582 */
329 #define SECS_15_OCT_1582_TO_1601 ((17 + 30 + 31 + 365 * 18 + 5) * SECSPERDAY)
330 #define TICKS_15_OCT_1582_TO_1601 ((ULONGLONG)SECS_15_OCT_1582_TO_1601 * TICKSPERSEC)
332 static void RPC_UuidGetSystemTime(ULONGLONG *time)
334 FILETIME ft;
336 GetSystemTimeAsFileTime(&ft);
338 *time = ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
339 *time += TICKS_15_OCT_1582_TO_1601;
342 /* Assume that a hardware address is at least 6 bytes long */
343 #define ADDRESS_BYTES_NEEDED 6
345 static RPC_STATUS RPC_UuidGetNodeAddress(BYTE *address)
347 int i;
348 DWORD status = RPC_S_OK;
350 ULONG buflen = sizeof(IP_ADAPTER_INFO);
351 PIP_ADAPTER_INFO adapter = HeapAlloc(GetProcessHeap(), 0, buflen);
353 if (GetAdaptersInfo(adapter, &buflen) == ERROR_BUFFER_OVERFLOW) {
354 HeapFree(GetProcessHeap(), 0, adapter);
355 adapter = HeapAlloc(GetProcessHeap(), 0, buflen);
358 if (GetAdaptersInfo(adapter, &buflen) == NO_ERROR) {
359 for (i = 0; i < ADDRESS_BYTES_NEEDED; i++) {
360 address[i] = adapter->Address[i];
363 /* We can't get a hardware address, just use random numbers.
364 Set the multicast bit to prevent conflicts with real cards. */
365 else {
366 RtlGenRandom(address, ADDRESS_BYTES_NEEDED);
367 address[0] |= 0x01;
368 status = RPC_S_UUID_LOCAL_ONLY;
371 HeapFree(GetProcessHeap(), 0, adapter);
372 return status;
375 /*************************************************************************
376 * UuidCreateSequential [RPCRT4.@]
378 * Creates a 128bit UUID.
380 * RETURNS
382 * RPC_S_OK if successful.
383 * RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
385 * FIXME: No compensation for changes across reloading
386 * this dll or across reboots (e.g. clock going
387 * backwards and swapped network cards). The RFC
388 * suggests using NVRAM for storing persistent
389 * values.
391 RPC_STATUS WINAPI UuidCreateSequential(UUID *Uuid)
393 static BOOL initialised;
394 static int count;
396 ULONGLONG time;
397 static ULONGLONG timelast;
398 static WORD sequence;
400 static DWORD status;
401 static BYTE address[MAX_ADAPTER_ADDRESS_LENGTH];
403 EnterCriticalSection(&uuid_cs);
405 if (!initialised) {
406 RPC_UuidGetSystemTime(&timelast);
407 count = TICKS_PER_CLOCK_TICK;
409 sequence = ((rand() & 0xff) << 8) + (rand() & 0xff);
410 sequence &= 0x1fff;
412 status = RPC_UuidGetNodeAddress(address);
413 initialised = TRUE;
416 /* Generate time element of the UUID. Account for going faster
417 than our clock as well as the clock going backwards. */
418 while (1) {
419 RPC_UuidGetSystemTime(&time);
420 if (time > timelast) {
421 count = 0;
422 break;
424 if (time < timelast) {
425 sequence = (sequence + 1) & 0x1fff;
426 count = 0;
427 break;
429 if (count < TICKS_PER_CLOCK_TICK) {
430 count++;
431 break;
435 timelast = time;
436 time += count;
438 /* Pack the information into the UUID structure. */
440 Uuid->Data1 = (ULONG)(time & 0xffffffff);
441 Uuid->Data2 = (unsigned short)((time >> 32) & 0xffff);
442 Uuid->Data3 = (unsigned short)((time >> 48) & 0x0fff);
444 /* This is a version 1 UUID */
445 Uuid->Data3 |= (1 << 12);
447 Uuid->Data4[0] = sequence & 0xff;
448 Uuid->Data4[1] = (sequence & 0x3f00) >> 8;
449 Uuid->Data4[1] |= 0x80;
450 memcpy(&Uuid->Data4[2], address, ADDRESS_BYTES_NEEDED);
452 LeaveCriticalSection(&uuid_cs);
454 TRACE("%s\n", debugstr_guid(Uuid));
456 return status;
460 /*************************************************************************
461 * UuidHash [RPCRT4.@]
463 * Generates a hash value for a given UUID
465 * Code based on FreeDCE implementation
468 unsigned short WINAPI UuidHash(UUID *uuid, RPC_STATUS *Status)
470 BYTE *data = (BYTE*)uuid;
471 short c0 = 0, c1 = 0, x, y;
472 unsigned int i;
474 if (!uuid) data = (BYTE*)(uuid = &uuid_nil);
476 TRACE("(%s)\n", debugstr_guid(uuid));
478 for (i=0; i<sizeof(UUID); i++) {
479 c0 += data[i];
480 c1 += c0;
483 x = -c1 % 255;
484 if (x < 0) x += 255;
486 y = (c1 - c0) % 255;
487 if (y < 0) y += 255;
489 *Status = RPC_S_OK;
490 return y*256 + x;
493 /*************************************************************************
494 * UuidToStringA [RPCRT4.@]
496 * Converts a UUID to a string.
498 * UUID format is 8 hex digits, followed by a hyphen then three groups of
499 * 4 hex digits each followed by a hyphen and then 12 hex digits
501 * RETURNS
503 * S_OK if successful.
504 * S_OUT_OF_MEMORY if unsuccessful.
506 RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, RPC_CSTR* StringUuid)
508 *StringUuid = HeapAlloc( GetProcessHeap(), 0, sizeof(char) * 37);
510 if(!(*StringUuid))
511 return RPC_S_OUT_OF_MEMORY;
513 if (!Uuid) Uuid = &uuid_nil;
515 sprintf( (char*)*StringUuid, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
516 Uuid->Data1, Uuid->Data2, Uuid->Data3,
517 Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
518 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
519 Uuid->Data4[6], Uuid->Data4[7] );
521 return RPC_S_OK;
524 /*************************************************************************
525 * UuidToStringW [RPCRT4.@]
527 * Converts a UUID to a string.
529 * S_OK if successful.
530 * S_OUT_OF_MEMORY if unsuccessful.
532 RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, RPC_WSTR* StringUuid)
534 char buf[37];
536 if (!Uuid) Uuid = &uuid_nil;
538 sprintf(buf, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
539 Uuid->Data1, Uuid->Data2, Uuid->Data3,
540 Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
541 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
542 Uuid->Data4[6], Uuid->Data4[7] );
544 *StringUuid = RPCRT4_strdupAtoW(buf);
546 if(!(*StringUuid))
547 return RPC_S_OUT_OF_MEMORY;
549 return RPC_S_OK;
552 static const BYTE hex2bin[] =
554 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */
555 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */
556 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */
557 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */
558 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */
559 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */
560 0,10,11,12,13,14,15 /* 0x60 */
563 /***********************************************************************
564 * UuidFromStringA (RPCRT4.@)
566 RPC_STATUS WINAPI UuidFromStringA(RPC_CSTR s, UUID *uuid)
568 int i;
570 if (!s) return UuidCreateNil( uuid );
572 if (strlen((char*)s) != 36) return RPC_S_INVALID_STRING_UUID;
574 if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
575 return RPC_S_INVALID_STRING_UUID;
577 for (i=0; i<36; i++)
579 if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
580 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
583 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
585 uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
586 hex2bin[s[4]] << 12 | hex2bin[s[5]] << 8 | hex2bin[s[6]] << 4 | hex2bin[s[7]]);
587 uuid->Data2 = hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
588 uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
590 /* these are just sequential bytes */
591 uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
592 uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
593 uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
594 uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
595 uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
596 uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
597 uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
598 uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
599 return RPC_S_OK;
603 /***********************************************************************
604 * UuidFromStringW (RPCRT4.@)
606 RPC_STATUS WINAPI UuidFromStringW(RPC_WSTR s, UUID *uuid)
608 int i;
610 if (!s) return UuidCreateNil( uuid );
612 if (strlenW(s) != 36) return RPC_S_INVALID_STRING_UUID;
614 if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
615 return RPC_S_INVALID_STRING_UUID;
617 for (i=0; i<36; i++)
619 if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
620 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
623 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
625 uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
626 hex2bin[s[4]] << 12 | hex2bin[s[5]] << 8 | hex2bin[s[6]] << 4 | hex2bin[s[7]]);
627 uuid->Data2 = hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
628 uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
630 /* these are just sequential bytes */
631 uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
632 uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
633 uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
634 uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
635 uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
636 uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
637 uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
638 uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
639 return RPC_S_OK;
642 /***********************************************************************
643 * DllRegisterServer (RPCRT4.@)
646 HRESULT WINAPI DllRegisterServer( void )
648 FIXME( "(): stub\n" );
649 return S_OK;
652 #define MAX_RPC_ERROR_TEXT 256
654 /******************************************************************************
655 * DceErrorInqTextW (rpcrt4.@)
657 * Notes
658 * 1. On passing a NULL pointer the code does bomb out.
659 * 2. The size of the required buffer is not defined in the documentation.
660 * It appears to be 256.
661 * 3. The function is defined to return RPC_S_INVALID_ARG but I don't know
662 * of any value for which it does.
663 * 4. The MSDN documentation currently declares that the second argument is
664 * unsigned char *, even for the W version. I don't believe it.
666 RPC_STATUS RPC_ENTRY DceErrorInqTextW (RPC_STATUS e, RPC_WSTR buffer)
668 DWORD count;
669 count = FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
670 FORMAT_MESSAGE_IGNORE_INSERTS,
671 NULL, e, 0, buffer, MAX_RPC_ERROR_TEXT, NULL);
672 if (!count)
674 count = FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
675 FORMAT_MESSAGE_IGNORE_INSERTS,
676 NULL, RPC_S_NOT_RPC_ERROR, 0, buffer, MAX_RPC_ERROR_TEXT, NULL);
677 if (!count)
679 ERR ("Failed to translate error\n");
680 return RPC_S_INVALID_ARG;
683 return RPC_S_OK;
686 /******************************************************************************
687 * DceErrorInqTextA (rpcrt4.@)
689 RPC_STATUS RPC_ENTRY DceErrorInqTextA (RPC_STATUS e, RPC_CSTR buffer)
691 RPC_STATUS status;
692 WCHAR bufferW [MAX_RPC_ERROR_TEXT];
693 if ((status = DceErrorInqTextW (e, bufferW)) == RPC_S_OK)
695 if (!WideCharToMultiByte(CP_ACP, 0, bufferW, -1, (LPSTR)buffer, MAX_RPC_ERROR_TEXT,
696 NULL, NULL))
698 ERR ("Failed to translate error\n");
699 status = RPC_S_INVALID_ARG;
702 return status;
705 /******************************************************************************
706 * I_RpcAllocate (rpcrt4.@)
708 void * WINAPI I_RpcAllocate(unsigned int Size)
710 return HeapAlloc(GetProcessHeap(), 0, Size);
713 /******************************************************************************
714 * I_RpcFree (rpcrt4.@)
716 void WINAPI I_RpcFree(void *Object)
718 HeapFree(GetProcessHeap(), 0, Object);
721 /******************************************************************************
722 * I_RpcMapWin32Status (rpcrt4.@)
724 * Maps Win32 RPC error codes to NT statuses.
726 * PARAMS
727 * status [I] Win32 RPC error code.
729 * RETURNS
730 * Appropriate translation into an NT status code.
732 LONG WINAPI I_RpcMapWin32Status(RPC_STATUS status)
734 TRACE("(%d)\n", status);
735 switch (status)
737 case ERROR_ACCESS_DENIED: return STATUS_ACCESS_DENIED;
738 case ERROR_INVALID_HANDLE: return RPC_NT_SS_CONTEXT_MISMATCH;
739 case ERROR_OUTOFMEMORY: return STATUS_NO_MEMORY;
740 case ERROR_INVALID_PARAMETER: return STATUS_INVALID_PARAMETER;
741 case ERROR_INSUFFICIENT_BUFFER: return STATUS_BUFFER_TOO_SMALL;
742 case ERROR_MAX_THRDS_REACHED: return STATUS_NO_MEMORY;
743 case ERROR_NOACCESS: return STATUS_ACCESS_VIOLATION;
744 case ERROR_NOT_ENOUGH_SERVER_MEMORY: return STATUS_INSUFF_SERVER_RESOURCES;
745 case ERROR_WRONG_PASSWORD: return STATUS_WRONG_PASSWORD;
746 case ERROR_INVALID_LOGON_HOURS: return STATUS_INVALID_LOGON_HOURS;
747 case ERROR_PASSWORD_EXPIRED: return STATUS_PASSWORD_EXPIRED;
748 case ERROR_ACCOUNT_DISABLED: return STATUS_ACCOUNT_DISABLED;
749 case ERROR_INVALID_SECURITY_DESCR: return STATUS_INVALID_SECURITY_DESCR;
750 case RPC_S_INVALID_STRING_BINDING: return RPC_NT_INVALID_STRING_BINDING;
751 case RPC_S_WRONG_KIND_OF_BINDING: return RPC_NT_WRONG_KIND_OF_BINDING;
752 case RPC_S_INVALID_BINDING: return RPC_NT_INVALID_BINDING;
753 case RPC_S_PROTSEQ_NOT_SUPPORTED: return RPC_NT_PROTSEQ_NOT_SUPPORTED;
754 case RPC_S_INVALID_RPC_PROTSEQ: return RPC_NT_INVALID_RPC_PROTSEQ;
755 case RPC_S_INVALID_STRING_UUID: return RPC_NT_INVALID_STRING_UUID;
756 case RPC_S_INVALID_ENDPOINT_FORMAT: return RPC_NT_INVALID_ENDPOINT_FORMAT;
757 case RPC_S_INVALID_NET_ADDR: return RPC_NT_INVALID_NET_ADDR;
758 case RPC_S_NO_ENDPOINT_FOUND: return RPC_NT_NO_ENDPOINT_FOUND;
759 case RPC_S_INVALID_TIMEOUT: return RPC_NT_INVALID_TIMEOUT;
760 case RPC_S_OBJECT_NOT_FOUND: return RPC_NT_OBJECT_NOT_FOUND;
761 case RPC_S_ALREADY_REGISTERED: return RPC_NT_ALREADY_REGISTERED;
762 case RPC_S_TYPE_ALREADY_REGISTERED: return RPC_NT_TYPE_ALREADY_REGISTERED;
763 case RPC_S_ALREADY_LISTENING: return RPC_NT_ALREADY_LISTENING;
764 case RPC_S_NO_PROTSEQS_REGISTERED: return RPC_NT_NO_PROTSEQS_REGISTERED;
765 case RPC_S_NOT_LISTENING: return RPC_NT_NOT_LISTENING;
766 case RPC_S_UNKNOWN_MGR_TYPE: return RPC_NT_UNKNOWN_MGR_TYPE;
767 case RPC_S_UNKNOWN_IF: return RPC_NT_UNKNOWN_IF;
768 case RPC_S_NO_BINDINGS: return RPC_NT_NO_BINDINGS;
769 case RPC_S_NO_PROTSEQS: return RPC_NT_NO_PROTSEQS;
770 case RPC_S_CANT_CREATE_ENDPOINT: return RPC_NT_CANT_CREATE_ENDPOINT;
771 case RPC_S_OUT_OF_RESOURCES: return RPC_NT_OUT_OF_RESOURCES;
772 case RPC_S_SERVER_UNAVAILABLE: return RPC_NT_SERVER_UNAVAILABLE;
773 case RPC_S_SERVER_TOO_BUSY: return RPC_NT_SERVER_TOO_BUSY;
774 case RPC_S_INVALID_NETWORK_OPTIONS: return RPC_NT_INVALID_NETWORK_OPTIONS;
775 case RPC_S_NO_CALL_ACTIVE: return RPC_NT_NO_CALL_ACTIVE;
776 case RPC_S_CALL_FAILED: return RPC_NT_CALL_FAILED;
777 case RPC_S_CALL_FAILED_DNE: return RPC_NT_CALL_FAILED_DNE;
778 case RPC_S_PROTOCOL_ERROR: return RPC_NT_PROTOCOL_ERROR;
779 case RPC_S_UNSUPPORTED_TRANS_SYN: return RPC_NT_UNSUPPORTED_TRANS_SYN;
780 case RPC_S_UNSUPPORTED_TYPE: return RPC_NT_UNSUPPORTED_TYPE;
781 case RPC_S_INVALID_TAG: return RPC_NT_INVALID_TAG;
782 case RPC_S_INVALID_BOUND: return RPC_NT_INVALID_BOUND;
783 case RPC_S_NO_ENTRY_NAME: return RPC_NT_NO_ENTRY_NAME;
784 case RPC_S_INVALID_NAME_SYNTAX: return RPC_NT_INVALID_NAME_SYNTAX;
785 case RPC_S_UNSUPPORTED_NAME_SYNTAX: return RPC_NT_UNSUPPORTED_NAME_SYNTAX;
786 case RPC_S_UUID_NO_ADDRESS: return RPC_NT_UUID_NO_ADDRESS;
787 case RPC_S_DUPLICATE_ENDPOINT: return RPC_NT_DUPLICATE_ENDPOINT;
788 case RPC_S_UNKNOWN_AUTHN_TYPE: return RPC_NT_UNKNOWN_AUTHN_TYPE;
789 case RPC_S_MAX_CALLS_TOO_SMALL: return RPC_NT_MAX_CALLS_TOO_SMALL;
790 case RPC_S_STRING_TOO_LONG: return RPC_NT_STRING_TOO_LONG;
791 case RPC_S_PROTSEQ_NOT_FOUND: return RPC_NT_PROTSEQ_NOT_FOUND;
792 case RPC_S_PROCNUM_OUT_OF_RANGE: return RPC_NT_PROCNUM_OUT_OF_RANGE;
793 case RPC_S_BINDING_HAS_NO_AUTH: return RPC_NT_BINDING_HAS_NO_AUTH;
794 case RPC_S_UNKNOWN_AUTHN_SERVICE: return RPC_NT_UNKNOWN_AUTHN_SERVICE;
795 case RPC_S_UNKNOWN_AUTHN_LEVEL: return RPC_NT_UNKNOWN_AUTHN_LEVEL;
796 case RPC_S_INVALID_AUTH_IDENTITY: return RPC_NT_INVALID_AUTH_IDENTITY;
797 case RPC_S_UNKNOWN_AUTHZ_SERVICE: return RPC_NT_UNKNOWN_AUTHZ_SERVICE;
798 case EPT_S_INVALID_ENTRY: return EPT_NT_INVALID_ENTRY;
799 case EPT_S_CANT_PERFORM_OP: return EPT_NT_CANT_PERFORM_OP;
800 case EPT_S_NOT_REGISTERED: return EPT_NT_NOT_REGISTERED;
801 case EPT_S_CANT_CREATE: return EPT_NT_CANT_CREATE;
802 case RPC_S_NOTHING_TO_EXPORT: return RPC_NT_NOTHING_TO_EXPORT;
803 case RPC_S_INCOMPLETE_NAME: return RPC_NT_INCOMPLETE_NAME;
804 case RPC_S_INVALID_VERS_OPTION: return RPC_NT_INVALID_VERS_OPTION;
805 case RPC_S_NO_MORE_MEMBERS: return RPC_NT_NO_MORE_MEMBERS;
806 case RPC_S_NOT_ALL_OBJS_UNEXPORTED: return RPC_NT_NOT_ALL_OBJS_UNEXPORTED;
807 case RPC_S_INTERFACE_NOT_FOUND: return RPC_NT_INTERFACE_NOT_FOUND;
808 case RPC_S_ENTRY_ALREADY_EXISTS: return RPC_NT_ENTRY_ALREADY_EXISTS;
809 case RPC_S_ENTRY_NOT_FOUND: return RPC_NT_ENTRY_NOT_FOUND;
810 case RPC_S_NAME_SERVICE_UNAVAILABLE: return RPC_NT_NAME_SERVICE_UNAVAILABLE;
811 case RPC_S_INVALID_NAF_ID: return RPC_NT_INVALID_NAF_ID;
812 case RPC_S_CANNOT_SUPPORT: return RPC_NT_CANNOT_SUPPORT;
813 case RPC_S_NO_CONTEXT_AVAILABLE: return RPC_NT_NO_CONTEXT_AVAILABLE;
814 case RPC_S_INTERNAL_ERROR: return RPC_NT_INTERNAL_ERROR;
815 case RPC_S_ZERO_DIVIDE: return RPC_NT_ZERO_DIVIDE;
816 case RPC_S_ADDRESS_ERROR: return RPC_NT_ADDRESS_ERROR;
817 case RPC_S_FP_DIV_ZERO: return RPC_NT_FP_DIV_ZERO;
818 case RPC_S_FP_UNDERFLOW: return RPC_NT_FP_UNDERFLOW;
819 case RPC_S_FP_OVERFLOW: return RPC_NT_FP_OVERFLOW;
820 case RPC_S_CALL_IN_PROGRESS: return RPC_NT_CALL_IN_PROGRESS;
821 case RPC_S_NO_MORE_BINDINGS: return RPC_NT_NO_MORE_BINDINGS;
822 case RPC_S_CALL_CANCELLED: return RPC_NT_CALL_CANCELLED;
823 case RPC_S_INVALID_OBJECT: return RPC_NT_INVALID_OBJECT;
824 case RPC_S_INVALID_ASYNC_HANDLE: return RPC_NT_INVALID_ASYNC_HANDLE;
825 case RPC_S_INVALID_ASYNC_CALL: return RPC_NT_INVALID_ASYNC_CALL;
826 case RPC_S_GROUP_MEMBER_NOT_FOUND: return RPC_NT_GROUP_MEMBER_NOT_FOUND;
827 case RPC_X_NO_MORE_ENTRIES: return RPC_NT_NO_MORE_ENTRIES;
828 case RPC_X_SS_CHAR_TRANS_OPEN_FAIL: return RPC_NT_SS_CHAR_TRANS_OPEN_FAIL;
829 case RPC_X_SS_CHAR_TRANS_SHORT_FILE: return RPC_NT_SS_CHAR_TRANS_SHORT_FILE;
830 case RPC_X_SS_IN_NULL_CONTEXT: return RPC_NT_SS_IN_NULL_CONTEXT;
831 case RPC_X_SS_CONTEXT_DAMAGED: return RPC_NT_SS_CONTEXT_DAMAGED;
832 case RPC_X_SS_HANDLES_MISMATCH: return RPC_NT_SS_HANDLES_MISMATCH;
833 case RPC_X_SS_CANNOT_GET_CALL_HANDLE: return RPC_NT_SS_CANNOT_GET_CALL_HANDLE;
834 case RPC_X_NULL_REF_POINTER: return RPC_NT_NULL_REF_POINTER;
835 case RPC_X_ENUM_VALUE_OUT_OF_RANGE: return RPC_NT_ENUM_VALUE_OUT_OF_RANGE;
836 case RPC_X_BYTE_COUNT_TOO_SMALL: return RPC_NT_BYTE_COUNT_TOO_SMALL;
837 case RPC_X_BAD_STUB_DATA: return RPC_NT_BAD_STUB_DATA;
838 case RPC_X_PIPE_CLOSED: return RPC_NT_PIPE_CLOSED;
839 case RPC_X_PIPE_DISCIPLINE_ERROR: return RPC_NT_PIPE_DISCIPLINE_ERROR;
840 case RPC_X_PIPE_EMPTY: return RPC_NT_PIPE_EMPTY;
841 case ERROR_PASSWORD_MUST_CHANGE: return STATUS_PASSWORD_MUST_CHANGE;
842 case ERROR_ACCOUNT_LOCKED_OUT: return STATUS_ACCOUNT_LOCKED_OUT;
843 default: return status;
847 /******************************************************************************
848 * I_RpcExceptionFilter (rpcrt4.@)
850 int WINAPI I_RpcExceptionFilter(ULONG ExceptionCode)
852 TRACE("0x%x\n", ExceptionCode);
853 switch (ExceptionCode)
855 case STATUS_DATATYPE_MISALIGNMENT:
856 case STATUS_BREAKPOINT:
857 case STATUS_ACCESS_VIOLATION:
858 case STATUS_ILLEGAL_INSTRUCTION:
859 case STATUS_PRIVILEGED_INSTRUCTION:
860 case STATUS_INSTRUCTION_MISALIGNMENT:
861 case STATUS_STACK_OVERFLOW:
862 case STATUS_POSSIBLE_DEADLOCK:
863 return EXCEPTION_CONTINUE_SEARCH;
864 default:
865 return EXCEPTION_EXECUTE_HANDLER;
869 /******************************************************************************
870 * RpcErrorStartEnumeration (rpcrt4.@)
872 RPC_STATUS RPC_ENTRY RpcErrorStartEnumeration(RPC_ERROR_ENUM_HANDLE* EnumHandle)
874 FIXME("(%p): stub\n", EnumHandle);
875 return RPC_S_ENTRY_NOT_FOUND;
878 /******************************************************************************
879 * RpcErrorEndEnumeration (rpcrt4.@)
881 RPC_STATUS RPC_ENTRY RpcErrorEndEnumeration(RPC_ERROR_ENUM_HANDLE* EnumHandle)
883 FIXME("(%p): stub\n", EnumHandle);
884 return RPC_S_OK;
887 /******************************************************************************
888 * RpcErrorSaveErrorInfo (rpcrt4.@)
890 RPC_STATUS RPC_ENTRY RpcErrorSaveErrorInfo(RPC_ERROR_ENUM_HANDLE *EnumHandle, void **ErrorBlob, SIZE_T *BlobSize)
892 FIXME("(%p %p %p): stub\n", EnumHandle, ErrorBlob, BlobSize);
893 return ERROR_CALL_NOT_IMPLEMENTED;
896 /******************************************************************************
897 * RpcErrorLoadErrorInfo (rpcrt4.@)
899 RPC_STATUS RPC_ENTRY RpcErrorLoadErrorInfo(void *ErrorBlob, SIZE_T BlobSize, RPC_ERROR_ENUM_HANDLE *EnumHandle)
901 FIXME("(%p %lu %p): stub\n", ErrorBlob, BlobSize, EnumHandle);
902 return ERROR_CALL_NOT_IMPLEMENTED;
905 /******************************************************************************
906 * RpcErrorGetNextRecord (rpcrt4.@)
908 RPC_STATUS RPC_ENTRY RpcErrorGetNextRecord(RPC_ERROR_ENUM_HANDLE *EnumHandle, BOOL CopyStrings, RPC_EXTENDED_ERROR_INFO *ErrorInfo)
910 FIXME("(%p %x %p): stub\n", EnumHandle, CopyStrings, ErrorInfo);
911 return RPC_S_ENTRY_NOT_FOUND;
914 /******************************************************************************
915 * RpcMgmtSetCancelTimeout (rpcrt4.@)
917 RPC_STATUS RPC_ENTRY RpcMgmtSetCancelTimeout(LONG Timeout)
919 FIXME("(%d): stub\n", Timeout);
920 return RPC_S_OK;
923 static struct threaddata *get_or_create_threaddata(void)
925 struct threaddata *tdata = NtCurrentTeb()->ReservedForNtRpc;
926 if (!tdata)
928 tdata = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*tdata));
929 if (!tdata) return NULL;
931 InitializeCriticalSection(&tdata->cs);
932 tdata->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": threaddata.cs");
933 tdata->thread_id = GetCurrentThreadId();
935 EnterCriticalSection(&threaddata_cs);
936 list_add_tail(&threaddata_list, &tdata->entry);
937 LeaveCriticalSection(&threaddata_cs);
939 NtCurrentTeb()->ReservedForNtRpc = tdata;
940 return tdata;
942 return tdata;
945 void RPCRT4_SetThreadCurrentConnection(RpcConnection *Connection)
947 struct threaddata *tdata = get_or_create_threaddata();
948 if (!tdata) return;
950 EnterCriticalSection(&tdata->cs);
951 tdata->connection = Connection;
952 LeaveCriticalSection(&tdata->cs);
955 void RPCRT4_SetThreadCurrentCallHandle(RpcBinding *Binding)
957 struct threaddata *tdata = get_or_create_threaddata();
958 if (!tdata) return;
960 tdata->server_binding = Binding;
963 RpcBinding *RPCRT4_GetThreadCurrentCallHandle(void)
965 struct threaddata *tdata = get_or_create_threaddata();
966 if (!tdata) return NULL;
968 return tdata->server_binding;
971 void RPCRT4_PushThreadContextHandle(NDR_SCONTEXT SContext)
973 struct threaddata *tdata = get_or_create_threaddata();
974 struct context_handle_list *context_handle_list;
976 if (!tdata) return;
978 context_handle_list = HeapAlloc(GetProcessHeap(), 0, sizeof(*context_handle_list));
979 if (!context_handle_list) return;
981 context_handle_list->context_handle = SContext;
982 context_handle_list->next = tdata->context_handle_list;
983 tdata->context_handle_list = context_handle_list;
986 void RPCRT4_RemoveThreadContextHandle(NDR_SCONTEXT SContext)
988 struct threaddata *tdata = get_or_create_threaddata();
989 struct context_handle_list *current, *prev;
991 if (!tdata) return;
993 for (current = tdata->context_handle_list, prev = NULL; current; prev = current, current = current->next)
995 if (current->context_handle == SContext)
997 if (prev)
998 prev->next = current->next;
999 else
1000 tdata->context_handle_list = current->next;
1001 HeapFree(GetProcessHeap(), 0, current);
1002 return;
1007 NDR_SCONTEXT RPCRT4_PopThreadContextHandle(void)
1009 struct threaddata *tdata = get_or_create_threaddata();
1010 struct context_handle_list *context_handle_list;
1011 NDR_SCONTEXT context_handle;
1013 if (!tdata) return NULL;
1015 context_handle_list = tdata->context_handle_list;
1016 if (!context_handle_list) return NULL;
1017 tdata->context_handle_list = context_handle_list->next;
1019 context_handle = context_handle_list->context_handle;
1020 HeapFree(GetProcessHeap(), 0, context_handle_list);
1021 return context_handle;
1024 static RPC_STATUS rpc_cancel_thread(DWORD target_tid)
1026 struct threaddata *tdata;
1028 EnterCriticalSection(&threaddata_cs);
1029 LIST_FOR_EACH_ENTRY(tdata, &threaddata_list, struct threaddata, entry)
1030 if (tdata->thread_id == target_tid)
1032 EnterCriticalSection(&tdata->cs);
1033 if (tdata->connection) rpcrt4_conn_cancel_call(tdata->connection);
1034 LeaveCriticalSection(&tdata->cs);
1035 break;
1037 LeaveCriticalSection(&threaddata_cs);
1039 return RPC_S_OK;
1042 /******************************************************************************
1043 * RpcCancelThread (rpcrt4.@)
1045 RPC_STATUS RPC_ENTRY RpcCancelThread(void* ThreadHandle)
1047 TRACE("(%p)\n", ThreadHandle);
1048 return RpcCancelThreadEx(ThreadHandle, 0);
1051 /******************************************************************************
1052 * RpcCancelThreadEx (rpcrt4.@)
1054 RPC_STATUS RPC_ENTRY RpcCancelThreadEx(void* ThreadHandle, LONG Timeout)
1056 DWORD target_tid;
1058 FIXME("(%p, %d)\n", ThreadHandle, Timeout);
1060 target_tid = GetThreadId(ThreadHandle);
1061 if (!target_tid)
1062 return RPC_S_INVALID_ARG;
1064 if (Timeout)
1066 FIXME("(%p, %d)\n", ThreadHandle, Timeout);
1067 return RPC_S_OK;
1069 else
1070 return rpc_cancel_thread(target_tid);