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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * WINE RPC TODO's (and a few TODONT's)
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.
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)
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...
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).
46 * - Some transports are not yet implemented. The existing transport implementations
47 * are incomplete and may be bug-infested.
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.
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.
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 DLL's
61 * and the marshalling going on here [TODO: well, is there or not?]
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.
67 * - Name services... [TODO: what about them]
69 * - Protocol Towers: Totally unimplemented.... I think.
71 * - Context Handle Rundown: whatever that is.
73 * - Nested RPC's: Totally unimplemented.
75 * - Statistics: we are supposed to be keeping various counters. we aren't.
77 * - Async RPC: Unimplemented.
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.
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.
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.
99 #ifdef HAVE_SYS_TIME_H
100 # include <sys/time.h>
107 #include "winerror.h"
110 #include "wine/unicode.h"
115 #include "rpcproxy.h"
117 #ifdef HAVE_SYS_FILE_H
118 # include <sys/file.h>
120 #ifdef HAVE_SYS_IOCTL_H
121 # include <sys/ioctl.h>
123 #ifdef HAVE_SYS_SOCKET_H
124 # include <sys/socket.h>
126 #ifdef HAVE_SYS_SOCKIO_H
127 # include <sys/sockio.h>
132 #ifdef HAVE_NETINET_IN_H
133 # include <netinet/in.h>
136 #include "rpc_binding.h"
137 #include "rpcss_np_client.h"
139 #include "wine/debug.h"
141 WINE_DEFAULT_DEBUG_CHANNEL(ole);
143 static UUID uuid_nil;
144 static HANDLE master_mutex;
146 HANDLE RPCRT4_GetMasterMutex(void)
151 /***********************************************************************
155 * hinstDLL [I] handle to the DLL's instance
157 * lpvReserved [I] reserved, must be NULL
164 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
167 case DLL_PROCESS_ATTACH:
168 DisableThreadLibraryCalls(hinstDLL);
169 master_mutex = CreateMutexA( NULL, FALSE, RPCSS_MASTER_MUTEX_NAME);
171 ERR("Failed to create master mutex\n");
174 case DLL_PROCESS_DETACH:
175 CloseHandle(master_mutex);
183 /*************************************************************************
184 * RpcStringFreeA [RPCRT4.@]
186 * Frees a character string allocated by the RPC run-time library.
190 * S_OK if successful.
192 RPC_STATUS WINAPI RpcStringFreeA(unsigned char** String)
194 HeapFree( GetProcessHeap(), 0, *String);
199 /*************************************************************************
200 * RpcStringFreeW [RPCRT4.@]
202 * Frees a character string allocated by the RPC run-time library.
206 * S_OK if successful.
208 RPC_STATUS WINAPI RpcStringFreeW(unsigned short** String)
210 HeapFree( GetProcessHeap(), 0, *String);
215 /*************************************************************************
216 * RpcRaiseException [RPCRT4.@]
218 * Raises an exception.
220 void WINAPI RpcRaiseException(RPC_STATUS exception)
222 /* FIXME: translate exception? */
223 RaiseException(exception, 0, 0, NULL);
226 /*************************************************************************
227 * UuidCompare [RPCRT4.@]
229 * (an educated-guess implementation)
232 * UUID *Uuid1 [I] Uuid to compare
233 * UUID *Uuid2 [I] Uuid to compare
234 * RPC_STATUS *Status [O] returns RPC_S_OK
237 * -1 if Uuid1 is less than Uuid2
238 * 0 if Uuid1 and Uuid2 are equal
239 * 1 if Uuid1 is greater than Uuid2
241 int WINAPI UuidCompare(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
243 TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
245 if (!Uuid1) Uuid1 = &uuid_nil;
246 if (!Uuid2) Uuid2 = &uuid_nil;
247 if (Uuid1 == Uuid2) return 0;
248 return memcmp(Uuid1, Uuid2, sizeof(UUID));
251 /*************************************************************************
252 * UuidEqual [RPCRT4.@]
255 * UUID *Uuid1 [I] Uuid to compare
256 * UUID *Uuid2 [I] Uuid to compare
257 * RPC_STATUS *Status [O] returns RPC_S_OK
262 int WINAPI UuidEqual(UUID *Uuid1, UUID *Uuid2, RPC_STATUS *Status)
264 TRACE("(%s,%s)\n", debugstr_guid(Uuid1), debugstr_guid(Uuid2));
265 return !UuidCompare(Uuid1, Uuid2, Status);
268 /*************************************************************************
269 * UuidIsNil [RPCRT4.@]
272 * UUID *Uuid [I] Uuid to compare
273 * RPC_STATUS *Status [O] retuns RPC_S_OK
278 int WINAPI UuidIsNil(UUID *uuid, RPC_STATUS *Status)
280 TRACE("(%s)\n", debugstr_guid(uuid));
282 if (!uuid) return TRUE;
283 return !memcmp(uuid, &uuid_nil, sizeof(UUID));
286 /*************************************************************************
287 * UuidCreateNil [RPCRT4.@]
290 * UUID *Uuid [O] returns a nil UUID
295 RPC_STATUS WINAPI UuidCreateNil(UUID *Uuid)
301 /*************************************************************************
302 * UuidCreate [RPCRT4.@]
304 * Creates a 128bit UUID.
305 * Implemented according the DCE specification for UUID generation.
306 * Code is based upon uuid library in e2fsprogs by Theodore Ts'o.
307 * Copyright (C) 1996, 1997 Theodore Ts'o.
311 * S_OK if successful.
313 RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
315 static char has_init = 0;
316 static unsigned char a[6];
317 static int adjustment = 0;
318 static struct timeval last = {0, 0};
319 static WORD clock_seq;
321 unsigned long long clock_reg;
322 DWORD clock_high, clock_low;
323 WORD temp_clock_seq, temp_clock_mid, temp_clock_hi_and_version;
326 struct ifreq ifr, *ifrp;
332 /* Have we already tried to get the MAC address? */
335 /* BSD 4.4 defines the size of an ifreq to be
336 * max(sizeof(ifreq), sizeof(ifreq.ifr_name)+ifreq.ifr_addr.sa_len
337 * However, under earlier systems, sa_len isn't present, so
338 * the size is just sizeof(struct ifreq)
340 #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
342 # define max(a,b) ((a) > (b) ? (a) : (b))
344 # define ifreq_size(i) max(sizeof(struct ifreq),\
345 sizeof((i).ifr_name)+(i).ifr_addr.sa_len)
347 # define ifreq_size(i) sizeof(struct ifreq)
348 # endif /* HAVE_STRUCT_SOCKADDR_SA_LEN */
350 sd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
352 /* if we can't open a socket, just use random numbers */
353 /* set the multicast bit to prevent conflicts with real cards */
354 a[0] = (rand() & 0xff) | 0x80;
355 a[1] = rand() & 0xff;
356 a[2] = rand() & 0xff;
357 a[3] = rand() & 0xff;
358 a[4] = rand() & 0xff;
359 a[5] = rand() & 0xff;
361 memset(buf, 0, sizeof(buf));
362 ifc.ifc_len = sizeof(buf);
364 /* get the ifconf interface */
365 if (ioctl (sd, SIOCGIFCONF, (char *)&ifc) < 0) {
367 /* no ifconf, so just use random numbers */
368 /* set the multicast bit to prevent conflicts with real cards */
369 a[0] = (rand() & 0xff) | 0x80;
370 a[1] = rand() & 0xff;
371 a[2] = rand() & 0xff;
372 a[3] = rand() & 0xff;
373 a[4] = rand() & 0xff;
374 a[5] = rand() & 0xff;
376 /* loop through the interfaces, looking for a valid one */
378 for (i = 0; i < n; i+= ifreq_size(ifr) ) {
379 ifrp = (struct ifreq *)((char *) ifc.ifc_buf+i);
380 strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ);
381 /* try to get the address for this interface */
382 # ifdef SIOCGIFHWADDR
383 if (ioctl(sd, SIOCGIFHWADDR, &ifr) < 0)
385 memcpy(a, (unsigned char *)&ifr.ifr_hwaddr.sa_data, 6);
388 if (ioctl(sd, SIOCGENADDR, &ifr) < 0)
390 memcpy(a, (unsigned char *) ifr.ifr_enaddr, 6);
392 /* XXX we don't have a way of getting the hardware address */
396 # endif /* SIOCGENADDR */
397 # endif /* SIOCGIFHWADDR */
398 /* make sure it's not blank */
399 if (!a[0] && !a[1] && !a[2] && !a[3] && !a[4] && !a[5])
404 /* if we didn't find a valid address, make a random one */
405 /* once again, set multicast bit to avoid conflicts */
406 a[0] = (rand() & 0xff) | 0x80;
407 a[1] = rand() & 0xff;
408 a[2] = rand() & 0xff;
409 a[3] = rand() & 0xff;
410 a[4] = rand() & 0xff;
411 a[5] = rand() & 0xff;
418 /* no networking info, so generate a random address */
419 a[0] = (rand() & 0xff) | 0x80;
420 a[1] = rand() & 0xff;
421 a[2] = rand() & 0xff;
422 a[3] = rand() & 0xff;
423 a[4] = rand() & 0xff;
424 a[5] = rand() & 0xff;
425 #endif /* HAVE_NET_IF_H */
429 /* generate time element of GUID */
431 /* Assume that the gettimeofday() has microsecond granularity */
432 #define MAX_ADJUSTMENT 10
435 gettimeofday(&tv, 0);
436 if ((last.tv_sec == 0) && (last.tv_usec == 0)) {
437 clock_seq = ((rand() & 0xff) << 8) + (rand() & 0xff);
442 if ((tv.tv_sec < last.tv_sec) ||
443 ((tv.tv_sec == last.tv_sec) &&
444 (tv.tv_usec < last.tv_usec))) {
445 clock_seq = (clock_seq+1) & 0x1FFF;
447 } else if ((tv.tv_sec == last.tv_sec) &&
448 (tv.tv_usec == last.tv_usec)) {
449 if (adjustment >= MAX_ADJUSTMENT)
455 clock_reg = tv.tv_usec*10 + adjustment;
456 clock_reg += ((unsigned long long) tv.tv_sec)*10000000;
457 clock_reg += (((unsigned long long) 0x01B21DD2) << 32) + 0x13814000;
459 clock_high = clock_reg >> 32;
460 clock_low = clock_reg;
461 temp_clock_seq = clock_seq | 0x8000;
462 temp_clock_mid = (WORD)clock_high;
463 temp_clock_hi_and_version = (clock_high >> 16) | 0x1000;
465 /* pack the information into the GUID structure */
467 ((unsigned char*)&Uuid->Data1)[3] = (unsigned char)clock_low;
469 ((unsigned char*)&Uuid->Data1)[2] = (unsigned char)clock_low;
471 ((unsigned char*)&Uuid->Data1)[1] = (unsigned char)clock_low;
473 ((unsigned char*)&Uuid->Data1)[0] = (unsigned char)clock_low;
475 ((unsigned char*)&Uuid->Data2)[1] = (unsigned char)temp_clock_mid;
476 temp_clock_mid >>= 8;
477 ((unsigned char*)&Uuid->Data2)[0] = (unsigned char)temp_clock_mid;
479 ((unsigned char*)&Uuid->Data3)[1] = (unsigned char)temp_clock_hi_and_version;
480 temp_clock_hi_and_version >>= 8;
481 ((unsigned char*)&Uuid->Data3)[0] = (unsigned char)temp_clock_hi_and_version;
483 ((unsigned char*)Uuid->Data4)[1] = (unsigned char)temp_clock_seq;
484 temp_clock_seq >>= 8;
485 ((unsigned char*)Uuid->Data4)[0] = (unsigned char)temp_clock_seq;
487 ((unsigned char*)Uuid->Data4)[2] = a[0];
488 ((unsigned char*)Uuid->Data4)[3] = a[1];
489 ((unsigned char*)Uuid->Data4)[4] = a[2];
490 ((unsigned char*)Uuid->Data4)[5] = a[3];
491 ((unsigned char*)Uuid->Data4)[6] = a[4];
492 ((unsigned char*)Uuid->Data4)[7] = a[5];
494 TRACE("%s\n", debugstr_guid(Uuid));
500 /*************************************************************************
501 * UuidCreateSequential [RPCRT4.@]
503 * Creates a 128bit UUID by calling UuidCreate.
504 * New API in Win 2000
506 RPC_STATUS WINAPI UuidCreateSequential(UUID *Uuid)
508 return UuidCreate (Uuid);
512 /*************************************************************************
513 * UuidHash [RPCRT4.@]
515 * Generates a hash value for a given UUID
517 * Code based on FreeDCE implementation
520 unsigned short WINAPI UuidHash(UUID *uuid, RPC_STATUS *Status)
522 BYTE *data = (BYTE*)uuid;
523 short c0 = 0, c1 = 0, x, y;
526 if (!uuid) data = (BYTE*)(uuid = &uuid_nil);
528 TRACE("(%s)\n", debugstr_guid(uuid));
530 for (i=0; i<sizeof(UUID); i++) {
545 /*************************************************************************
546 * UuidToStringA [RPCRT4.@]
548 * Converts a UUID to a string.
550 * UUID format is 8 hex digits, followed by a hyphen then three groups of
551 * 4 hex digits each followed by a hyphen and then 12 hex digits
555 * S_OK if successful.
556 * S_OUT_OF_MEMORY if unsucessful.
558 RPC_STATUS WINAPI UuidToStringA(UUID *Uuid, unsigned char** StringUuid)
560 *StringUuid = HeapAlloc( GetProcessHeap(), 0, sizeof(char) * 37);
563 return RPC_S_OUT_OF_MEMORY;
565 if (!Uuid) Uuid = &uuid_nil;
567 sprintf(*StringUuid, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
568 Uuid->Data1, Uuid->Data2, Uuid->Data3,
569 Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
570 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
571 Uuid->Data4[6], Uuid->Data4[7] );
576 /*************************************************************************
577 * UuidToStringW [RPCRT4.@]
579 * Converts a UUID to a string.
581 * S_OK if successful.
582 * S_OUT_OF_MEMORY if unsucessful.
584 RPC_STATUS WINAPI UuidToStringW(UUID *Uuid, unsigned short** StringUuid)
588 if (!Uuid) Uuid = &uuid_nil;
590 sprintf(buf, "%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
591 Uuid->Data1, Uuid->Data2, Uuid->Data3,
592 Uuid->Data4[0], Uuid->Data4[1], Uuid->Data4[2],
593 Uuid->Data4[3], Uuid->Data4[4], Uuid->Data4[5],
594 Uuid->Data4[6], Uuid->Data4[7] );
596 *StringUuid = RPCRT4_strdupAtoW(buf);
599 return RPC_S_OUT_OF_MEMORY;
604 static const BYTE hex2bin[] =
606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x00 */
607 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x10 */
608 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x20 */
609 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, /* 0x30 */
610 0,10,11,12,13,14,15,0,0,0,0,0,0,0,0,0, /* 0x40 */
611 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x50 */
612 0,10,11,12,13,14,15 /* 0x60 */
615 /***********************************************************************
616 * UuidFromStringA (RPCRT4.@)
618 RPC_STATUS WINAPI UuidFromStringA(unsigned char* str, UUID *uuid)
620 BYTE *s = (BYTE *)str;
623 if (!s) return UuidCreateNil( uuid );
625 if (strlen(s) != 36) return RPC_S_INVALID_STRING_UUID;
627 if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
628 return RPC_S_INVALID_STRING_UUID;
632 if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
633 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
636 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
638 uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
639 hex2bin[s[4]] << 12 | hex2bin[s[5]] << 8 | hex2bin[s[6]] << 4 | hex2bin[s[7]]);
640 uuid->Data2 = hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
641 uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
643 /* these are just sequential bytes */
644 uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
645 uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
646 uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
647 uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
648 uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
649 uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
650 uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
651 uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
656 /***********************************************************************
657 * UuidFromStringW (RPCRT4.@)
659 RPC_STATUS WINAPI UuidFromStringW(unsigned short* s, UUID *uuid)
663 if (!s) return UuidCreateNil( uuid );
665 if (strlenW(s) != 36) return RPC_S_INVALID_STRING_UUID;
667 if ((s[8]!='-') || (s[13]!='-') || (s[18]!='-') || (s[23]!='-'))
668 return RPC_S_INVALID_STRING_UUID;
672 if ((i == 8)||(i == 13)||(i == 18)||(i == 23)) continue;
673 if (s[i] > 'f' || (!hex2bin[s[i]] && s[i] != '0')) return RPC_S_INVALID_STRING_UUID;
676 /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
678 uuid->Data1 = (hex2bin[s[0]] << 28 | hex2bin[s[1]] << 24 | hex2bin[s[2]] << 20 | hex2bin[s[3]] << 16 |
679 hex2bin[s[4]] << 12 | hex2bin[s[5]] << 8 | hex2bin[s[6]] << 4 | hex2bin[s[7]]);
680 uuid->Data2 = hex2bin[s[9]] << 12 | hex2bin[s[10]] << 8 | hex2bin[s[11]] << 4 | hex2bin[s[12]];
681 uuid->Data3 = hex2bin[s[14]] << 12 | hex2bin[s[15]] << 8 | hex2bin[s[16]] << 4 | hex2bin[s[17]];
683 /* these are just sequential bytes */
684 uuid->Data4[0] = hex2bin[s[19]] << 4 | hex2bin[s[20]];
685 uuid->Data4[1] = hex2bin[s[21]] << 4 | hex2bin[s[22]];
686 uuid->Data4[2] = hex2bin[s[24]] << 4 | hex2bin[s[25]];
687 uuid->Data4[3] = hex2bin[s[26]] << 4 | hex2bin[s[27]];
688 uuid->Data4[4] = hex2bin[s[28]] << 4 | hex2bin[s[29]];
689 uuid->Data4[5] = hex2bin[s[30]] << 4 | hex2bin[s[31]];
690 uuid->Data4[6] = hex2bin[s[32]] << 4 | hex2bin[s[33]];
691 uuid->Data4[7] = hex2bin[s[34]] << 4 | hex2bin[s[35]];
695 /***********************************************************************
696 * DllRegisterServer (RPCRT4.@)
699 HRESULT WINAPI RPCRT4_DllRegisterServer( void )
701 FIXME( "(): stub\n" );
705 BOOL RPCRT4_StartRPCSS(void)
707 PROCESS_INFORMATION pi;
712 ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
713 ZeroMemory(&si, sizeof(STARTUPINFOA));
714 si.cb = sizeof(STARTUPINFOA);
716 /* apparently it's not OK to use a constant string below */
717 CopyMemory(cmd, "rpcss", 6);
719 /* FIXME: will this do the right thing when run as a test? */
720 rslt = CreateProcessA(
721 NULL, /* executable */
722 cmd, /* command line */
723 NULL, /* process security attributes */
724 NULL, /* primary thread security attributes */
725 FALSE, /* inherit handles */
726 0, /* creation flags */
727 NULL, /* use parent's environment */
728 NULL, /* use parent's current directory */
729 &si, /* STARTUPINFO pointer */
730 &pi /* PROCESS_INFORMATION */
734 CloseHandle(pi.hProcess);
735 CloseHandle(pi.hThread);
741 /***********************************************************************
742 * RPCRT4_RPCSSOnDemandCall (internal)
744 * Attempts to send a message to the RPCSS process
745 * on the local machine, invoking it if necessary.
746 * For remote RPCSS calls, use.... your imagination.
749 * msg [I] pointer to the RPCSS message
750 * vardata_payload [I] pointer vardata portion of the RPCSS message
751 * reply [O] pointer to reply structure
757 BOOL RPCRT4_RPCSSOnDemandCall(PRPCSS_NP_MESSAGE msg, char *vardata_payload, PRPCSS_NP_REPLY reply)
759 HANDLE client_handle;
762 TRACE("(msg == %p, vardata_payload == %p, reply == %p)\n", msg, vardata_payload, reply);
764 client_handle = RPCRT4_RpcssNPConnect();
766 while (!client_handle) {
767 /* start the RPCSS process */
768 if (!RPCRT4_StartRPCSS()) {
769 ERR("Unable to start RPCSS process.\n");
772 /* wait for a connection (w/ periodic polling) */
773 for (i = 0; i < 60; i++) {
775 client_handle = RPCRT4_RpcssNPConnect();
776 if (client_handle) break;
778 /* we are only willing to try twice */
782 if (!client_handle) {
784 ERR("Unable to connect to RPCSS process!\n");
785 SetLastError(RPC_E_SERVER_DIED_DNE);
789 /* great, we're connected. now send the message */
790 if (!RPCRT4_SendReceiveNPMsg(client_handle, msg, vardata_payload, reply)) {
791 ERR("Something is amiss: RPC_SendReceive failed.\n");