dll/win32/rpcrt4/rpcrt4_main.c

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