2012-10-08 00:13:30 +04:00
|
|
|
/**
|
|
|
|
* WinPR: Windows Portable Runtime
|
|
|
|
* Pipe Functions
|
|
|
|
*
|
|
|
|
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <winpr/crt.h>
|
2013-07-23 02:20:34 +04:00
|
|
|
#include <winpr/path.h>
|
2013-09-17 01:10:27 +04:00
|
|
|
#include <winpr/synch.h>
|
2012-10-08 04:25:50 +04:00
|
|
|
#include <winpr/handle.h>
|
2012-10-08 00:13:30 +04:00
|
|
|
|
|
|
|
#include <winpr/pipe.h>
|
|
|
|
|
2012-10-08 04:25:50 +04:00
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
2012-10-08 00:13:30 +04:00
|
|
|
#ifndef _WIN32
|
|
|
|
|
2013-05-17 01:32:58 +04:00
|
|
|
#include "../handle/handle.h"
|
|
|
|
|
2013-07-23 06:53:44 +04:00
|
|
|
#include <fcntl.h>
|
2014-02-07 18:17:05 +04:00
|
|
|
#include <errno.h>
|
2013-07-23 06:53:44 +04:00
|
|
|
#include <sys/un.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
|
2013-05-17 01:32:58 +04:00
|
|
|
#include "pipe.h"
|
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
/*
|
2014-05-09 01:17:39 +04:00
|
|
|
* Since the WinPR implementation of named pipes makes use of UNIX domain
|
2014-04-18 21:16:42 +04:00
|
|
|
* sockets, it is not possible to bind the same name more than once (i.e.,
|
|
|
|
* SO_REUSEADDR does not work with UNIX domain sockets). As a result, the
|
|
|
|
* first call to CreateNamedPipe must create the UNIX domain socket and
|
|
|
|
* subsequent calls to CreateNamedPipe will reference the first named pipe
|
|
|
|
* handle and duplicate the socket descriptor.
|
|
|
|
*
|
|
|
|
* The following array keeps track of the named pipe handles for the first
|
|
|
|
* instance. If multiple instances are created, subsequent instances store
|
|
|
|
* a pointer to the first instance and a reference count is maintained. When
|
|
|
|
* the last instance is closed, the named pipe handle is removed from the list.
|
|
|
|
*/
|
|
|
|
|
2014-04-18 23:11:26 +04:00
|
|
|
static wArrayList* g_BaseNamedPipeList = NULL;
|
2014-04-18 22:02:44 +04:00
|
|
|
|
|
|
|
static BOOL g_Initialized = FALSE;
|
2014-04-18 21:16:42 +04:00
|
|
|
|
|
|
|
static void InitWinPRPipeModule()
|
|
|
|
{
|
2014-05-09 01:17:39 +04:00
|
|
|
if (g_Initialized)
|
|
|
|
return;
|
2014-04-18 21:16:42 +04:00
|
|
|
|
2014-04-18 22:02:44 +04:00
|
|
|
g_BaseNamedPipeList = ArrayList_New(TRUE);
|
2014-04-18 21:16:42 +04:00
|
|
|
|
2014-04-18 22:02:44 +04:00
|
|
|
g_Initialized = TRUE;
|
|
|
|
}
|
2014-04-18 21:16:42 +04:00
|
|
|
|
2014-05-09 01:17:39 +04:00
|
|
|
void WinPR_RemoveBaseNamedPipeFromList(WINPR_NAMED_PIPE* pNamedPipe)
|
2014-04-18 22:02:44 +04:00
|
|
|
{
|
2014-05-09 01:17:39 +04:00
|
|
|
ArrayList_Remove(g_BaseNamedPipeList, pNamedPipe);
|
2014-04-18 21:16:42 +04:00
|
|
|
}
|
|
|
|
|
2013-07-23 00:30:25 +04:00
|
|
|
/*
|
|
|
|
* Unnamed pipe
|
|
|
|
*/
|
|
|
|
|
2012-10-08 00:13:30 +04:00
|
|
|
BOOL CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes, DWORD nSize)
|
|
|
|
{
|
2012-10-08 04:25:50 +04:00
|
|
|
int pipe_fd[2];
|
2013-05-17 01:32:58 +04:00
|
|
|
WINPR_PIPE* pReadPipe;
|
|
|
|
WINPR_PIPE* pWritePipe;
|
2012-10-08 04:25:50 +04:00
|
|
|
|
|
|
|
pipe_fd[0] = -1;
|
|
|
|
pipe_fd[1] = -1;
|
|
|
|
|
|
|
|
if (pipe(pipe_fd) < 0)
|
|
|
|
{
|
|
|
|
printf("CreatePipe: failed to create pipe\n");
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2013-05-17 01:32:58 +04:00
|
|
|
pReadPipe = (WINPR_PIPE*) malloc(sizeof(WINPR_PIPE));
|
|
|
|
pWritePipe = (WINPR_PIPE*) malloc(sizeof(WINPR_PIPE));
|
|
|
|
|
|
|
|
if (!pReadPipe || !pWritePipe)
|
2013-08-28 19:36:55 +04:00
|
|
|
{
|
|
|
|
if (pReadPipe)
|
|
|
|
free(pReadPipe);
|
2013-09-26 07:16:33 +04:00
|
|
|
|
2013-08-28 19:36:55 +04:00
|
|
|
if (pWritePipe)
|
|
|
|
free(pWritePipe);
|
2013-09-26 07:16:33 +04:00
|
|
|
|
2013-05-17 01:32:58 +04:00
|
|
|
return FALSE;
|
2013-08-28 19:36:55 +04:00
|
|
|
}
|
2013-05-17 01:32:58 +04:00
|
|
|
|
|
|
|
pReadPipe->fd = pipe_fd[0];
|
|
|
|
pWritePipe->fd = pipe_fd[1];
|
|
|
|
|
2013-05-17 02:27:26 +04:00
|
|
|
WINPR_HANDLE_SET_TYPE(pReadPipe, HANDLE_TYPE_ANONYMOUS_PIPE);
|
|
|
|
*((ULONG_PTR*) hReadPipe) = (ULONG_PTR) pReadPipe;
|
2012-10-08 04:25:50 +04:00
|
|
|
|
2013-05-17 02:27:26 +04:00
|
|
|
WINPR_HANDLE_SET_TYPE(pWritePipe, HANDLE_TYPE_ANONYMOUS_PIPE);
|
|
|
|
*((ULONG_PTR*) hWritePipe) = (ULONG_PTR) pWritePipe;
|
2012-10-08 04:25:50 +04:00
|
|
|
|
2012-10-08 00:13:30 +04:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2013-07-23 00:30:25 +04:00
|
|
|
/**
|
|
|
|
* Named pipe
|
|
|
|
*/
|
|
|
|
|
|
|
|
HANDLE CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances,
|
|
|
|
DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
|
|
|
|
{
|
2014-04-18 21:16:42 +04:00
|
|
|
int index;
|
2013-07-23 06:53:44 +04:00
|
|
|
int status;
|
2013-07-23 02:20:34 +04:00
|
|
|
HANDLE hNamedPipe;
|
|
|
|
char* lpPipePath;
|
2013-07-23 06:53:44 +04:00
|
|
|
struct sockaddr_un s;
|
2013-07-23 02:20:34 +04:00
|
|
|
WINPR_NAMED_PIPE* pNamedPipe;
|
2014-04-18 21:16:42 +04:00
|
|
|
WINPR_NAMED_PIPE* pBaseNamedPipe;
|
2013-07-23 02:20:34 +04:00
|
|
|
|
|
|
|
if (!lpName)
|
|
|
|
return INVALID_HANDLE_VALUE;
|
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
InitWinPRPipeModule();
|
|
|
|
|
|
|
|
/* Find the base named pipe instance (i.e., the first instance). */
|
|
|
|
pBaseNamedPipe = NULL;
|
|
|
|
|
2014-04-18 22:02:44 +04:00
|
|
|
ArrayList_Lock(g_BaseNamedPipeList);
|
2014-05-09 01:17:39 +04:00
|
|
|
|
2014-04-18 22:02:44 +04:00
|
|
|
for (index = 0; index < ArrayList_Count(g_BaseNamedPipeList); index++)
|
2014-04-18 21:16:42 +04:00
|
|
|
{
|
2014-04-18 22:02:44 +04:00
|
|
|
WINPR_NAMED_PIPE* p = (WINPR_NAMED_PIPE*) ArrayList_GetItem(g_BaseNamedPipeList, index);
|
2014-05-09 01:17:39 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
if (strcmp(p->name, lpName) == 0)
|
|
|
|
{
|
|
|
|
pBaseNamedPipe = p;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2014-05-09 01:17:39 +04:00
|
|
|
|
2014-04-18 22:02:44 +04:00
|
|
|
ArrayList_Unlock(g_BaseNamedPipeList);
|
2014-04-18 21:16:42 +04:00
|
|
|
|
2013-07-23 02:20:34 +04:00
|
|
|
pNamedPipe = (WINPR_NAMED_PIPE*) malloc(sizeof(WINPR_NAMED_PIPE));
|
|
|
|
hNamedPipe = (HANDLE) pNamedPipe;
|
|
|
|
|
|
|
|
WINPR_HANDLE_SET_TYPE(pNamedPipe, HANDLE_TYPE_NAMED_PIPE);
|
|
|
|
|
2014-05-09 01:17:39 +04:00
|
|
|
pNamedPipe->pfnRemoveBaseNamedPipeFromList = WinPR_RemoveBaseNamedPipeFromList;
|
|
|
|
|
2013-07-23 02:20:34 +04:00
|
|
|
pNamedPipe->name = _strdup(lpName);
|
|
|
|
pNamedPipe->dwOpenMode = dwOpenMode;
|
|
|
|
pNamedPipe->dwPipeMode = dwPipeMode;
|
|
|
|
pNamedPipe->nMaxInstances = nMaxInstances;
|
|
|
|
pNamedPipe->nOutBufferSize = nOutBufferSize;
|
|
|
|
pNamedPipe->nInBufferSize = nInBufferSize;
|
|
|
|
pNamedPipe->nDefaultTimeOut = nDefaultTimeOut;
|
2013-08-23 06:36:37 +04:00
|
|
|
pNamedPipe->dwFlagsAndAttributes = dwOpenMode;
|
2013-07-23 02:20:34 +04:00
|
|
|
|
2013-07-23 06:53:44 +04:00
|
|
|
pNamedPipe->lpFileName = GetNamedPipeNameWithoutPrefixA(lpName);
|
|
|
|
pNamedPipe->lpFilePath = GetNamedPipeUnixDomainSocketFilePathA(lpName);
|
2013-07-23 02:20:34 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
pNamedPipe->clientfd = -1;
|
|
|
|
pNamedPipe->ServerMode = TRUE;
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
pNamedPipe->pBaseNamedPipe = pBaseNamedPipe;
|
|
|
|
pNamedPipe->dwRefCount = 1;
|
|
|
|
|
|
|
|
/* If this is the first instance of the named pipe... */
|
|
|
|
if (pBaseNamedPipe == NULL)
|
2013-09-26 03:13:39 +04:00
|
|
|
{
|
2014-04-18 21:16:42 +04:00
|
|
|
/* Create the UNIX domain socket and start listening. */
|
|
|
|
lpPipePath = GetNamedPipeUnixDomainSocketBaseFilePathA();
|
2013-07-23 02:20:34 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
if (!PathFileExistsA(lpPipePath))
|
|
|
|
{
|
|
|
|
CreateDirectoryA(lpPipePath, 0);
|
|
|
|
UnixChangeFileMode(lpPipePath, 0xFFFF);
|
|
|
|
}
|
2013-07-23 02:20:34 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
free(lpPipePath);
|
2013-10-01 20:03:08 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
if (PathFileExistsA(pNamedPipe->lpFilePath))
|
|
|
|
{
|
|
|
|
DeleteFileA(pNamedPipe->lpFilePath);
|
|
|
|
}
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
pNamedPipe->serverfd = socket(AF_UNIX, SOCK_STREAM, 0);
|
2013-10-01 20:03:08 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
if (pNamedPipe->serverfd == -1)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "CreateNamedPipeA: socket error, %s\n", strerror(errno));
|
2014-05-09 00:38:21 +04:00
|
|
|
goto err_out;
|
2014-04-18 21:16:42 +04:00
|
|
|
}
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
ZeroMemory(&s, sizeof(struct sockaddr_un));
|
|
|
|
s.sun_family = AF_UNIX;
|
|
|
|
strcpy(s.sun_path, pNamedPipe->lpFilePath);
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
status = bind(pNamedPipe->serverfd, (struct sockaddr*) &s, sizeof(struct sockaddr_un));
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
if (status != 0)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "CreateNamedPipeA: bind error, %s\n", strerror(errno));
|
2014-05-09 00:38:21 +04:00
|
|
|
goto err_out;
|
2014-04-18 21:16:42 +04:00
|
|
|
}
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
status = listen(pNamedPipe->serverfd, 2);
|
2013-10-01 20:03:08 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
if (status != 0)
|
|
|
|
{
|
|
|
|
fprintf(stderr, "CreateNamedPipeA: listen error, %s\n", strerror(errno));
|
2014-05-09 00:38:21 +04:00
|
|
|
goto err_out;
|
2014-04-18 21:16:42 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
UnixChangeFileMode(pNamedPipe->lpFilePath, 0xFFFF);
|
|
|
|
|
|
|
|
/* Add the named pipe to the list of base named pipe instances. */
|
2014-04-18 22:02:44 +04:00
|
|
|
ArrayList_Add(g_BaseNamedPipeList, pNamedPipe);
|
2013-07-23 06:53:44 +04:00
|
|
|
}
|
2014-04-18 21:16:42 +04:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Duplicate the file handle for the UNIX domain socket in the first instance. */
|
|
|
|
pNamedPipe->serverfd = dup(pBaseNamedPipe->serverfd);
|
2013-07-23 02:20:34 +04:00
|
|
|
|
2014-04-18 21:16:42 +04:00
|
|
|
/* Update the reference count in the base named pipe instance. */
|
|
|
|
pBaseNamedPipe->dwRefCount++;
|
|
|
|
}
|
2013-10-01 20:03:08 +04:00
|
|
|
|
2014-02-17 22:02:39 +04:00
|
|
|
if (dwOpenMode & FILE_FLAG_OVERLAPPED)
|
|
|
|
{
|
|
|
|
#if 0
|
|
|
|
int flags = fcntl(pNamedPipe->serverfd, F_GETFL);
|
|
|
|
|
|
|
|
if (flags != -1)
|
|
|
|
fcntl(pNamedPipe->serverfd, F_SETFL, flags | O_NONBLOCK);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2013-07-23 02:20:34 +04:00
|
|
|
return hNamedPipe;
|
2014-05-09 00:38:21 +04:00
|
|
|
|
2014-04-26 07:53:08 +04:00
|
|
|
err_out:
|
|
|
|
if (pNamedPipe) {
|
|
|
|
if (pNamedPipe->serverfd != -1)
|
|
|
|
close(pNamedPipe->serverfd);
|
|
|
|
free(pNamedPipe);
|
|
|
|
}
|
|
|
|
return INVALID_HANDLE_VALUE;
|
2013-07-23 00:30:25 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
HANDLE CreateNamedPipeW(LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances,
|
|
|
|
DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped)
|
|
|
|
{
|
2013-07-23 06:53:44 +04:00
|
|
|
int status;
|
|
|
|
socklen_t length;
|
|
|
|
struct sockaddr_un s;
|
2013-07-23 02:20:34 +04:00
|
|
|
WINPR_NAMED_PIPE* pNamedPipe;
|
|
|
|
|
2013-07-23 06:53:44 +04:00
|
|
|
if (!hNamedPipe)
|
|
|
|
return FALSE;
|
|
|
|
|
2013-07-23 02:20:34 +04:00
|
|
|
pNamedPipe = (WINPR_NAMED_PIPE*) hNamedPipe;
|
|
|
|
|
2013-09-26 07:16:33 +04:00
|
|
|
if (!(pNamedPipe->dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))
|
|
|
|
{
|
|
|
|
length = sizeof(struct sockaddr_un);
|
|
|
|
ZeroMemory(&s, sizeof(struct sockaddr_un));
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2013-09-26 07:16:33 +04:00
|
|
|
status = accept(pNamedPipe->serverfd, (struct sockaddr*) &s, &length);
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2013-09-26 07:16:33 +04:00
|
|
|
if (status < 0)
|
2013-10-01 20:03:08 +04:00
|
|
|
{
|
|
|
|
fprintf(stderr, "ConnectNamedPipe: accept error\n");
|
2013-09-26 07:16:33 +04:00
|
|
|
return FALSE;
|
2013-10-01 20:03:08 +04:00
|
|
|
}
|
2013-07-23 06:53:44 +04:00
|
|
|
|
2013-09-26 07:16:33 +04:00
|
|
|
pNamedPipe->clientfd = status;
|
|
|
|
pNamedPipe->ServerMode = FALSE;
|
|
|
|
}
|
|
|
|
else
|
2013-08-23 06:36:37 +04:00
|
|
|
{
|
|
|
|
if (!lpOverlapped)
|
|
|
|
return FALSE;
|
|
|
|
|
2013-09-26 07:16:33 +04:00
|
|
|
if (pNamedPipe->serverfd == -1)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
pNamedPipe->lpOverlapped = lpOverlapped;
|
|
|
|
|
|
|
|
/* synchronous behavior */
|
|
|
|
|
|
|
|
lpOverlapped->Internal = 2;
|
|
|
|
lpOverlapped->InternalHigh = (ULONG_PTR) 0;
|
|
|
|
lpOverlapped->Pointer = (PVOID) NULL;
|
|
|
|
|
2013-08-23 06:36:37 +04:00
|
|
|
SetEvent(lpOverlapped->hEvent);
|
|
|
|
}
|
|
|
|
|
2013-07-23 00:30:25 +04:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL DisconnectNamedPipe(HANDLE hNamedPipe)
|
|
|
|
{
|
2013-07-23 02:20:34 +04:00
|
|
|
WINPR_NAMED_PIPE* pNamedPipe;
|
|
|
|
|
|
|
|
pNamedPipe = (WINPR_NAMED_PIPE*) hNamedPipe;
|
|
|
|
|
2013-07-23 07:17:08 +04:00
|
|
|
if (pNamedPipe->clientfd != -1)
|
|
|
|
{
|
|
|
|
close(pNamedPipe->clientfd);
|
|
|
|
pNamedPipe->clientfd = -1;
|
|
|
|
}
|
|
|
|
|
2013-07-23 00:30:25 +04:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL PeekNamedPipe(HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize,
|
|
|
|
LPDWORD lpBytesRead, LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage)
|
|
|
|
{
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL TransactNamedPipe(HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer,
|
|
|
|
DWORD nOutBufferSize, LPDWORD lpBytesRead, LPOVERLAPPED lpOverlapped)
|
|
|
|
{
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL WaitNamedPipeA(LPCSTR lpNamedPipeName, DWORD nTimeOut)
|
|
|
|
{
|
2013-09-24 02:10:21 +04:00
|
|
|
BOOL status;
|
|
|
|
DWORD nWaitTime;
|
|
|
|
char* lpFilePath;
|
|
|
|
DWORD dwSleepInterval;
|
|
|
|
|
|
|
|
if (!lpNamedPipeName)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
lpFilePath = GetNamedPipeUnixDomainSocketFilePathA(lpNamedPipeName);
|
|
|
|
|
|
|
|
if (nTimeOut == NMPWAIT_USE_DEFAULT_WAIT)
|
|
|
|
nTimeOut = 50;
|
|
|
|
|
|
|
|
nWaitTime = 0;
|
|
|
|
status = TRUE;
|
|
|
|
dwSleepInterval = 10;
|
|
|
|
|
|
|
|
while (!PathFileExistsA(lpFilePath))
|
|
|
|
{
|
|
|
|
Sleep(dwSleepInterval);
|
|
|
|
nWaitTime += dwSleepInterval;
|
|
|
|
|
|
|
|
if (nWaitTime >= nTimeOut)
|
|
|
|
{
|
|
|
|
status = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-10-15 15:09:13 +04:00
|
|
|
free(lpFilePath);
|
2013-09-24 02:10:21 +04:00
|
|
|
return status;
|
2013-07-23 00:30:25 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
BOOL WaitNamedPipeW(LPCWSTR lpNamedPipeName, DWORD nTimeOut)
|
|
|
|
{
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL SetNamedPipeHandleState(HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout)
|
|
|
|
{
|
2013-09-26 07:16:33 +04:00
|
|
|
int fd;
|
2014-04-16 12:05:53 +04:00
|
|
|
int flags;
|
2013-07-23 02:20:34 +04:00
|
|
|
WINPR_NAMED_PIPE* pNamedPipe;
|
|
|
|
|
|
|
|
pNamedPipe = (WINPR_NAMED_PIPE*) hNamedPipe;
|
|
|
|
|
|
|
|
if (lpMode)
|
2013-09-26 07:16:33 +04:00
|
|
|
{
|
2013-07-23 02:20:34 +04:00
|
|
|
pNamedPipe->dwPipeMode = *lpMode;
|
|
|
|
|
2013-09-26 07:16:33 +04:00
|
|
|
fd = (pNamedPipe->ServerMode) ? pNamedPipe->serverfd : pNamedPipe->clientfd;
|
|
|
|
|
|
|
|
if (fd == -1)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
flags = fcntl(fd, F_GETFL);
|
|
|
|
|
|
|
|
if (pNamedPipe->dwPipeMode & PIPE_NOWAIT)
|
|
|
|
flags = (flags | O_NONBLOCK);
|
|
|
|
else
|
|
|
|
flags = (flags & ~(O_NONBLOCK));
|
|
|
|
|
|
|
|
fcntl(fd, F_SETFL, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lpMaxCollectionCount)
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lpCollectDataTimeout)
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-07-23 00:30:25 +04:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL ImpersonateNamedPipeClient(HANDLE hNamedPipe)
|
|
|
|
{
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL GetNamedPipeClientComputerNameA(HANDLE Pipe, LPCSTR ClientComputerName, ULONG ClientComputerNameLength)
|
|
|
|
{
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL GetNamedPipeClientComputerNameW(HANDLE Pipe, LPCWSTR ClientComputerName, ULONG ClientComputerNameLength)
|
|
|
|
{
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2012-10-08 00:13:30 +04:00
|
|
|
#endif
|