localipc-win.cpp@ 105155

Last change on this file since 105155 was 99758, checked in by vboxsync, 20 months ago
IPRT: Make doxygen 1.9.6 happy. Mostly removing duplicate docs (iprt is documented in the header files). bugref:10442
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.6 KB

Line
1	/* $Id: localipc-win.cpp 99758 2023-05-11 21:37:59Z vboxsync $ */
2	/** @file
3	* IPRT - Local IPC, Windows Implementation Using Named Pipes.
4	*
5	* @note This code only works on W2K because of the dependency on
6	* ConvertStringSecurityDescriptorToSecurityDescriptor.
7	*/
8
9	/*
10	* Copyright (C) 2008-2023 Oracle and/or its affiliates.
11	*
12	* This file is part of VirtualBox base platform packages, as
13	* available from https://www.virtualbox.org.
14	*
15	* This program is free software; you can redistribute it and/or
16	* modify it under the terms of the GNU General Public License
17	* as published by the Free Software Foundation, in version 3 of the
18	* License.
19	*
20	* This program is distributed in the hope that it will be useful, but
21	* WITHOUT ANY WARRANTY; without even the implied warranty of
22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23	* General Public License for more details.
24	*
25	* You should have received a copy of the GNU General Public License
26	* along with this program; if not, see <https://www.gnu.org/licenses>.
27	*
28	* The contents of this file may alternatively be used under the terms
29	* of the Common Development and Distribution License Version 1.0
30	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
31	* in the VirtualBox distribution, in which case the provisions of the
32	* CDDL are applicable instead of those of the GPL.
33	*
34	* You may elect to license modified versions of this file under the
35	* terms and conditions of either the GPL or the CDDL or both.
36	*
37	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
38	*/
39
40
41	/*********************************************************************************************************************************
42	* Header Files *
43	*********************************************************************************************************************************/
44	#define LOG_GROUP RTLOGGROUP_LOCALIPC
45	#include <iprt/nt/nt-and-windows.h> /* Need NtCancelIoFile and a few Rtl functions. */
46	#include <sddl.h>
47	#include <aclapi.h>
48
49	#include "internal/iprt.h"
50	#include <iprt/localipc.h>
51
52	#include <iprt/asm.h>
53	#include <iprt/assert.h>
54	#include <iprt/critsect.h>
55	#include <iprt/ctype.h>
56	#include <iprt/err.h>
57	#include <iprt/ldr.h>
58	#include <iprt/log.h>
59	#include <iprt/mem.h>
60	#include <iprt/param.h>
61	#include <iprt/string.h>
62	#include <iprt/thread.h>
63	#include <iprt/time.h>
64	#include <iprt/utf16.h>
65
66	#include "internal/magics.h"
67	#include "internal-r3-win.h"
68
69
70
71	/*********************************************************************************************************************************
72	* Defined Constants And Macros *
73	*********************************************************************************************************************************/
74	/** Pipe prefix string. */
75	#define RTLOCALIPC_WIN_PREFIX L"\\\\.\\pipe\\IPRT-"
76
77
78	/*********************************************************************************************************************************
79	* Structures and Typedefs *
80	*********************************************************************************************************************************/
81	/**
82	* Local IPC service instance, Windows.
83	*/
84	typedef struct RTLOCALIPCSERVERINT
85	{
86	/** The magic (RTLOCALIPCSERVER_MAGIC). */
87	uint32_t u32Magic;
88	/** The creation flags. */
89	uint32_t fFlags;
90	/** Critical section protecting the structure. */
91	RTCRITSECT CritSect;
92	/** The number of references to the instance.
93	* @remarks The reference counting isn't race proof. */
94	uint32_t volatile cRefs;
95	/** Indicates that there is a pending cancel request. */
96	bool volatile fCancelled;
97	/** The named pipe handle. */
98	HANDLE hNmPipe;
99	/** The handle to the event object we're using for overlapped I/O. */
100	HANDLE hEvent;
101	/** The overlapped I/O structure. */
102	OVERLAPPED OverlappedIO;
103	/** The full pipe name (variable length). */
104	RTUTF16 wszName[1];
105	} RTLOCALIPCSERVERINT;
106	/** Pointer to a local IPC server instance (Windows). */
107	typedef RTLOCALIPCSERVERINT *PRTLOCALIPCSERVERINT;
108
109
110	/**
111	* Local IPC session instance, Windows.
112	*
113	* This is a named pipe and we should probably merge the pipe code with this to
114	* save work and code duplication.
115	*/
116	typedef struct RTLOCALIPCSESSIONINT
117	{
118	/** The magic (RTLOCALIPCSESSION_MAGIC). */
119	uint32_t u32Magic;
120	/** Critical section protecting the structure. */
121	RTCRITSECT CritSect;
122	/** The number of references to the instance.
123	* @remarks The reference counting isn't race proof. */
124	uint32_t volatile cRefs;
125	/** Set if the zero byte read that the poll code using is pending. */
126	bool fZeroByteRead;
127	/** Indicates that there is a pending cancel request. */
128	bool volatile fCancelled;
129	/** Set if this is the server side, clear if the client. */
130	bool fServerSide;
131	/** The named pipe handle. */
132	HANDLE hNmPipe;
133	struct
134	{
135	RTTHREAD hActiveThread;
136	/** The handle to the event object we're using for overlapped I/O. */
137	HANDLE hEvent;
138	/** The overlapped I/O structure. */
139	OVERLAPPED OverlappedIO;
140	}
141	/** Overlapped reads. */
142	Read,
143	/** Overlapped writes. */
144	Write;
145	#if 0 /* Non-blocking writes are not yet supported. */
146	/** Bounce buffer for writes. */
147	uint8_t *pbBounceBuf;
148	/** Amount of used buffer space. */
149	size_t cbBounceBufUsed;
150	/** Amount of allocated buffer space. */
151	size_t cbBounceBufAlloc;
152	#endif
153	/** Buffer for the zero byte read.
154	* Used in RTLocalIpcSessionWaitForData(). */
155	uint8_t abBuf[8];
156	} RTLOCALIPCSESSIONINT;
157	/** Pointer to a local IPC session instance (Windows). */
158	typedef RTLOCALIPCSESSIONINT *PRTLOCALIPCSESSIONINT;
159
160
161	/*********************************************************************************************************************************
162	* Internal Functions *
163	*********************************************************************************************************************************/
164	static int rtLocalIpcWinCreateSession(PRTLOCALIPCSESSIONINT *ppSession, HANDLE hNmPipeSession);
165
166
167	/**
168	* DACL for block all network access and local users other than the creator/owner.
169	*
170	* ACE format: (ace_type;ace_flags;rights;object_guid;inherit_object_guid;account_sid)
171	*
172	* Note! FILE_GENERIC_WRITE (SDDL_FILE_WRITE) is evil here because it includes
173	* the FILE_CREATE_PIPE_INSTANCE(=FILE_APPEND_DATA) flag. Thus the hardcoded
174	* value 0x0012019b in the client ACE. The server-side still needs
175	* setting FILE_CREATE_PIPE_INSTANCE although.
176	* It expands to:
177	* 0x00000001 - FILE_READ_DATA
178	* 0x00000008 - FILE_READ_EA
179	* 0x00000080 - FILE_READ_ATTRIBUTES
180	* 0x00020000 - READ_CONTROL
181	* 0x00100000 - SYNCHRONIZE
182	* 0x00000002 - FILE_WRITE_DATA
183	* 0x00000010 - FILE_WRITE_EA
184	* 0x00000100 - FILE_WRITE_ATTRIBUTES
185	* = 0x0012019b (client)
186	* + (only for server):
187	* 0x00000004 - FILE_CREATE_PIPE_INSTANCE
188	* = 0x0012019f
189	*
190	* @todo Triple check this!
191	* @todo EVERYONE -> AUTHENTICATED USERS or something more appropriate?
192	* @todo Have trouble allowing the owner FILE_CREATE_PIPE_INSTANCE access, so for now I'm hacking
193	* it just to get progress - the service runs as local system.
194	* The CREATOR OWNER and PERSONAL SELF works (the former is only involved in inheriting
195	* it seems, which is why it won't work. The latter I've no idea about. Perhaps the solution
196	* is to go the annoying route of OpenProcessToken, QueryTokenInformation,
197	* ConvertSidToStringSid and then use the result... Suggestions are very welcome
198	*/
199	#define RTLOCALIPC_WIN_SDDL_BASE \
200	SDDL_DACL SDDL_DELIMINATOR \
201	SDDL_ACE_BEGIN SDDL_ACCESS_DENIED L";;" SDDL_GENERIC_ALL L";;;" SDDL_NETWORK SDDL_ACE_END \
202	SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" SDDL_FILE_ALL L";;;" SDDL_LOCAL_SYSTEM SDDL_ACE_END
203	#define RTLOCALIPC_WIN_SDDL_SERVER \
204	RTLOCALIPC_WIN_SDDL_BASE \
205	SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" L"0x0012019f" L";;;" SDDL_EVERYONE SDDL_ACE_END
206	#define RTLOCALIPC_WIN_SDDL_CLIENT \
207	RTLOCALIPC_WIN_SDDL_BASE \
208	SDDL_ACE_BEGIN SDDL_ACCESS_ALLOWED L";;" L"0x0012019b" L";;;" SDDL_EVERYONE SDDL_ACE_END
209	static NTSTATUS rtLocalIpcBuildDacl(PACL pDacl, bool fServer)
210	{
211	static SID_IDENTIFIER_AUTHORITY s_NtAuth = SECURITY_NT_AUTHORITY;
212	static SID_IDENTIFIER_AUTHORITY s_WorldAuth = SECURITY_WORLD_SID_AUTHORITY;
213	union
214	{
215	SID Sid;
216	uint8_t abPadding[SECURITY_MAX_SID_SIZE];
217	} Network, LocalSystem, Everyone;
218
219
220	/* 1. SDDL_ACCESS_DENIED L";;" SDDL_GENERIC_ALL L";;;" SDDL_NETWORK */
221	NTSTATUS rcNt = RtlInitializeSid(&Network.Sid, &s_NtAuth, 1);
222	AssertReturn(NT_SUCCESS(rcNt), rcNt);
223	*RtlSubAuthoritySid(&Network.Sid, 0) = SECURITY_NETWORK_RID;
224
225	rcNt = RtlAddAccessDeniedAce(pDacl, ACL_REVISION, GENERIC_ALL, &Network.Sid);
226	AssertReturn(NT_SUCCESS(rcNt), rcNt);
227
228	/* 2. SDDL_ACCESS_ALLOWED L";;" SDDL_FILE_ALL L";;;" SDDL_LOCAL_SYSTEM */
229	rcNt = RtlInitializeSid(&LocalSystem.Sid, &s_NtAuth, 1);
230	AssertReturn(NT_SUCCESS(rcNt), rcNt);
231	*RtlSubAuthoritySid(&LocalSystem.Sid, 0) = SECURITY_LOCAL_SYSTEM_RID;
232
233	rcNt = RtlAddAccessAllowedAce(pDacl, ACL_REVISION, FILE_ALL_ACCESS, &Network.Sid);
234	AssertReturn(NT_SUCCESS(rcNt), rcNt);
235
236
237	/* 3. server: SDDL_ACCESS_ALLOWED L";;" L"0x0012019f" L";;;" SDDL_EVERYONE
238	client: SDDL_ACCESS_ALLOWED L";;" L"0x0012019b" L";;;" SDDL_EVERYONE */
239	rcNt = RtlInitializeSid(&Everyone.Sid, &s_NtAuth, 1);
240	AssertReturn(NT_SUCCESS(rcNt), rcNt);
241	*RtlSubAuthoritySid(&Everyone.Sid, 0) = SECURITY_WORLD_RID;
242
243	DWORD const fAccess = FILE_READ_DATA /* 0x00000001 */
244	\| FILE_WRITE_DATA /* 0x00000002 */
245	\| FILE_CREATE_PIPE_INSTANCE * fServer /* 0x00000004 */
246	\| FILE_READ_EA /* 0x00000008 */
247	\| FILE_WRITE_EA /* 0x00000010 */
248	\| FILE_READ_ATTRIBUTES /* 0x00000080 */
249	\| FILE_WRITE_ATTRIBUTES /* 0x00000100 */
250	\| READ_CONTROL /* 0x00020000 */
251	\| SYNCHRONIZE; /* 0x00100000*/
252	Assert(fAccess == (fServer ? 0x0012019fU : 0x0012019bU));
253
254	rcNt = RtlAddAccessAllowedAce(pDacl, ACL_REVISION, fAccess, &Network.Sid);
255	AssertReturn(NT_SUCCESS(rcNt), rcNt);
256
257	return true;
258	}
259
260
261	/**
262	* Builds and allocates the security descriptor required for securing the local pipe.
263	*
264	* @return IPRT status code.
265	* @param ppDesc Where to store the allocated security descriptor on success.
266	* Must be free'd using LocalFree().
267	* @param fServer Whether it's for a server or client instance.
268	*/
269	static int rtLocalIpcServerWinAllocSecurityDescriptor(PSECURITY_DESCRIPTOR *ppDesc, bool fServer)
270	{
271	int rc;
272	PSECURITY_DESCRIPTOR pSecDesc = NULL;
273
274	#if 0
275	/*
276	* Resolve the API the first time around.
277	*/
278	static bool volatile s_fResolvedApis = false;
279	/** advapi32.dll API ConvertStringSecurityDescriptorToSecurityDescriptorW. */
280	static decltype(ConvertStringSecurityDescriptorToSecurityDescriptorW) *s_pfnSSDLToSecDescW = NULL;
281
282	if (!s_fResolvedApis)
283	{
284	s_pfnSSDLToSecDescW
285	= (decltype(s_pfnSSDLToSecDescW))RTLdrGetSystemSymbol("advapi32.dll",
286	"ConvertStringSecurityDescriptorToSecurityDescriptorW");
287	ASMCompilerBarrier();
288	s_fResolvedApis = true;
289	}
290	if (s_pfnSSDLToSecDescW)
291	{
292	/*
293	* We'll create a security descriptor from a SDDL that denies
294	* access to network clients (this is local IPC after all), it
295	* makes some further restrictions to prevent non-authenticated
296	* users from screwing around.
297	*/
298	PCRTUTF16 pwszSDDL = fServer ? RTLOCALIPC_WIN_SDDL_SERVER : RTLOCALIPC_WIN_SDDL_CLIENT;
299	ULONG cbSecDesc = 0;
300	SetLastError(0);
301	if (s_pfnSSDLToSecDescW(pwszSDDL, SDDL_REVISION_1, &pSecDesc, &cbSecDesc))
302	{
303	DWORD dwErr = GetLastError(); RT_NOREF(dwErr);
304	AssertPtr(pSecDesc);
305	*ppDesc = pSecDesc;
306	return VINF_SUCCESS;
307	}
308
309	rc = RTErrConvertFromWin32(GetLastError());
310	}
311	else
312	#endif
313	{
314	/*
315	* Manually construct the descriptor.
316	*
317	* This is a bit crude. The 8KB is probably 50+ times more than what we need.
318	*/
319	uint32_t const cbAlloc = SECURITY_DESCRIPTOR_MIN_LENGTH * 2 + _8K;
320	pSecDesc = LocalAlloc(LMEM_FIXED, cbAlloc);
321	if (!pSecDesc)
322	return VERR_NO_MEMORY;
323	RT_BZERO(pSecDesc, cbAlloc);
324
325	uint32_t const cbDacl = cbAlloc - SECURITY_DESCRIPTOR_MIN_LENGTH * 2;
326	PACL const pDacl = (PACL)((uint8_t )pSecDesc + SECURITY_DESCRIPTOR_MIN_LENGTH 2);
327
328	if ( InitializeSecurityDescriptor(pSecDesc, SECURITY_DESCRIPTOR_REVISION)
329	&& InitializeAcl(pDacl, cbDacl, ACL_REVISION))
330	{
331	if (rtLocalIpcBuildDacl(pDacl, fServer))
332	{
333	*ppDesc = pSecDesc;
334	return VINF_SUCCESS;
335	}
336	rc = VERR_GENERAL_FAILURE;
337	}
338	else
339	rc = RTErrConvertFromWin32(GetLastError());
340	LocalFree(pSecDesc);
341	}
342	return rc;
343	}
344
345
346	/**
347	* Creates a named pipe instance.
348	*
349	* This is used by both RTLocalIpcServerCreate and RTLocalIpcServerListen.
350	*
351	* @return IPRT status code.
352	* @param phNmPipe Where to store the named pipe handle on success.
353	* This will be set to INVALID_HANDLE_VALUE on failure.
354	* @param pwszPipeName The named pipe name, full, UTF-16 encoded.
355	* @param fFirst Set on the first call (from RTLocalIpcServerCreate),
356	* otherwise clear. Governs the
357	* FILE_FLAG_FIRST_PIPE_INSTANCE flag.
358	*/
359	static int rtLocalIpcServerWinCreatePipeInstance(PHANDLE phNmPipe, PCRTUTF16 pwszPipeName, bool fFirst)
360	{
361	*phNmPipe = INVALID_HANDLE_VALUE;
362
363	/*
364	* Create a security descriptor blocking access to the pipe via network.
365	*/
366	PSECURITY_DESCRIPTOR pSecDesc;
367	int rc = rtLocalIpcServerWinAllocSecurityDescriptor(&pSecDesc, fFirst /* Server? */);
368	if (RT_SUCCESS(rc))
369	{
370	#if 0
371	{ /* Just for checking the security descriptor out in the debugger (!sd <addr> doesn't work): */
372	DWORD dwRet = LookupSecurityDescriptorPartsW(NULL, NULL, NULL, NULL, NULL, NULL, pSecDesc);
373	__debugbreak(); RT_NOREF(dwRet);
374
375	PTRUSTEE_W pOwner = NULL;
376	PTRUSTEE_W pGroup = NULL;
377	ULONG cAces = 0;
378	PEXPLICIT_ACCESS_W paAces = NULL;
379	ULONG cAuditEntries = 0;
380	PEXPLICIT_ACCESS_W paAuditEntries = NULL;
381	dwRet = LookupSecurityDescriptorPartsW(&pOwner, NULL, NULL, NULL, NULL, NULL, pSecDesc);
382	dwRet = LookupSecurityDescriptorPartsW(NULL, &pGroup, NULL, NULL, NULL, NULL, pSecDesc);
383	dwRet = LookupSecurityDescriptorPartsW(NULL, NULL, &cAces, &paAces, NULL, NULL, pSecDesc);
384	dwRet = LookupSecurityDescriptorPartsW(NULL, NULL, NULL, NULL, &cAuditEntries, &paAuditEntries, pSecDesc);
385	__debugbreak(); RT_NOREF(dwRet);
386	}
387	#endif
388
389	/*
390	* Now, create the pipe.
391	*/
392	SECURITY_ATTRIBUTES SecAttrs;
393	SecAttrs.nLength = sizeof(SECURITY_ATTRIBUTES);
394	SecAttrs.lpSecurityDescriptor = pSecDesc;
395	SecAttrs.bInheritHandle = FALSE;
396
397	DWORD fOpenMode = PIPE_ACCESS_DUPLEX
398	\| PIPE_WAIT
399	\| FILE_FLAG_OVERLAPPED;
400	if ( fFirst
401	&& ( g_enmWinVer >= kRTWinOSType_XP
402	\|\| ( g_enmWinVer == kRTWinOSType_2K
403	&& g_WinOsInfoEx.wServicePackMajor >= 2) ) )
404	fOpenMode \|= FILE_FLAG_FIRST_PIPE_INSTANCE; /* Introduced with W2K SP2 */
405
406	HANDLE hNmPipe = CreateNamedPipeW(pwszPipeName, /* lpName */
407	fOpenMode, /* dwOpenMode */
408	PIPE_TYPE_BYTE, /* dwPipeMode */
409	PIPE_UNLIMITED_INSTANCES, /* nMaxInstances */
410	PAGE_SIZE, /* nOutBufferSize (advisory) */
411	PAGE_SIZE, /* nInBufferSize (ditto) */
412	301000, / nDefaultTimeOut = 30 sec */
413	&SecAttrs); /* lpSecurityAttributes */
414	if (hNmPipe != INVALID_HANDLE_VALUE)
415	{
416	#if 0 /* For checking access control stuff in windbg (doesn't work): */
417	PSECURITY_DESCRIPTOR pSecDesc2 = NULL;
418	PACL pDacl = NULL;
419	DWORD dwRet;
420	dwRet = GetSecurityInfo(hNmPipe, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, &pDacl, NULL, &pSecDesc2);
421	PACL pSacl = NULL;
422	dwRet = GetSecurityInfo(hNmPipe, SE_FILE_OBJECT, SACL_SECURITY_INFORMATION, NULL, NULL, NULL, &pSacl, &pSecDesc2);
423	dwRet = GetSecurityInfo(hNmPipe, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION \| SACL_SECURITY_INFORMATION, NULL, NULL, &pDacl, &pSacl, &pSecDesc2);
424	PSID pSidOwner = NULL;
425	dwRet = GetSecurityInfo(hNmPipe, SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION, &pSidOwner, NULL, NULL, NULL, &pSecDesc2);
426	PSID pSidGroup = NULL;
427	dwRet = GetSecurityInfo(hNmPipe, SE_FILE_OBJECT, OWNER_SECURITY_INFORMATION, NULL, &pSidGroup, NULL, NULL, &pSecDesc2);
428	__debugbreak();
429	RT_NOREF(dwRet);
430	#endif
431	*phNmPipe = hNmPipe;
432	rc = VINF_SUCCESS;
433	}
434	else
435	rc = RTErrConvertFromWin32(GetLastError());
436	LocalFree(pSecDesc);
437	}
438	return rc;
439	}
440
441
442	/**
443	* Validates the user specified name.
444	*
445	* @returns IPRT status code.
446	* @param pszName The name to validate.
447	* @param pcwcFullName Where to return the UTF-16 length of the full name.
448	* @param fNative Whether it's a native name or a portable name.
449	*/
450	static int rtLocalIpcWinValidateName(const char pszName, size_t pcwcFullName, bool fNative)
451	{
452	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
453	AssertReturn(*pszName, VERR_INVALID_NAME);
454
455	if (!fNative)
456	{
457	size_t cwcName = RT_ELEMENTS(RTLOCALIPC_WIN_PREFIX) - 1;
458	for (;;)
459	{
460	char ch = *pszName++;
461	if (!ch)
462	break;
463	AssertReturn(!RT_C_IS_CNTRL(ch), VERR_INVALID_NAME);
464	AssertReturn((unsigned)ch < 0x80, VERR_INVALID_NAME);
465	AssertReturn(ch != '\\', VERR_INVALID_NAME);
466	AssertReturn(ch != '/', VERR_INVALID_NAME);
467	cwcName++;
468	}
469	*pcwcFullName = cwcName;
470	}
471	else
472	{
473	int rc = RTStrCalcUtf16LenEx(pszName, RTSTR_MAX, pcwcFullName);
474	AssertRCReturn(rc, rc);
475	}
476
477	return VINF_SUCCESS;
478	}
479
480
481	/**
482	* Constructs the full pipe name as UTF-16.
483	*
484	* @returns IPRT status code.
485	* @param pszName The user supplied name. ASSUMES reasonable length
486	* for now, so no long path prefixing needed.
487	* @param pwszFullName The output buffer.
488	* @param cwcFullName The output buffer size excluding the terminator.
489	* @param fNative Whether the user supplied name is a native or
490	* portable one.
491	*/
492	static int rtLocalIpcWinConstructName(const char *pszName, PRTUTF16 pwszFullName, size_t cwcFullName, bool fNative)
493	{
494	if (!fNative)
495	{
496	static RTUTF16 const s_wszPrefix[] = RTLOCALIPC_WIN_PREFIX;
497	Assert(cwcFullName * sizeof(RTUTF16) > sizeof(s_wszPrefix));
498	memcpy(pwszFullName, s_wszPrefix, sizeof(s_wszPrefix));
499	cwcFullName -= RT_ELEMENTS(s_wszPrefix) - 1;
500	pwszFullName += RT_ELEMENTS(s_wszPrefix) - 1;
501	}
502	return RTStrToUtf16Ex(pszName, RTSTR_MAX, &pwszFullName, cwcFullName + 1, NULL);
503	}
504
505
506	RTDECL(int) RTLocalIpcServerCreate(PRTLOCALIPCSERVER phServer, const char *pszName, uint32_t fFlags)
507	{
508	/*
509	* Validate parameters.
510	*/
511	AssertPtrReturn(phServer, VERR_INVALID_POINTER);
512	*phServer = NIL_RTLOCALIPCSERVER;
513	AssertReturn(!(fFlags & ~RTLOCALIPC_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
514	size_t cwcFullName;
515	int rc = rtLocalIpcWinValidateName(pszName, &cwcFullName, RT_BOOL(fFlags & RTLOCALIPC_FLAGS_NATIVE_NAME));
516	if (RT_SUCCESS(rc))
517	{
518	/*
519	* Allocate and initialize the instance data.
520	*/
521	size_t cbThis = RT_UOFFSETOF_DYN(RTLOCALIPCSERVERINT, wszName[cwcFullName + 1]);
522	PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)RTMemAllocVar(cbThis);
523	AssertReturn(pThis, VERR_NO_MEMORY);
524
525	pThis->u32Magic = RTLOCALIPCSERVER_MAGIC;
526	pThis->cRefs = 1; /* the one we return */
527	pThis->fCancelled = false;
528
529	rc = rtLocalIpcWinConstructName(pszName, pThis->wszName, cwcFullName, RT_BOOL(fFlags & RTLOCALIPC_FLAGS_NATIVE_NAME));
530	if (RT_SUCCESS(rc))
531	{
532	rc = RTCritSectInit(&pThis->CritSect);
533	if (RT_SUCCESS(rc))
534	{
535	pThis->hEvent = CreateEvent(NULL /lpEventAttributes/, TRUE /bManualReset/,
536	FALSE /bInitialState/, NULL /lpName/);
537	if (pThis->hEvent != NULL)
538	{
539	RT_ZERO(pThis->OverlappedIO);
540	pThis->OverlappedIO.Internal = STATUS_PENDING;
541	pThis->OverlappedIO.hEvent = pThis->hEvent;
542
543	rc = rtLocalIpcServerWinCreatePipeInstance(&pThis->hNmPipe, pThis->wszName, true /* fFirst */);
544	if (RT_SUCCESS(rc))
545	{
546	*phServer = pThis;
547	return VINF_SUCCESS;
548	}
549
550	BOOL fRc = CloseHandle(pThis->hEvent);
551	AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
552	}
553	else
554	rc = RTErrConvertFromWin32(GetLastError());
555
556	int rc2 = RTCritSectDelete(&pThis->CritSect);
557	AssertRC(rc2);
558	}
559	}
560	RTMemFree(pThis);
561	}
562	return rc;
563	}
564
565
566	/**
567	* Retains a reference to the server instance.
568	*
569	* @param pThis The server instance.
570	*/
571	DECLINLINE(void) rtLocalIpcServerRetain(PRTLOCALIPCSERVERINT pThis)
572	{
573	uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
574	Assert(cRefs < UINT32_MAX / 2 && cRefs); NOREF(cRefs);
575	}
576
577
578	/**
579	* Call when the reference count reaches 0.
580	*
581	* Caller owns the critsect.
582	*
583	* @returns VINF_OBJECT_DESTROYED
584	* @param pThis The instance to destroy.
585	*/
586	DECL_NO_INLINE(static, int) rtLocalIpcServerWinDestroy(PRTLOCALIPCSERVERINT pThis)
587	{
588	Assert(pThis->u32Magic == ~RTLOCALIPCSERVER_MAGIC);
589	pThis->u32Magic = ~RTLOCALIPCSERVER_MAGIC;
590
591	BOOL fRc = CloseHandle(pThis->hNmPipe);
592	AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
593	pThis->hNmPipe = INVALID_HANDLE_VALUE;
594
595	fRc = CloseHandle(pThis->hEvent);
596	AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
597	pThis->hEvent = NULL;
598
599	RTCritSectLeave(&pThis->CritSect);
600	RTCritSectDelete(&pThis->CritSect);
601
602	RTMemFree(pThis);
603	return VINF_OBJECT_DESTROYED;
604	}
605
606
607	/**
608	* Server instance destructor.
609	*
610	* @returns VINF_OBJECT_DESTROYED
611	* @param pThis The server instance.
612	*/
613	DECL_NO_INLINE(static, int) rtLocalIpcServerDtor(PRTLOCALIPCSERVERINT pThis)
614	{
615	RTCritSectEnter(&pThis->CritSect);
616	return rtLocalIpcServerWinDestroy(pThis);
617	}
618
619
620	/**
621	* Releases a reference to the server instance.
622	*
623	* @returns VINF_SUCCESS if only release, VINF_OBJECT_DESTROYED if destroyed.
624	* @param pThis The server instance.
625	*/
626	DECLINLINE(int) rtLocalIpcServerRelease(PRTLOCALIPCSERVERINT pThis)
627	{
628	uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
629	Assert(cRefs < UINT32_MAX / 2);
630	if (!cRefs)
631	return rtLocalIpcServerDtor(pThis);
632	return VINF_SUCCESS;
633	}
634
635
636	/**
637	* Releases a reference to the server instance and leaves the critsect.
638	*
639	* @returns VINF_SUCCESS if only release, VINF_OBJECT_DESTROYED if destroyed.
640	* @param pThis The server instance.
641	*/
642	DECLINLINE(int) rtLocalIpcServerReleaseAndUnlock(PRTLOCALIPCSERVERINT pThis)
643	{
644	uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
645	Assert(cRefs < UINT32_MAX / 2);
646	if (!cRefs)
647	return rtLocalIpcServerWinDestroy(pThis);
648	return RTCritSectLeave(&pThis->CritSect);
649	}
650
651
652
653	RTDECL(int) RTLocalIpcServerDestroy(RTLOCALIPCSERVER hServer)
654	{
655	/*
656	* Validate input.
657	*/
658	if (hServer == NIL_RTLOCALIPCSERVER)
659	return VINF_SUCCESS;
660	PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)hServer;
661	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
662	AssertReturn(pThis->u32Magic == RTLOCALIPCSERVER_MAGIC, VERR_INVALID_HANDLE);
663
664	/*
665	* Cancel any thread currently busy using the server,
666	* leaving the cleanup to it.
667	*/
668	AssertReturn(ASMAtomicCmpXchgU32(&pThis->u32Magic, ~RTLOCALIPCSERVER_MAGIC, RTLOCALIPCSERVER_MAGIC), VERR_WRONG_ORDER);
669
670	RTCritSectEnter(&pThis->CritSect);
671
672	/* Cancel everything. */
673	ASMAtomicUoWriteBool(&pThis->fCancelled, true);
674	if (pThis->cRefs > 1)
675	{
676	BOOL fRc = SetEvent(pThis->hEvent);
677	AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
678	}
679
680	return rtLocalIpcServerReleaseAndUnlock(pThis);
681	}
682
683
684	RTDECL(int) RTLocalIpcServerGrantGroupAccess(RTLOCALIPCSERVER hServer, RTGID gid)
685	{
686	RT_NOREF_PV(hServer); RT_NOREF(gid);
687	return VERR_NOT_SUPPORTED;
688	}
689
690
691	RTDECL(int) RTLocalIpcServerListen(RTLOCALIPCSERVER hServer, PRTLOCALIPCSESSION phClientSession)
692	{
693	/*
694	* Validate input.
695	*/
696	PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)hServer;
697	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
698	AssertReturn(pThis->u32Magic == RTLOCALIPCSERVER_MAGIC, VERR_INVALID_HANDLE);
699	AssertPtrReturn(phClientSession, VERR_INVALID_POINTER);
700
701	/*
702	* Enter the critsect before inspecting the object further.
703	*/
704	int rc = RTCritSectEnter(&pThis->CritSect);
705	AssertRCReturn(rc, rc);
706
707	rtLocalIpcServerRetain(pThis);
708	if (!pThis->fCancelled)
709	{
710	ResetEvent(pThis->hEvent);
711
712	RTCritSectLeave(&pThis->CritSect);
713
714	/*
715	* Try connect a client. We need to use overlapped I/O here because
716	* of the cancellation done by RTLocalIpcServerCancel and RTLocalIpcServerDestroy.
717	*/
718	SetLastError(NO_ERROR);
719	BOOL fRc = ConnectNamedPipe(pThis->hNmPipe, &pThis->OverlappedIO);
720	DWORD dwErr = fRc ? NO_ERROR : GetLastError();
721	if ( !fRc
722	&& dwErr == ERROR_IO_PENDING)
723	{
724	WaitForSingleObject(pThis->hEvent, INFINITE);
725	DWORD dwIgnored;
726	fRc = GetOverlappedResult(pThis->hNmPipe, &pThis->OverlappedIO, &dwIgnored, FALSE /* bWait*/);
727	dwErr = fRc ? NO_ERROR : GetLastError();
728	}
729
730	RTCritSectEnter(&pThis->CritSect);
731	if ( !pThis->fCancelled /* Event signalled but not cancelled? */
732	&& pThis->u32Magic == RTLOCALIPCSERVER_MAGIC)
733	{
734	/*
735	* Still alive, some error or an actual client.
736	*
737	* If it's the latter we'll have to create a new pipe instance that
738	* replaces the current one for the server. The current pipe instance
739	* will be assigned to the client session.
740	*/
741	if ( fRc
742	\|\| dwErr == ERROR_PIPE_CONNECTED)
743	{
744	HANDLE hNmPipe;
745	rc = rtLocalIpcServerWinCreatePipeInstance(&hNmPipe, pThis->wszName, false /* fFirst */);
746	if (RT_SUCCESS(rc))
747	{
748	HANDLE hNmPipeSession = pThis->hNmPipe; /* consumed */
749	pThis->hNmPipe = hNmPipe;
750	rc = rtLocalIpcWinCreateSession(phClientSession, hNmPipeSession);
751	}
752	else
753	{
754	/*
755	* We failed to create a new instance for the server, disconnect
756	* the client and fail. Don't try service the client here.
757	*/
758	fRc = DisconnectNamedPipe(pThis->hNmPipe);
759	AssertMsg(fRc, ("%d\n", GetLastError()));
760	}
761	}
762	else
763	rc = RTErrConvertFromWin32(dwErr);
764	}
765	else
766	{
767	/*
768	* Cancelled.
769	*
770	* Cancel the overlapped io if it didn't complete (must be done
771	* in the this thread) or disconnect the client.
772	*/
773	Assert(pThis->fCancelled);
774	if ( fRc
775	\|\| dwErr == ERROR_PIPE_CONNECTED)
776	fRc = DisconnectNamedPipe(pThis->hNmPipe);
777	else if (dwErr == ERROR_IO_PENDING)
778	{
779	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
780	NTSTATUS rcNt = NtCancelIoFile(pThis->hNmPipe, &Ios);
781	fRc = NT_SUCCESS(rcNt);
782	}
783	else
784	fRc = TRUE;
785	AssertMsg(fRc, ("%d\n", GetLastError()));
786	rc = VERR_CANCELLED;
787	}
788	}
789	else
790	{
791	/pThis->fCancelled = false; - Terrible interface idea. Add API to clear fCancelled if ever required. /
792	rc = VERR_CANCELLED;
793	}
794	rtLocalIpcServerReleaseAndUnlock(pThis);
795	return rc;
796	}
797
798
799	RTDECL(int) RTLocalIpcServerCancel(RTLOCALIPCSERVER hServer)
800	{
801	/*
802	* Validate input.
803	*/
804	PRTLOCALIPCSERVERINT pThis = (PRTLOCALIPCSERVERINT)hServer;
805	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
806	AssertReturn(pThis->u32Magic == RTLOCALIPCSERVER_MAGIC, VERR_INVALID_HANDLE);
807
808	/*
809	* Enter the critical section, then set the cancellation flag
810	* and signal the event (to wake up anyone in/at WaitForSingleObject).
811	*/
812	rtLocalIpcServerRetain(pThis);
813	int rc = RTCritSectEnter(&pThis->CritSect);
814	if (RT_SUCCESS(rc))
815	{
816	ASMAtomicUoWriteBool(&pThis->fCancelled, true);
817
818	BOOL fRc = SetEvent(pThis->hEvent);
819	if (fRc)
820	rc = VINF_SUCCESS;
821	else
822	{
823	DWORD dwErr = GetLastError();
824	AssertMsgFailed(("dwErr=%u\n", dwErr));
825	rc = RTErrConvertFromWin32(dwErr);
826	}
827
828	rtLocalIpcServerReleaseAndUnlock(pThis);
829	}
830	else
831	rtLocalIpcServerRelease(pThis);
832	return rc;
833	}
834
835
836	/**
837	* Create a session instance for a new server client or a client connect.
838	*
839	* @returns IPRT status code.
840	*
841	* @param ppSession Where to store the session handle on success.
842	* @param hNmPipeSession The named pipe handle if server calling,
843	* INVALID_HANDLE_VALUE if client connect. This will
844	* be consumed by this session, meaning on failure to
845	* create the session it will be closed.
846	*/
847	static int rtLocalIpcWinCreateSession(PRTLOCALIPCSESSIONINT *ppSession, HANDLE hNmPipeSession)
848	{
849	AssertPtr(ppSession);
850
851	/*
852	* Allocate and initialize the session instance data.
853	*/
854	int rc;
855	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)RTMemAllocZ(sizeof(*pThis));
856	if (pThis)
857	{
858	pThis->u32Magic = RTLOCALIPCSESSION_MAGIC;
859	pThis->cRefs = 1; /* our ref */
860	pThis->fCancelled = false;
861	pThis->fZeroByteRead = false;
862	pThis->fServerSide = hNmPipeSession != INVALID_HANDLE_VALUE;
863	pThis->hNmPipe = hNmPipeSession;
864	#if 0 /* Non-blocking writes are not yet supported. */
865	pThis->pbBounceBuf = NULL;
866	pThis->cbBounceBufAlloc = 0;
867	pThis->cbBounceBufUsed = 0;
868	#endif
869	rc = RTCritSectInit(&pThis->CritSect);
870	if (RT_SUCCESS(rc))
871	{
872	pThis->Read.hEvent = CreateEvent(NULL /lpEventAttributes/, TRUE /bManualReset/,
873	FALSE /bInitialState/, NULL /lpName/);
874	if (pThis->Read.hEvent != NULL)
875	{
876	pThis->Read.OverlappedIO.Internal = STATUS_PENDING;
877	pThis->Read.OverlappedIO.hEvent = pThis->Read.hEvent;
878	pThis->Read.hActiveThread = NIL_RTTHREAD;
879
880	pThis->Write.hEvent = CreateEvent(NULL /lpEventAttributes/, TRUE /bManualReset/,
881	FALSE /bInitialState/, NULL /lpName/);
882	if (pThis->Write.hEvent != NULL)
883	{
884	pThis->Write.OverlappedIO.Internal = STATUS_PENDING;
885	pThis->Write.OverlappedIO.hEvent = pThis->Write.hEvent;
886	pThis->Write.hActiveThread = NIL_RTTHREAD;
887
888	*ppSession = pThis;
889	return VINF_SUCCESS;
890	}
891
892	CloseHandle(pThis->Read.hEvent);
893	}
894
895	/* bail out */
896	rc = RTErrConvertFromWin32(GetLastError());
897	RTCritSectDelete(&pThis->CritSect);
898	}
899	RTMemFree(pThis);
900	}
901	else
902	rc = VERR_NO_MEMORY;
903
904	if (hNmPipeSession != INVALID_HANDLE_VALUE)
905	{
906	BOOL fRc = CloseHandle(hNmPipeSession);
907	AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
908	}
909	return rc;
910	}
911
912
913	RTDECL(int) RTLocalIpcSessionConnect(PRTLOCALIPCSESSION phSession, const char *pszName, uint32_t fFlags)
914	{
915	/*
916	* Validate input.
917	*/
918	AssertPtrReturn(phSession, VERR_INVALID_POINTER);
919	AssertReturn(!(fFlags & ~RTLOCALIPC_C_FLAGS_VALID_MASK), VERR_INVALID_FLAGS);
920
921	size_t cwcFullName;
922	int rc = rtLocalIpcWinValidateName(pszName, &cwcFullName, RT_BOOL(fFlags & RTLOCALIPC_C_FLAGS_NATIVE_NAME));
923	if (RT_SUCCESS(rc))
924	{
925	/*
926	* Create a session (shared with server client session creation).
927	*/
928	PRTLOCALIPCSESSIONINT pThis;
929	rc = rtLocalIpcWinCreateSession(&pThis, INVALID_HANDLE_VALUE);
930	if (RT_SUCCESS(rc))
931	{
932	/*
933	* Try open the pipe.
934	*/
935	PSECURITY_DESCRIPTOR pSecDesc;
936	rc = rtLocalIpcServerWinAllocSecurityDescriptor(&pSecDesc, false /fServer/);
937	if (RT_SUCCESS(rc))
938	{
939	PRTUTF16 pwszFullName = RTUtf16Alloc((cwcFullName + 1) * sizeof(RTUTF16));
940	if (pwszFullName)
941	rc = rtLocalIpcWinConstructName(pszName, pwszFullName, cwcFullName,
942	RT_BOOL(fFlags & RTLOCALIPC_C_FLAGS_NATIVE_NAME));
943	else
944	rc = VERR_NO_UTF16_MEMORY;
945	if (RT_SUCCESS(rc))
946	{
947	SECURITY_ATTRIBUTES SecAttrs;
948	SecAttrs.nLength = sizeof(SECURITY_ATTRIBUTES);
949	SecAttrs.lpSecurityDescriptor = pSecDesc;
950	SecAttrs.bInheritHandle = FALSE;
951
952	/* The SECURITY_XXX flags are needed in order to prevent the server from impersonating with
953	this thread's security context (supported at least back to NT 3.51). See @bugref{9773}. */
954	HANDLE hPipe = CreateFileW(pwszFullName,
955	GENERIC_READ \| GENERIC_WRITE,
956	0 /no sharing/,
957	&SecAttrs,
958	OPEN_EXISTING,
959	FILE_FLAG_OVERLAPPED \| SECURITY_SQOS_PRESENT \| SECURITY_ANONYMOUS,
960	NULL /no template handle/);
961	if (hPipe != INVALID_HANDLE_VALUE)
962	{
963	pThis->hNmPipe = hPipe;
964
965	LocalFree(pSecDesc);
966	RTUtf16Free(pwszFullName);
967
968	/*
969	* We're done!
970	*/
971	*phSession = pThis;
972	return VINF_SUCCESS;
973	}
974
975	rc = RTErrConvertFromWin32(GetLastError());
976	}
977
978	RTUtf16Free(pwszFullName);
979	LocalFree(pSecDesc);
980	}
981
982	/* destroy the session handle. */
983	CloseHandle(pThis->Read.hEvent);
984	CloseHandle(pThis->Write.hEvent);
985	RTCritSectDelete(&pThis->CritSect);
986
987	RTMemFree(pThis);
988	}
989	}
990	return rc;
991	}
992
993
994	/**
995	* Cancells all pending I/O operations, forcing the methods to return with
996	* VERR_CANCELLED (unless they've got actual data to return).
997	*
998	* Used by RTLocalIpcSessionCancel and RTLocalIpcSessionClose.
999	*
1000	* @returns IPRT status code.
1001	* @param pThis The client session instance.
1002	*/
1003	static int rtLocalIpcWinCancel(PRTLOCALIPCSESSIONINT pThis)
1004	{
1005	ASMAtomicUoWriteBool(&pThis->fCancelled, true);
1006
1007	/*
1008	* Call NtCancelIoFile since this call cancels both read and write
1009	* oriented operations.
1010	*/
1011	if ( pThis->fZeroByteRead
1012	\|\| pThis->Read.hActiveThread != NIL_RTTHREAD
1013	\|\| pThis->Write.hActiveThread != NIL_RTTHREAD)
1014	{
1015	IO_STATUS_BLOCK Ios = RTNT_IO_STATUS_BLOCK_INITIALIZER;
1016	NtCancelIoFile(pThis->hNmPipe, &Ios);
1017	}
1018
1019	/*
1020	* Set both event semaphores.
1021	*/
1022	BOOL fRc = SetEvent(pThis->Read.hEvent);
1023	AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
1024	fRc = SetEvent(pThis->Write.hEvent);
1025	AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
1026
1027	return VINF_SUCCESS;
1028	}
1029
1030
1031	/**
1032	* Retains a reference to the session instance.
1033	*
1034	* @param pThis The client session instance.
1035	*/
1036	DECLINLINE(void) rtLocalIpcSessionRetain(PRTLOCALIPCSESSIONINT pThis)
1037	{
1038	uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
1039	Assert(cRefs < UINT32_MAX / 2 && cRefs); NOREF(cRefs);
1040	}
1041
1042
1043	RTDECL(uint32_t) RTLocalIpcSessionRetain(RTLOCALIPCSESSION hSession)
1044	{
1045	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1046	AssertPtrReturn(pThis, UINT32_MAX);
1047	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, UINT32_MAX);
1048
1049	uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
1050	Assert(cRefs < UINT32_MAX / 2 && cRefs);
1051	return cRefs;
1052	}
1053
1054
1055	/**
1056	* Call when the reference count reaches 0.
1057	*
1058	* Caller owns the critsect.
1059	*
1060	* @returns VINF_OBJECT_DESTROYED
1061	* @param pThis The instance to destroy.
1062	*/
1063	DECL_NO_INLINE(static, int) rtLocalIpcSessionWinDestroy(PRTLOCALIPCSESSIONINT pThis)
1064	{
1065	BOOL fRc = CloseHandle(pThis->hNmPipe);
1066	AssertMsg(fRc, ("%d\n", GetLastError())); NOREF(fRc);
1067	pThis->hNmPipe = INVALID_HANDLE_VALUE;
1068
1069	fRc = CloseHandle(pThis->Write.hEvent);
1070	AssertMsg(fRc, ("%d\n", GetLastError()));
1071	pThis->Write.hEvent = NULL;
1072
1073	fRc = CloseHandle(pThis->Read.hEvent);
1074	AssertMsg(fRc, ("%d\n", GetLastError()));
1075	pThis->Read.hEvent = NULL;
1076
1077	int rc2 = RTCritSectLeave(&pThis->CritSect); AssertRC(rc2);
1078	RTCritSectDelete(&pThis->CritSect);
1079
1080	RTMemFree(pThis);
1081	return VINF_OBJECT_DESTROYED;
1082	}
1083
1084
1085	/**
1086	* Releases a reference to the session instance and unlock it.
1087	*
1088	* @returns VINF_SUCCESS or VINF_OBJECT_DESTROYED as appropriate.
1089	* @param pThis The session instance.
1090	*/
1091	DECLINLINE(int) rtLocalIpcSessionReleaseAndUnlock(PRTLOCALIPCSESSIONINT pThis)
1092	{
1093	uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
1094	Assert(cRefs < UINT32_MAX / 2);
1095	if (!cRefs)
1096	return rtLocalIpcSessionWinDestroy(pThis);
1097
1098	int rc2 = RTCritSectLeave(&pThis->CritSect); AssertRC(rc2);
1099	Log(("rtLocalIpcSessionReleaseAndUnlock: %u refs left\n", cRefs));
1100	return VINF_SUCCESS;
1101	}
1102
1103
1104	RTDECL(uint32_t) RTLocalIpcSessionRelease(RTLOCALIPCSESSION hSession)
1105	{
1106	if (hSession == NIL_RTLOCALIPCSESSION)
1107	return 0;
1108
1109	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1110	AssertPtrReturn(pThis, UINT32_MAX);
1111	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, UINT32_MAX);
1112
1113	uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
1114	Assert(cRefs < UINT32_MAX / 2);
1115	if (cRefs)
1116	Log(("RTLocalIpcSessionRelease: %u refs left\n", cRefs));
1117	else
1118	{
1119	RTCritSectEnter(&pThis->CritSect);
1120	rtLocalIpcSessionWinDestroy(pThis);
1121	}
1122	return cRefs;
1123	}
1124
1125
1126	RTDECL(int) RTLocalIpcSessionClose(RTLOCALIPCSESSION hSession)
1127	{
1128	/*
1129	* Validate input.
1130	*/
1131	if (hSession == NIL_RTLOCALIPCSESSION)
1132	return VINF_SUCCESS;
1133	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1134	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1135	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE);
1136
1137	/*
1138	* Invalidate the instance, cancel all outstanding I/O and drop our reference.
1139	*/
1140	RTCritSectEnter(&pThis->CritSect);
1141	rtLocalIpcWinCancel(pThis);
1142	return rtLocalIpcSessionReleaseAndUnlock(pThis);
1143	}
1144
1145
1146	/**
1147	* Handles WaitForSingleObject return value when waiting for a zero byte read.
1148	*
1149	* The zero byte read is started by the RTLocalIpcSessionWaitForData method and
1150	* left pending when the function times out. This saves us the problem of
1151	* NtCancelIoFile messing with all active I/O operations and the trouble of
1152	* restarting the zero byte read the next time the method is called. However
1153	* should RTLocalIpcSessionRead be called after a failed
1154	* RTLocalIpcSessionWaitForData call, the zero byte read will still be pending
1155	* and it must wait for it to complete before the OVERLAPPEDIO structure can be
1156	* reused.
1157	*
1158	* Thus, both functions will do WaitForSingleObject and share this routine to
1159	* handle the outcome.
1160	*
1161	* @returns IPRT status code.
1162	* @param pThis The session instance.
1163	* @param rcWait The WaitForSingleObject return code.
1164	*/
1165	static int rtLocalIpcWinGetZeroReadResult(PRTLOCALIPCSESSIONINT pThis, DWORD rcWait)
1166	{
1167	int rc;
1168	DWORD cbRead = 42;
1169	if (rcWait == WAIT_OBJECT_0)
1170	{
1171	if (GetOverlappedResult(pThis->hNmPipe, &pThis->Read.OverlappedIO, &cbRead, !pThis->fCancelled /fWait/))
1172	{
1173	Assert(cbRead == 0);
1174	rc = VINF_SUCCESS;
1175	pThis->fZeroByteRead = false;
1176	}
1177	else if (pThis->fCancelled)
1178	rc = VERR_CANCELLED;
1179	else
1180	rc = RTErrConvertFromWin32(GetLastError());
1181	}
1182	else
1183	{
1184	/* We try get the result here too, just in case we're lucky, but no waiting. */
1185	DWORD dwErr = GetLastError();
1186	if (GetOverlappedResult(pThis->hNmPipe, &pThis->Read.OverlappedIO, &cbRead, FALSE /fWait/))
1187	{
1188	Assert(cbRead == 0);
1189	rc = VINF_SUCCESS;
1190	pThis->fZeroByteRead = false;
1191	}
1192	else if (rcWait == WAIT_TIMEOUT)
1193	rc = VERR_TIMEOUT;
1194	else if (rcWait == WAIT_ABANDONED)
1195	rc = VERR_INVALID_HANDLE;
1196	else
1197	rc = RTErrConvertFromWin32(dwErr);
1198	}
1199	return rc;
1200	}
1201
1202
1203	RTDECL(int) RTLocalIpcSessionRead(RTLOCALIPCSESSION hSession, void pvBuf, size_t cbToRead, size_t pcbRead)
1204	{
1205	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1206	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1207	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE);
1208	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1209	/* pcbRead is optional. */
1210
1211	int rc = RTCritSectEnter(&pThis->CritSect);
1212	if (RT_SUCCESS(rc))
1213	{
1214	rtLocalIpcSessionRetain(pThis);
1215	if (pThis->Read.hActiveThread == NIL_RTTHREAD)
1216	{
1217	pThis->Read.hActiveThread = RTThreadSelf();
1218
1219	size_t cbTotalRead = 0;
1220	while (cbToRead > 0)
1221	{
1222	DWORD cbRead = 0;
1223	if (!pThis->fCancelled)
1224	{
1225	/*
1226	* Wait for pending zero byte read, if necessary.
1227	* Note! It cannot easily be cancelled due to concurrent current writes.
1228	*/
1229	if (!pThis->fZeroByteRead)
1230	{ /* likely */ }
1231	else
1232	{
1233	RTCritSectLeave(&pThis->CritSect);
1234	DWORD rcWait = WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, RT_MS_1MIN);
1235	RTCritSectEnter(&pThis->CritSect);
1236
1237	rc = rtLocalIpcWinGetZeroReadResult(pThis, rcWait);
1238	if (RT_SUCCESS(rc) \|\| rc == VERR_TIMEOUT)
1239	continue;
1240	break;
1241	}
1242
1243	/*
1244	* Kick of a an overlapped read. It should return immediately if
1245	* there is bytes in the buffer. If not, we'll cancel it and see
1246	* what we get back.
1247	*/
1248	rc = ResetEvent(pThis->Read.OverlappedIO.hEvent); Assert(rc == TRUE);
1249	RTCritSectLeave(&pThis->CritSect);
1250
1251	if (ReadFile(pThis->hNmPipe, pvBuf,
1252	cbToRead <= ~(DWORD)0 ? (DWORD)cbToRead : ~(DWORD)0,
1253	&cbRead, &pThis->Read.OverlappedIO))
1254	{
1255	RTCritSectEnter(&pThis->CritSect);
1256	rc = VINF_SUCCESS;
1257	}
1258	else if (GetLastError() == ERROR_IO_PENDING)
1259	{
1260	WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, INFINITE);
1261
1262	RTCritSectEnter(&pThis->CritSect);
1263	if (GetOverlappedResult(pThis->hNmPipe, &pThis->Read.OverlappedIO, &cbRead, TRUE /fWait/))
1264	rc = VINF_SUCCESS;
1265	else
1266	{
1267	if (pThis->fCancelled)
1268	rc = VERR_CANCELLED;
1269	else
1270	rc = RTErrConvertFromWin32(GetLastError());
1271	break;
1272	}
1273	}
1274	else
1275	{
1276	rc = RTErrConvertFromWin32(GetLastError());
1277	AssertMsgFailedBreak(("%Rrc\n", rc));
1278	}
1279	}
1280	else
1281	{
1282	rc = VERR_CANCELLED;
1283	break;
1284	}
1285
1286	/* Advance. */
1287	cbToRead -= cbRead;
1288	cbTotalRead += cbRead;
1289	pvBuf = (uint8_t *)pvBuf + cbRead;
1290	}
1291
1292	if (pcbRead)
1293	{
1294	*pcbRead = cbTotalRead;
1295	if ( RT_FAILURE(rc)
1296	&& cbTotalRead
1297	&& rc != VERR_INVALID_POINTER)
1298	rc = VINF_SUCCESS;
1299	}
1300
1301	pThis->Read.hActiveThread = NIL_RTTHREAD;
1302	}
1303	else
1304	rc = VERR_WRONG_ORDER;
1305	rtLocalIpcSessionReleaseAndUnlock(pThis);
1306	}
1307
1308	return rc;
1309	}
1310
1311
1312	RTDECL(int) RTLocalIpcSessionReadNB(RTLOCALIPCSESSION hSession, void pvBuf, size_t cbToRead, size_t pcbRead)
1313	{
1314	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1315	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1316	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE);
1317	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1318	AssertPtrReturn(pcbRead, VERR_INVALID_POINTER);
1319	*pcbRead = 0;
1320
1321	int rc = RTCritSectEnter(&pThis->CritSect);
1322	if (RT_SUCCESS(rc))
1323	{
1324	rtLocalIpcSessionRetain(pThis);
1325	if (pThis->Read.hActiveThread == NIL_RTTHREAD)
1326	{
1327	pThis->Read.hActiveThread = RTThreadSelf();
1328
1329	for (;;)
1330	{
1331	DWORD cbRead = 0;
1332	if (!pThis->fCancelled)
1333	{
1334	/*
1335	* Wait for pending zero byte read, if necessary.
1336	* Note! It cannot easily be cancelled due to concurrent current writes.
1337	*/
1338	if (!pThis->fZeroByteRead)
1339	{ /* likely */ }
1340	else
1341	{
1342	RTCritSectLeave(&pThis->CritSect);
1343	DWORD rcWait = WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, 0);
1344	RTCritSectEnter(&pThis->CritSect);
1345
1346	rc = rtLocalIpcWinGetZeroReadResult(pThis, rcWait);
1347	if (RT_SUCCESS(rc))
1348	continue;
1349
1350	if (rc == VERR_TIMEOUT)
1351	rc = VINF_TRY_AGAIN;
1352	break;
1353	}
1354
1355	/*
1356	* Figure out how much we can read (cannot try and cancel here
1357	* like in the anonymous pipe code).
1358	*/
1359	DWORD cbAvailable;
1360	if (PeekNamedPipe(pThis->hNmPipe, NULL, 0, NULL, &cbAvailable, NULL))
1361	{
1362	if (cbAvailable == 0 \|\| cbToRead == 0)
1363	{
1364	*pcbRead = 0;
1365	rc = VINF_TRY_AGAIN;
1366	break;
1367	}
1368	}
1369	else
1370	{
1371	rc = RTErrConvertFromWin32(GetLastError());
1372	break;
1373	}
1374	if (cbAvailable > cbToRead)
1375	cbAvailable = (DWORD)cbToRead;
1376
1377	/*
1378	* Kick of a an overlapped read. It should return immediately, so we
1379	* don't really need to leave the critsect here.
1380	*/
1381	rc = ResetEvent(pThis->Read.OverlappedIO.hEvent); Assert(rc == TRUE);
1382	if (ReadFile(pThis->hNmPipe, pvBuf, cbAvailable, &cbRead, &pThis->Read.OverlappedIO))
1383	{
1384	*pcbRead = cbRead;
1385	rc = VINF_SUCCESS;
1386	}
1387	else if (GetLastError() == ERROR_IO_PENDING)
1388	{
1389	DWORD rcWait = WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, 0);
1390	if (rcWait == WAIT_TIMEOUT)
1391	{
1392	RTCritSectLeave(&pThis->CritSect);
1393	rcWait = WaitForSingleObject(pThis->Read.OverlappedIO.hEvent, INFINITE);
1394	RTCritSectEnter(&pThis->CritSect);
1395	}
1396	if (GetOverlappedResult(pThis->hNmPipe, &pThis->Read.OverlappedIO, &cbRead, TRUE /fWait/))
1397	{
1398	*pcbRead = cbRead;
1399	rc = VINF_SUCCESS;
1400	}
1401	else
1402	{
1403	if (pThis->fCancelled)
1404	rc = VERR_CANCELLED;
1405	else
1406	rc = RTErrConvertFromWin32(GetLastError());
1407	}
1408	}
1409	else
1410	{
1411	rc = RTErrConvertFromWin32(GetLastError());
1412	AssertMsgFailedBreak(("%Rrc\n", rc));
1413	}
1414	}
1415	else
1416	rc = VERR_CANCELLED;
1417	break;
1418	}
1419
1420	pThis->Read.hActiveThread = NIL_RTTHREAD;
1421	}
1422	else
1423	rc = VERR_WRONG_ORDER;
1424	rtLocalIpcSessionReleaseAndUnlock(pThis);
1425	}
1426
1427	return rc;
1428	}
1429
1430
1431	#if 0 /* Non-blocking writes are not yet supported. */
1432	/**
1433	* Common worker for handling I/O completion.
1434	*
1435	* This is used by RTLocalIpcSessionClose and RTLocalIpcSessionWrite.
1436	*
1437	* @returns IPRT status code.
1438	* @param pThis The pipe instance handle.
1439	*/
1440	static int rtLocalIpcSessionWriteCheckCompletion(PRTLOCALIPCSESSIONINT pThis)
1441	{
1442	int rc;
1443	DWORD rcWait = WaitForSingleObject(pThis->OverlappedIO.hEvent, 0);
1444	if (rcWait == WAIT_OBJECT_0)
1445	{
1446	DWORD cbWritten = 0;
1447	if (GetOverlappedResult(pThis->hNmPipe, &pThis->OverlappedIO, &cbWritten, TRUE))
1448	{
1449	for (;;)
1450	{
1451	if (cbWritten >= pThis->cbBounceBufUsed)
1452	{
1453	pThis->fIOPending = false;
1454	rc = VINF_SUCCESS;
1455	break;
1456	}
1457
1458	/* resubmit the remainder of the buffer - can this actually happen? */
1459	memmove(&pThis->pbBounceBuf[0], &pThis->pbBounceBuf[cbWritten], pThis->cbBounceBufUsed - cbWritten);
1460	rc = ResetEvent(pThis->OverlappedIO.hEvent); Assert(rc == TRUE);
1461	if (!WriteFile(pThis->hNmPipe, pThis->pbBounceBuf, (DWORD)pThis->cbBounceBufUsed,
1462	&cbWritten, &pThis->OverlappedIO))
1463	{
1464	DWORD dwErr = GetLastError();
1465	if (dwErr == ERROR_IO_PENDING)
1466	rc = VINF_TRY_AGAIN;
1467	else
1468	{
1469	pThis->fIOPending = false;
1470	if (dwErr == ERROR_NO_DATA)
1471	rc = VERR_BROKEN_PIPE;
1472	else
1473	rc = RTErrConvertFromWin32(dwErr);
1474	}
1475	break;
1476	}
1477	Assert(cbWritten > 0);
1478	}
1479	}
1480	else
1481	{
1482	pThis->fIOPending = false;
1483	rc = RTErrConvertFromWin32(GetLastError());
1484	}
1485	}
1486	else if (rcWait == WAIT_TIMEOUT)
1487	rc = VINF_TRY_AGAIN;
1488	else
1489	{
1490	pThis->fIOPending = false;
1491	if (rcWait == WAIT_ABANDONED)
1492	rc = VERR_INVALID_HANDLE;
1493	else
1494	rc = RTErrConvertFromWin32(GetLastError());
1495	}
1496	return rc;
1497	}
1498	#endif
1499
1500
1501	RTDECL(int) RTLocalIpcSessionWrite(RTLOCALIPCSESSION hSession, const void *pvBuf, size_t cbToWrite)
1502	{
1503	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1504	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1505	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE);
1506	AssertPtrReturn(pvBuf, VERR_INVALID_POINTER);
1507	AssertReturn(cbToWrite, VERR_INVALID_PARAMETER);
1508
1509	int rc = RTCritSectEnter(&pThis->CritSect);
1510	if (RT_SUCCESS(rc))
1511	{
1512	rtLocalIpcSessionRetain(pThis);
1513	if (pThis->Write.hActiveThread == NIL_RTTHREAD)
1514	{
1515	pThis->Write.hActiveThread = RTThreadSelf();
1516
1517	/*
1518	* Try write everything. No bounce buffering necessary.
1519	*/
1520	size_t cbTotalWritten = 0;
1521	while (cbToWrite > 0)
1522	{
1523	DWORD cbWritten = 0;
1524	if (!pThis->fCancelled)
1525	{
1526	BOOL fRc = ResetEvent(pThis->Write.OverlappedIO.hEvent); Assert(fRc == TRUE);
1527	RTCritSectLeave(&pThis->CritSect);
1528
1529	DWORD const cbToWriteInThisIteration = cbToWrite <= ~(DWORD)0 ? (DWORD)cbToWrite : ~(DWORD)0;
1530	fRc = WriteFile(pThis->hNmPipe, pvBuf, cbToWriteInThisIteration, &cbWritten, &pThis->Write.OverlappedIO);
1531	if (fRc)
1532	rc = VINF_SUCCESS;
1533	else
1534	{
1535	DWORD dwErr = GetLastError();
1536	if (dwErr == ERROR_IO_PENDING)
1537	{
1538	DWORD rcWait = WaitForSingleObject(pThis->Write.OverlappedIO.hEvent, INFINITE);
1539	if (rcWait == WAIT_OBJECT_0)
1540	{
1541	if (GetOverlappedResult(pThis->hNmPipe, &pThis->Write.OverlappedIO, &cbWritten, TRUE /fWait/))
1542	rc = VINF_SUCCESS;
1543	else
1544	rc = RTErrConvertFromWin32(GetLastError());
1545	}
1546	else if (rcWait == WAIT_TIMEOUT)
1547	rc = VERR_TIMEOUT;
1548	else if (rcWait == WAIT_ABANDONED)
1549	rc = VERR_INVALID_HANDLE;
1550	else
1551	rc = RTErrConvertFromWin32(GetLastError());
1552	}
1553	else if (dwErr == ERROR_NO_DATA)
1554	rc = VERR_BROKEN_PIPE;
1555	else
1556	rc = RTErrConvertFromWin32(dwErr);
1557	}
1558
1559	if (cbWritten > cbToWriteInThisIteration) /* paranoia^3 */
1560	cbWritten = cbToWriteInThisIteration;
1561
1562	RTCritSectEnter(&pThis->CritSect);
1563	if (RT_FAILURE(rc))
1564	break;
1565	}
1566	else
1567	{
1568	rc = VERR_CANCELLED;
1569	break;
1570	}
1571
1572	/* Advance. */
1573	pvBuf = (char const *)pvBuf + cbWritten;
1574	cbTotalWritten += cbWritten;
1575	cbToWrite -= cbWritten;
1576	}
1577
1578	pThis->Write.hActiveThread = NIL_RTTHREAD;
1579	}
1580	else
1581	rc = VERR_WRONG_ORDER;
1582	rtLocalIpcSessionReleaseAndUnlock(pThis);
1583	}
1584
1585	return rc;
1586	}
1587
1588
1589	RTDECL(int) RTLocalIpcSessionFlush(RTLOCALIPCSESSION hSession)
1590	{
1591	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1592	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1593	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE);
1594
1595	int rc = RTCritSectEnter(&pThis->CritSect);
1596	if (RT_SUCCESS(rc))
1597	{
1598	if (pThis->Write.hActiveThread == NIL_RTTHREAD)
1599	{
1600	/* No flushing on Windows needed since RTLocalIpcSessionWrite will block until
1601	* all data was written (or an error occurred). */
1602	/** @todo r=bird: above comment is misinformed.
1603	* Implement this as soon as we want an explicit asynchronous version of
1604	* RTLocalIpcSessionWrite on Windows. */
1605	rc = VINF_SUCCESS;
1606	}
1607	else
1608	rc = VERR_WRONG_ORDER;
1609	RTCritSectLeave(&pThis->CritSect);
1610	}
1611	return rc;
1612	}
1613
1614
1615	RTDECL(int) RTLocalIpcSessionWaitForData(RTLOCALIPCSESSION hSession, uint32_t cMillies)
1616	{
1617	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1618	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1619	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE);
1620
1621	uint64_t const msStart = RTTimeMilliTS();
1622
1623	int rc = RTCritSectEnter(&pThis->CritSect);
1624	if (RT_SUCCESS(rc))
1625	{
1626	rtLocalIpcSessionRetain(pThis);
1627	if (pThis->Read.hActiveThread == NIL_RTTHREAD)
1628	{
1629	pThis->Read.hActiveThread = RTThreadSelf();
1630
1631	/*
1632	* Wait loop.
1633	*/
1634	for (unsigned iLoop = 0;; iLoop++)
1635	{
1636	/*
1637	* Check for cancellation before we continue.
1638	*/
1639	if (!pThis->fCancelled)
1640	{ /* likely */ }
1641	else
1642	{
1643	rc = VERR_CANCELLED;
1644	break;
1645	}
1646
1647	/*
1648	* Prep something we can wait on.
1649	*/
1650	HANDLE hWait = INVALID_HANDLE_VALUE;
1651	if (pThis->fZeroByteRead)
1652	hWait = pThis->Read.OverlappedIO.hEvent;
1653	else
1654	{
1655	/* Peek at the pipe buffer and see how many bytes it contains. */
1656	DWORD cbAvailable;
1657	if ( PeekNamedPipe(pThis->hNmPipe, NULL, 0, NULL, &cbAvailable, NULL)
1658	&& cbAvailable)
1659	{
1660	rc = VINF_SUCCESS;
1661	break;
1662	}
1663
1664	/* Start a zero byte read operation that we can wait on. */
1665	if (cMillies == 0)
1666	{
1667	rc = VERR_TIMEOUT;
1668	break;
1669	}
1670	BOOL fRc = ResetEvent(pThis->Read.OverlappedIO.hEvent); Assert(fRc == TRUE); NOREF(fRc);
1671	DWORD cbRead = 0;
1672	if (ReadFile(pThis->hNmPipe, pThis->abBuf, 0 /cbToRead/, &cbRead, &pThis->Read.OverlappedIO))
1673	{
1674	rc = VINF_SUCCESS;
1675	if (iLoop > 10)
1676	RTThreadYield();
1677	}
1678	else if (GetLastError() == ERROR_IO_PENDING)
1679	{
1680	pThis->fZeroByteRead = true;
1681	hWait = pThis->Read.OverlappedIO.hEvent;
1682	}
1683	else
1684	rc = RTErrConvertFromWin32(GetLastError());
1685	if (RT_FAILURE(rc))
1686	break;
1687	}
1688
1689	/*
1690	* Check for timeout.
1691	*/
1692	DWORD cMsMaxWait = INFINITE; /* (MSC maybe used uninitialized) */
1693	if (cMillies == RT_INDEFINITE_WAIT)
1694	cMsMaxWait = INFINITE;
1695	else if ( hWait != INVALID_HANDLE_VALUE
1696	\|\| iLoop > 10)
1697	{
1698	uint64_t cMsElapsed = RTTimeMilliTS() - msStart;
1699	if (cMsElapsed <= cMillies)
1700	cMsMaxWait = cMillies - (uint32_t)cMsElapsed;
1701	else if (iLoop == 0)
1702	cMsMaxWait = cMillies ? 1 : 0;
1703	else
1704	{
1705	rc = VERR_TIMEOUT;
1706	break;
1707	}
1708	}
1709
1710	/*
1711	* Wait and collect the result.
1712	*/
1713	if (hWait != INVALID_HANDLE_VALUE)
1714	{
1715	RTCritSectLeave(&pThis->CritSect);
1716
1717	DWORD rcWait = WaitForSingleObject(hWait, cMsMaxWait);
1718
1719	int rc2 = RTCritSectEnter(&pThis->CritSect);
1720	AssertRC(rc2);
1721
1722	rc = rtLocalIpcWinGetZeroReadResult(pThis, rcWait);
1723	break;
1724	}
1725	}
1726
1727	pThis->Read.hActiveThread = NIL_RTTHREAD;
1728	}
1729
1730	rtLocalIpcSessionReleaseAndUnlock(pThis);
1731	}
1732
1733	return rc;
1734	}
1735
1736
1737	RTDECL(int) RTLocalIpcSessionCancel(RTLOCALIPCSESSION hSession)
1738	{
1739	PRTLOCALIPCSESSIONINT pThis = (PRTLOCALIPCSESSIONINT)hSession;
1740	AssertPtrReturn(pThis, VERR_INVALID_HANDLE);
1741	AssertReturn(pThis->u32Magic == RTLOCALIPCSESSION_MAGIC, VERR_INVALID_HANDLE);
1742
1743	/*
1744	* Enter the critical section, then set the cancellation flag
1745	* and signal the event (to wake up anyone in/at WaitForSingleObject).
1746	*/
1747	int rc = RTCritSectEnter(&pThis->CritSect);
1748	if (RT_SUCCESS(rc))
1749	{
1750	rtLocalIpcSessionRetain(pThis);
1751	rc = rtLocalIpcWinCancel(pThis);
1752	rtLocalIpcSessionReleaseAndUnlock(pThis);
1753	}
1754
1755	return rc;
1756	}
1757
1758
1759	RTDECL(int) RTLocalIpcSessionQueryProcess(RTLOCALIPCSESSION hSession, PRTPROCESS pProcess)
1760	{
1761	RT_NOREF_PV(hSession); RT_NOREF_PV(pProcess);
1762	return VERR_NOT_SUPPORTED;
1763	}
1764
1765
1766	RTDECL(int) RTLocalIpcSessionQueryUserId(RTLOCALIPCSESSION hSession, PRTUID pUid)
1767	{
1768	RT_NOREF_PV(hSession); RT_NOREF_PV(pUid);
1769	return VERR_NOT_SUPPORTED;
1770	}
1771
1772
1773	RTDECL(int) RTLocalIpcSessionQueryGroupId(RTLOCALIPCSESSION hSession, PRTGID pGid)
1774	{
1775	RT_NOREF_PV(hSession); RT_NOREF_PV(pGid);
1776	return VERR_NOT_SUPPORTED;
1777	}
1778

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/r3/win/localipc-win.cpp@ 105155

Download in other formats: