27afc4461b3da47a427d628380850f7f59a25639
[reactos.git] / reactos / lib / 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * WINE RPC TODO's (and a few TODONT's)
21 *
22 * - Ove's decreasingly incomplete widl is an IDL compiler for wine. For widl
23 * to be wine's only IDL compiler, a fair bit of work remains to be done.
24 * until then we have used some midl-generated stuff. (What?)
25 * widl currently doesn't generate stub/proxy files required by wine's (O)RPC
26 * capabilities -- nor does it make those lovely format strings :(
27 * The MS MIDL compiler does some really esoteric stuff. Of course Ove has
28 * started with the less esoteric stuff. There are also lots of nice
29 * comments in there if you want to flex your bison and help build this monster.
30 *
31 * - RPC has a quite featureful error handling mechanism; basically none of this is
32 * implemented right now. We also have deficiencies on the compiler side, where
33 * wine's __TRY / __EXCEPT / __FINALLY macros are not even used for RpcTryExcept & co,
34 * due to syntactic differences! (we can fix it with widl by using __TRY)
35 *
36 * - There are several different memory allocation schemes for MSRPC.
37 * I don't even understand what they all are yet, much less have them
38 * properly implemented. Surely we are supposed to be doing something with
39 * the user-provided allocation/deallocation functions, but so far,
40 * I don't think we are doing this...
41 *
42 * - MSRPC provides impersonation capabilities which currently are not possible
43 * to implement in wine. At the very least we should implement the authorization
44 * API's & gracefully ignore the irrelevant stuff (to an extent we already do).
45 *
46 * - Some transports are not yet implemented. The existing transport implementations
47 * are incomplete and may be bug-infested.
48 *
49 * - The various transports that we do support ought to be supported in a more
50 * object-oriented manner, as in DCE's RPC implementation, instead of cluttering
51 * up the code with conditionals like we do now.
52 *
53 * - Data marshalling: So far, only the beginnings of a full implementation
54 * exist in wine. NDR protocol itself is documented, but the MS API's to
55 * convert data-types in memory into NDR are not. This is challenging work,
56 * and has supposedly been "at the top of Greg's queue" for several months now.
57 *
58 * - ORPC is RPC for OLE; once we have a working RPC framework, we can
59 * use it to implement out-of-process OLE client/server communications.
60 * ATM there is maybe a disconnect between the marshalling in the OLE DLLs
61 * and the marshalling going on here [TODO: well, is there or not?]
62 *
63 * - In-source API Documentation, at least for those functions which we have
64 * implemented, but preferably for everything we can document, would be nice,
65 * since some of this stuff is quite obscure.
66 *
67 * - Name services... [TODO: what about them]
68 *
69 * - Protocol Towers: Totally unimplemented.... I think.
70 *
71 * - Context Handle Rundown: whatever that is.
72 *
73 * - Nested RPC's: Totally unimplemented.
74 *
75 * - Statistics: we are supposed to be keeping various counters. we aren't.
76 *
77 * - Async RPC: Unimplemented.
78 *
79 * - XML/http RPC: Somewhere there's an XML fiend that wants to do this! Betcha
80 * we could use these as a transport for RPC's across computers without a
81 * permissions and/or licensing crisis.
82 *
83 * - The NT "ports" API, aka LPC. Greg claims this is on his radar. Might (or
84 * might not) enable users to get some kind of meaningful result out of
85 * NT-based native rpcrt4's. Commonly-used transport for self-to-self RPC's.
86 *
87 * - ...? More stuff I haven't thought of. If you think of more RPC todo's
88 * drop me an e-mail <gmturner007@ameritech.net> or send a patch to the
89 * wine-patches mailing list.
90 */
91
92 #include "config.h"
93
94 #include <stdarg.h>
95 #include <stdio.h>
96 #include <stdlib.h>
97 #include <string.h>
98
99 #include "windef.h"
100 #include "winerror.h"
101 #include "winbase.h"
102 #include "winuser.h"
103 #include "iptypes.h"
104 #include "iphlpapi.h"
105 #include "wine/unicode.h"
106 #include "rpc.h"
107
108 #include "ole2.h"
109 #include "rpcndr.h"
110 #include "rpcproxy.h"
111
112 #include "rpc_binding.h"
113 #include "rpcss_np_client.h"
114
115 #include "wine/debug.h"
116
117 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
118
119 static UUID uuid_nil;
120 static HANDLE master_mutex;
121
122 HANDLE RPCRT4_GetMasterMutex(void)
123 {
124 return master_mutex;
125 }
126
127 static CRITICAL_SECTION uuid_cs;
128 static CRITICAL_SECTION_DEBUG critsect_debug =
129 {
130 0, 0, &uuid_cs,
131 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
132 0, 0, { 0, (DWORD)(__FILE__ ": uuid_cs") }
133 };
134 static CRITICAL_SECTION uuid_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
135
136 /***********************************************************************
137 * DllMain
138 *
139 * PARAMS
140 * hinstDLL [I] handle to the DLL's instance
141 * fdwReason [I]
142 * lpvReserved [I] reserved, must be NULL
143 *
144 * RETURNS
145 * Success: TRUE
146 * Failure: FALSE
147 */
148
149 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
150 {
151 switch (fdwReason) {
152 case DLL_PROCESS_ATTACH:
153 DisableThreadLibraryCalls(hinstDLL);
154 master_mutex = CreateMutexA( NULL, FALSE, RPCSS_MASTER_MUTEX_NAME);
155 break;
156
157 case DLL_PROCESS_DETACH:
158 CloseHandle(master_mutex);
159 master_mutex = NULL;
160 break;
161 }
162
163 return TRUE;
164 }
165
166 /*************************************************************************
167 * RpcStringFreeA [RPCRT4.@]
168 *
169 * Frees a character string allocated by the RPC run-time library.
170 *
171 * RETURNS
172 *
173 * S_OK if successful.
174 */
175 RPC_STATUS WINAPI RpcStringFreeA(unsigned char** String)
176 {
177 HeapFree( GetProcessHeap(), 0, *String);
178
179 return RPC_S_OK;
180 }
181
182 /*************************************************************************
183 * RpcStringFreeW [RPCRT4.@]
184 *
185 * Frees a character string allocated by the RPC run-time library.
186 *
187 * RETURNS
188 *
189 * S_OK if successful.
190 */
191 RPC_STATUS WINAPI RpcStringFreeW(unsigned short** String)
192 {
193 HeapFree( GetProcessHeap(), 0, *String);
194
195 return RPC_S_OK;
196 }
197
198 /*************************************************************************
199 * RpcRaiseException [RPCRT4.@]
200 *
201 * Raises an exception.
202 */
203 void WINAPI RpcRaiseException(RPC_STATUS exception)
204 {
205 /* FIXME: translate exception? */
206 RaiseException(exception, 0, 0, NULL);
207 }
208
209 /*************************************************************************
210 * UuidCompare [RPCRT4.@]
211 *
212 * PARAMS
213 * UUID *Uuid1 [I] Uuid to compare
214 * UUID *Uuid2 [I] Uuid to compare
215 * RPC_STATUS *Status [O] returns RPC_S_OK
216 *
217 * RETURNS
218 * -1 if Uuid1 is less than Uuid2
219 * 0 if Uuid1 and Uuid2 are equal
220 * 1 if Uuid1 is greater than Uuid2
221 */
222 int WINAPI UuidCompare(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
223 {
224 int i;
225
226 TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
227
228 *Status = RPC_S_OK;
229
230 if (!Uuid1) Uuid1 = &uuid_nil;
231 if (!Uuid2) Uuid2 = &uuid_nil;
232
233 if (Uuid1 == Uuid2) return 0;
234
235 if (Uuid1->Data1 != Uuid2->Data1)
236 return Uuid1->Data1 < Uuid2->Data1 ? -1 : 1;
237
238 if (Uuid1->Data2 != Uuid2->Data2)
239 return Uuid1->Data2 < Uuid2->Data2 ? -1 : 1;
240
241 if (Uuid1->Data3 != Uuid2->Data3)
242 return Uuid1->Data3 < Uuid2->Data3 ? -1 : 1;
243
244 for (i = 0; i < 8; i++) {
245 if (Uuid1->Data4[i] < Uuid2->Data4[i])
246 return -1;
247 if (Uuid1->Data4[i] > Uuid2->Data4[i])
248 return 1;
249 }
250
251 return 0;
252 }
253
254 /*************************************************************************
255 * UuidEqual [RPCRT4.@]
256 *
257 * PARAMS
258 * UUID *Uuid1 [I] Uuid to compare
259 * UUID *Uuid2 [I] Uuid to compare
260 * RPC_STATUS *Status [O] returns RPC_S_OK
261 *
262 * RETURNS
263 * TRUE/FALSE
264 */
265 int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
266 {
267 TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
268 return !UuidCompare(Uuid1, Uuid2, Status);
269 }
270
271 /*************************************************************************
272 * UuidIsNil [RPCRT4.@]
273 *
274 * PARAMS
275 * UUID *Uuid [I] Uuid to compare
276 * RPC_STATUS *Status [O] retuns RPC_S_OK
277 *
278 * RETURNS
279 * TRUE/FALSE
280 */
281 int WINAPI UuidIsNil(UUID *Uuid, RPC_STATUS *Status)
282 {
283 TRACE("(%s)\n", debugstr_guid(Uuid));
284 if (!Uuid) return TRUE;
285 return !UuidCompare(Uuid, &uuid_nil, Status);
286 }
287
288 /*************************************************************************
289 * UuidCreateNil [RPCRT4.@]
290 *
291 * PARAMS
292 * UUID *Uuid [O] returns a nil UUID
293 *
294 * RETURNS
295 * RPC_S_OK
296 */
297 RPC_STATUS WINAPI UuidCreateNil(UUID *Uuid)
298 {
299 *Uuid = uuid_nil;
300 return RPC_S_OK;
301 }
302
303 /* Number of 100ns ticks per clock tick. To be safe, assume that the clock
304 resolution is at least 1000 * 100 * (1/1000000) = 1/10 of a second */
305 #define TICKS_PER_CLOCK_TICK 1000
306 #define SECSPERDAY 86400
307 #define TICKSPERSEC 10000000
308 /* UUID system time starts at October 15, 1582 */
309 #define SECS_15_OCT_1582_TO_1601 ((17 + 30 + 31 + 365 * 18 + 5) * SECSPERDAY)
310 #define TICKS_15_OCT_1582_TO_1601 ((ULONGLONG)SECS_15_OCT_1582_TO_1601 * TICKSPERSEC)
311
312 static void RPC_UuidGetSystemTime(ULONGLONG *time)
313 {
314 FILETIME ft;
315
316 GetSystemTimeAsFileTime(&ft);
317
318 *time = ((ULONGLONG)ft.dwHighDateTime << 32) | ft.dwLowDateTime;
319 *time += TICKS_15_OCT_1582_TO_1601;
320 }
321
322 typedef DWORD WINAPI (*LPGETADAPTERSINFO)(PIP_ADAPTER_INFO pAdapterInfo, PULONG pOutBufLen);
323
324 /* Assume that a hardware address is at least 6 bytes long */
325 #define ADDRESS_BYTES_NEEDED 6
326
327 static RPC_STATUS RPC_UuidGetNodeAddress(BYTE *address)
328 {
329 int i;
330 DWORD status = RPC_S_OK;
331
332 ULONG buflen = sizeof(IP_ADAPTER_INFO);
333 PIP_ADAPTER_INFO adapter = HeapAlloc(GetProcessHeap(), 0, buflen);
334 HANDLE hIpHlpApi;
335 LPGETADAPTERSINFO pGetAdaptersInfo;
336
337 hIpHlpApi = LoadLibrary("iphlpapi.dll");
338 if (hIpHlpApi)
339 {
340 pGetAdaptersInfo = (LPGETADAPTERSINFO)GetProcAddress(hIpHlpApi, "GetAdaptersInfo");
341 if (pGetAdaptersInfo)
342 {
343 if (pGetAdaptersInfo(adapter, &buflen) == ERROR_BUFFER_OVERFLOW) {
344 HeapFree(GetProcessHeap(), 0, adapter);
345 adapter = HeapAlloc(GetProcessHeap(), 0, buflen);
346 }
347
348 if (pGetAdaptersInfo(adapter, &buflen) == NO_ERROR) {
349 for (i = 0; i < ADDRESS_BYTES_NEEDED; i++) {
350 address[i] = adapter->Address[i];
351 }
352 }
353 else
354 {
355 goto local;
356 }
357 }
358
359 /* Free the Library */
360 FreeLibrary(hIpHlpApi);
361 goto exit;
362 }
363
364 local:
365 /* We can't get a hardware address, just use random numbers.
366 Set the multicast bit to prevent conflicts with real cards. */
367 for (i = 0; i < ADDRESS_BYTES_NEEDED; i++) {
368 address[i] = rand() & 0xff;
369 }
370 address[0] |= 0x01;
371 status = RPC_S_UUID_LOCAL_ONLY;
372
373 exit:
374 HeapFree(GetProcessHeap(), 0, adapter);
375 return status;
376 }
377
378 /*************************************************************************
379 * UuidCreate [RPCRT4.@]
380 *
381 * Creates a 128bit UUID.
382 *
383 * RETURNS
384 *
385 * RPC_S_OK if successful.
386 * RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
387 *
388 * FIXME: No compensation for changes across reloading
389 * this dll or across reboots (e.g. clock going
390 * backwards and swapped network cards). The RFC
391 * suggests using NVRAM for storing persistent
392 * values.
393 */
394 RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
395 {
396 static int initialised, count;
397
398 ULONGLONG time;
399 static ULONGLONG timelast;
400 static WORD sequence;
401
402 static DWORD status;
403 static BYTE address[MAX_ADAPTER_ADDRESS_LENGTH];
404
405 EnterCriticalSection(&uuid_cs);
406
407 if (!initialised) {
408 RPC_UuidGetSystemTime(&timelast);
409 count = TICKS_PER_CLOCK_TICK;
410
411 sequence = ((rand() & 0xff) << 8) + (rand() & 0xff);
412 sequence &= 0x1fff;
413
414 status = RPC_UuidGetNodeAddress(address);
415 initialised = 1;
416 }
417
418 /* Generate time element of the UUID. Account for going faster
419 than our clock as well as the clock going backwards. */
420 while (1) {
421 RPC_UuidGetSystemTime(&time);
422 if (time > timelast) {
423 count = 0;
424 break;
425 }
426 if (time < timelast) {
427 sequence = (sequence + 1) & 0x1fff;
428 count = 0;
429 break;
430 }
431 if (count < TICKS_PER_CLOCK_TICK) {
432 count++;
433 break;
434 }
435 }
436
437 timelast = time;
438 time += count;
439
440 /* Pack the information into the UUID structure. */
441
442 Uuid->Data1 = (unsigned long)(time & 0xffffffff);
443 Uuid->Data2 = (unsigned short)((time >> 32) & 0xffff);
444 Uuid->Data3 = (unsigned short)((time >> 48) & 0x0fff);
445
446 /* This is a version 1 UUID */
447 Uuid->Data3 |= (1 << 12);
448
449 Uuid->Data4[0] = sequence & 0xff;
450 Uuid->Data4[1] = (sequence & 0x3f00) >> 8;
451 Uuid->Data4[1] |= 0x80;
452
453 Uuid->Data4[2] = address[0];
454 Uuid->Data4[3] = address[1];
455 Uuid->Data4[4] = address[2];
456 Uuid->Data4[5] = address[3];
457 Uuid->Data4[6] = address[4];
458 Uuid->Data4[7] = address[5];
459
460 LeaveCriticalSection(&uuid_cs);
461
462 TRACE("%s\n", debugstr_guid(Uuid));
463
464 return status;
465 }
466
467 /*************************************************************************
468 * UuidCreateSequential [RPCRT4.@]
469 *
470 * Creates a 128bit UUID.
471 *
472 * RETURNS
473 *
474 * RPC_S_OK if successful.
475 * RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
476 *
477 */
478 RPC_STATUS WINAPI UuidCreateSequential(UUID *Uuid)
479 {
480 return UuidCreate(Uuid);
481 }
482
483
484 /*************************************************************************
485 * UuidHash [RPCRT4.@]
486 *
487 * Generates a hash value for a given UUID
488 *
489 * Code based on FreeDCE implementation
490 *
491 */
492 unsigned short WINAPI UuidHash(UUID *uuid, RPC_STATUS *Status)
493 {
494 BYTE *data = (BYTE*)uuid;
495 short c0 = 0, c1 = 0, x, y;
496 unsigned int i;
497
498 if (!uuid) data = (BYTE*)(uuid = &uuid_nil);
499
500 TRACE("(%s)\n", debugstr_guid(uuid));
501
502 for (i=0; i<sizeof(UUID); i++) {
503 c0 += data[i];
504 c1 += c0;
505 }
506
507 x = -c1 % 255;
508 if (x < 0) x += 255;
509
510 y = (c1 - c0) % 255;
511 if (y < 0) y += 255;
512
513 *Status = RPC_S_OK;
514 return y*256 + x;
515 }
516
517 /*************************************************************************
518 * UuidToStringA [RPCRT4.@]
519 *
520 * Converts a UUID to a string.
521 *
522 * UUID format is 8 hex digits, followed by a hyphen then three groups of
523 * 4 hex digits each followed by a hyphen and then 12 hex digits
524 *
525 * RETURNS
526 *
527 * S_OK if successful.
528 * S_OUT_OF_MEMORY if unsucessful.
529 */
530 RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, unsigned char** StringUuid)
531 {
532 *StringUuid = HeapAlloc( GetProcessHeap(), 0, sizeof(char) * 37);
533
534 if(!(*StringUuid))
535 return RPC_S_OUT_OF_MEMORY;
536
537 if (!Uuid) Uuid = &uuid_nil;
538
539 sprintf(*StringUuid, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
540 Uuid->Data1, Uuid->Data2, Uuid->Data3,
541 Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
542 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
543 Uuid->Data4[6], Uuid->Data4[7] );
544
545 return RPC_S_OK;
546 }
547
548 /*************************************************************************
549 * UuidToStringW [RPCRT4.@]
550 *
551 * Converts a UUID to a string.
552 *
553 * S_OK if successful.
554 * S_OUT_OF_MEMORY if unsucessful.
555 */
556 RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, unsigned short** StringUuid)
557 {
558 char buf[37];
559
560 if (!Uuid) Uuid = &uuid_nil;
561
562 sprintf(buf, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
563 Uuid->Data1, Uuid->Data2, Uuid->Data3,
564 Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
565 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
566 Uuid->Data4[6], Uuid->Data4[7] );
567
568 *StringUuid = RPCRT4_strdupAtoW(buf);
569
570 if(!(*StringUuid))
571 return RPC_S_OUT_OF_MEMORY;
572
573 return RPC_S_OK;
574 }
575
576 static const BYTE hex2bin[] =
577 {
578 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */
579 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */
580 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */
581 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */
582 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */
583 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */
584 0,10,11,12,13,14,15 /* 0x60 */
585 };
586
587 /***********************************************************************
588 * UuidFromStringA (RPCRT4.@)
589 */
590 RPC_STATUS WINAPI UuidFromStringA(unsigned char* str, UUID *uuid)
591 {
592 BYTE *s = (BYTE *)str;
593 int i;
594
595 if (!s) return UuidCreateNil( uuid );
596
597 if (strlen(s) != 36) return RPC_S_INVALID_STRING_UUID;
598
599 if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
600 return RPC_S_INVALID_STRING_UUID;
601
602 for (i=0; i<36; i++)
603 {
604 if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
605 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
606 }
607
608 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
609
610 uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
611 hex2bin[s[4]] << 12 | hex2bin[s[5]] << 8 | hex2bin[s[6]] << 4 | hex2bin[s[7]]);
612 uuid->Data2 = hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
613 uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
614
615 /* these are just sequential bytes */
616 uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
617 uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
618 uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
619 uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
620 uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
621 uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
622 uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
623 uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
624 return RPC_S_OK;
625 }
626
627
628 /***********************************************************************
629 * UuidFromStringW (RPCRT4.@)
630 */
631 RPC_STATUS WINAPI UuidFromStringW(unsigned short* s, UUID *uuid)
632 {
633 int i;
634
635 if (!s) return UuidCreateNil( uuid );
636
637 if (strlenW(s) != 36) return RPC_S_INVALID_STRING_UUID;
638
639 if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
640 return RPC_S_INVALID_STRING_UUID;
641
642 for (i=0; i<36; i++)
643 {
644 if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
645 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
646 }
647
648 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
649
650 uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
651 hex2bin[s[4]] << 12 | hex2bin[s[5]] << 8 | hex2bin[s[6]] << 4 | hex2bin[s[7]]);
652 uuid->Data2 = hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
653 uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
654
655 /* these are just sequential bytes */
656 uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
657 uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
658 uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
659 uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
660 uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
661 uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
662 uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
663 uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
664 return RPC_S_OK;
665 }
666
667 /***********************************************************************
668 * DllRegisterServer (RPCRT4.@)
669 */
670
671 HRESULT WINAPI RPCRT4_DllRegisterServer( void )
672 {
673 FIXME( "(): stub\n" );
674 return S_OK;
675 }
676
677 BOOL RPCRT4_StartRPCSS(void)
678 {
679 PROCESS_INFORMATION pi;
680 STARTUPINFOA si;
681 static char cmd[6];
682 BOOL rslt;
683
684 ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
685 ZeroMemory(&si, sizeof(STARTUPINFOA));
686 si.cb = sizeof(STARTUPINFOA);
687
688 /* apparently it's not OK to use a constant string below */
689 CopyMemory(cmd, "rpcss", 6);
690
691 /* FIXME: will this do the right thing when run as a test? */
692 rslt = CreateProcessA(
693 NULL, /* executable */
694 cmd, /* command line */
695 NULL, /* process security attributes */
696 NULL, /* primary thread security attributes */
697 FALSE, /* inherit handles */
698 0, /* creation flags */
699 NULL, /* use parent's environment */
700 NULL, /* use parent's current directory */
701 &si, /* STARTUPINFO pointer */
702 &pi /* PROCESS_INFORMATION */
703 );
704
705 if (rslt) {
706 CloseHandle(pi.hProcess);
707 CloseHandle(pi.hThread);
708 }
709
710 return rslt;
711 }
712
713 /***********************************************************************
714 * RPCRT4_RPCSSOnDemandCall (internal)
715 *
716 * Attempts to send a message to the RPCSS process
717 * on the local machine, invoking it if necessary.
718 * For remote RPCSS calls, use.... your imagination.
719 *
720 * PARAMS
721 * msg [I] pointer to the RPCSS message
722 * vardata_payload [I] pointer vardata portion of the RPCSS message
723 * reply [O] pointer to reply structure
724 *
725 * RETURNS
726 * TRUE if successful
727 * FALSE otherwise
728 */
729 BOOL RPCRT4_RPCSSOnDemandCall(PRPCSS_NP_MESSAGE msg, char *vardata_payload, PRPCSS_NP_REPLY reply)
730 {
731 HANDLE client_handle;
732 int i, j = 0;
733
734 TRACE("(msg == %p, vardata_payload == %p, reply == %p)\n", msg, vardata_payload, reply);
735
736 client_handle = RPCRT4_RpcssNPConnect();
737
738 while (!client_handle) {
739 /* start the RPCSS process */
740 if (!RPCRT4_StartRPCSS()) {
741 ERR("Unable to start RPCSS process.\n");
742 return FALSE;
743 }
744 /* wait for a connection (w/ periodic polling) */
745 for (i = 0; i < 60; i++) {
746 Sleep(200);
747 client_handle = RPCRT4_RpcssNPConnect();
748 if (client_handle) break;
749 }
750 /* we are only willing to try twice */
751 if (j++ >= 1) break;
752 }
753
754 if (!client_handle) {
755 /* no dice! */
756 ERR("Unable to connect to RPCSS process!\n");
757 SetLastError(RPC_E_SERVER_DIED_DNE);
758 return FALSE;
759 }
760
761 /* great, we're connected. now send the message */
762 if (!RPCRT4_SendReceiveNPMsg(client_handle, msg, vardata_payload, reply)) {
763 ERR("Something is amiss: RPC_SendReceive failed.\n");
764 return FALSE;
765 }
766
767 return TRUE;
768 }
769
770 #define MAX_RPC_ERROR_TEXT 256
771
772 /******************************************************************************
773 * DceErrorInqTextW (rpcrt4.@)
774 *
775 * Notes
776 * 1. On passing a NULL pointer the code does bomb out.
777 * 2. The size of the required buffer is not defined in the documentation.
778 * It appears to be 256.
779 * 3. The function is defined to return RPC_S_INVALID_ARG but I don't know
780 * of any value for which it does.
781 * 4. The MSDN documentation currently declares that the second argument is
782 * unsigned char *, even for the W version. I don't believe it.
783 */
784 RPC_STATUS RPC_ENTRY DceErrorInqTextW (RPC_STATUS e, unsigned short *buffer)
785 {
786 DWORD count;
787 count = FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
788 FORMAT_MESSAGE_IGNORE_INSERTS,
789 NULL, e, 0, buffer, MAX_RPC_ERROR_TEXT, NULL);
790 if (!count)
791 {
792 count = FormatMessageW (FORMAT_MESSAGE_FROM_SYSTEM |
793 FORMAT_MESSAGE_IGNORE_INSERTS,
794 NULL, RPC_S_NOT_RPC_ERROR, 0, buffer, MAX_RPC_ERROR_TEXT, NULL);
795 if (!count)
796 {
797 ERR ("Failed to translate error");
798 return RPC_S_INVALID_ARG;
799 }
800 }
801 return RPC_S_OK;
802 }
803
804 /******************************************************************************
805 * DceErrorInqTextA (rpcrt4.@)
806 */
807 RPC_STATUS RPC_ENTRY DceErrorInqTextA (RPC_STATUS e, unsigned char *buffer)
808 {
809 RPC_STATUS status;
810 WCHAR bufferW [MAX_RPC_ERROR_TEXT];
811 if ((status = DceErrorInqTextW (e, bufferW)) == RPC_S_OK)
812 {
813 if (!WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_RPC_ERROR_TEXT,
814 NULL, NULL))
815 {
816 ERR ("Failed to translate error");
817 status = RPC_S_INVALID_ARG;
818 }
819 }
820 return status;
821 }