Milestone 5: deliver embedded RDP sessions and lifecycle hardening
This commit is contained in:
Keith Smith
940
third_party/FreeRDP/winpr/libwinpr/pipe/pipe.c
vendored
Normal file
940
third_party/FreeRDP/winpr/libwinpr/pipe/pipe.c
vendored
Normal file
@@ -0,0 +1,940 @@
|
||||
/**
|
||||
* WinPR: Windows Portable Runtime
|
||||
* Pipe Functions
|
||||
*
|
||||
* Copyright 2012 Marc-Andre Moreau <marcandre.moreau@gmail.com>
|
||||
* Copyright 2017 Armin Novak <armin.novak@thincast.com>
|
||||
* Copyright 2017 Thincast Technologies GmbH
|
||||
*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include <winpr/config.h>
|
||||
|
||||
#include <winpr/crt.h>
|
||||
#include <winpr/path.h>
|
||||
#include <winpr/synch.h>
|
||||
#include <winpr/handle.h>
|
||||
|
||||
#include <winpr/pipe.h>
|
||||
|
||||
#ifdef WINPR_HAVE_UNISTD_H
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#ifndef _WIN32
|
||||
|
||||
#include "../handle/handle.h"
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
#include <sys/un.h>
|
||||
#include <sys/socket.h>
|
||||
#include <winpr/assert.h>
|
||||
|
||||
#ifdef WINPR_HAVE_SYS_AIO_H
|
||||
#undef WINPR_HAVE_SYS_AIO_H /* disable for now, incomplete */
|
||||
#endif
|
||||
|
||||
#ifdef WINPR_HAVE_SYS_AIO_H
|
||||
#include <aio.h>
|
||||
#endif
|
||||
|
||||
#include "pipe.h"
|
||||
|
||||
#include "../log.h"
|
||||
#define TAG WINPR_TAG("pipe")
|
||||
|
||||
/*
|
||||
* Since the WinPR implementation of named pipes makes use of UNIX domain
|
||||
* 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 with name n creates a "shared" UNIX domain
|
||||
* socket descriptor that gets duplicated via dup() for the first and all
|
||||
* subsequent calls to CreateNamedPipe with name n.
|
||||
*
|
||||
* The following array keeps track of the references to the shared socked
|
||||
* descriptors. If an entry's reference count is zero the base socket
|
||||
* descriptor gets closed and the entry is removed from the list.
|
||||
*/
|
||||
|
||||
static wArrayList* g_NamedPipeServerSockets = nullptr;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
char* name;
|
||||
int serverfd;
|
||||
int references;
|
||||
} NamedPipeServerSocketEntry;
|
||||
|
||||
static BOOL PipeIsHandled(HANDLE handle)
|
||||
{
|
||||
return WINPR_HANDLE_IS_HANDLED(handle, HANDLE_TYPE_ANONYMOUS_PIPE, FALSE);
|
||||
}
|
||||
|
||||
static int PipeGetFd(HANDLE handle)
|
||||
{
|
||||
WINPR_PIPE* pipe = (WINPR_PIPE*)handle;
|
||||
|
||||
if (!PipeIsHandled(handle))
|
||||
return -1;
|
||||
|
||||
return pipe->fd;
|
||||
}
|
||||
|
||||
static BOOL PipeCloseHandle(HANDLE handle)
|
||||
{
|
||||
WINPR_PIPE* pipe = (WINPR_PIPE*)handle;
|
||||
|
||||
if (!PipeIsHandled(handle))
|
||||
return FALSE;
|
||||
|
||||
if (pipe->fd != -1)
|
||||
{
|
||||
close(pipe->fd);
|
||||
pipe->fd = -1;
|
||||
}
|
||||
|
||||
free(handle);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static BOOL PipeRead(PVOID Object, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
|
||||
LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
|
||||
{
|
||||
SSIZE_T io_status = 0;
|
||||
WINPR_PIPE* pipe = nullptr;
|
||||
BOOL status = TRUE;
|
||||
|
||||
if (lpOverlapped)
|
||||
{
|
||||
WLog_ERR(TAG, "WinPR does not support the lpOverlapped parameter");
|
||||
SetLastError(ERROR_NOT_SUPPORTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pipe = (WINPR_PIPE*)Object;
|
||||
|
||||
do
|
||||
{
|
||||
io_status = read(pipe->fd, lpBuffer, nNumberOfBytesToRead);
|
||||
} while ((io_status < 0) && (errno == EINTR));
|
||||
|
||||
if (io_status < 0)
|
||||
{
|
||||
status = FALSE;
|
||||
|
||||
switch (errno)
|
||||
{
|
||||
case EWOULDBLOCK:
|
||||
SetLastError(ERROR_NO_DATA);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (lpNumberOfBytesRead)
|
||||
*lpNumberOfBytesRead = (DWORD)io_status;
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static BOOL PipeWrite(PVOID Object, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
|
||||
LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
|
||||
{
|
||||
SSIZE_T io_status = 0;
|
||||
WINPR_PIPE* pipe = nullptr;
|
||||
|
||||
if (lpOverlapped)
|
||||
{
|
||||
WLog_ERR(TAG, "WinPR does not support the lpOverlapped parameter");
|
||||
SetLastError(ERROR_NOT_SUPPORTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pipe = (WINPR_PIPE*)Object;
|
||||
|
||||
do
|
||||
{
|
||||
io_status = write(pipe->fd, lpBuffer, nNumberOfBytesToWrite);
|
||||
} while ((io_status < 0) && (errno == EINTR));
|
||||
|
||||
if ((io_status < 0) && (errno == EWOULDBLOCK))
|
||||
io_status = 0;
|
||||
|
||||
*lpNumberOfBytesWritten = (DWORD)io_status;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static HANDLE_OPS ops = { PipeIsHandled,
|
||||
PipeCloseHandle,
|
||||
PipeGetFd,
|
||||
nullptr, /* CleanupHandle */
|
||||
PipeRead,
|
||||
nullptr, /* FileReadEx */
|
||||
nullptr, /* FileReadScatter */
|
||||
PipeWrite,
|
||||
nullptr, /* FileWriteEx */
|
||||
nullptr, /* FileWriteGather */
|
||||
nullptr, /* FileGetFileSize */
|
||||
nullptr, /* FlushFileBuffers */
|
||||
nullptr, /* FileSetEndOfFile */
|
||||
nullptr, /* FileSetFilePointer */
|
||||
nullptr, /* SetFilePointerEx */
|
||||
nullptr, /* FileLockFile */
|
||||
nullptr, /* FileLockFileEx */
|
||||
nullptr, /* FileUnlockFile */
|
||||
nullptr, /* FileUnlockFileEx */
|
||||
nullptr /* SetFileTime */
|
||||
,
|
||||
nullptr };
|
||||
|
||||
static BOOL NamedPipeIsHandled(HANDLE handle)
|
||||
{
|
||||
return WINPR_HANDLE_IS_HANDLED(handle, HANDLE_TYPE_NAMED_PIPE, TRUE);
|
||||
}
|
||||
|
||||
static int NamedPipeGetFd(HANDLE handle)
|
||||
{
|
||||
WINPR_NAMED_PIPE* pipe = (WINPR_NAMED_PIPE*)handle;
|
||||
|
||||
if (!NamedPipeIsHandled(handle))
|
||||
return -1;
|
||||
|
||||
if (pipe->ServerMode)
|
||||
return pipe->serverfd;
|
||||
|
||||
return pipe->clientfd;
|
||||
}
|
||||
|
||||
static BOOL NamedPipeCloseHandle(HANDLE handle)
|
||||
{
|
||||
WINPR_NAMED_PIPE* pNamedPipe = (WINPR_NAMED_PIPE*)handle;
|
||||
|
||||
/* This check confuses the analyzer. Since not all handle
|
||||
* types are handled here, it guesses that the memory of a
|
||||
* NamedPipeHandle may leak. */
|
||||
#ifndef __clang_analyzer__
|
||||
if (!NamedPipeIsHandled(handle))
|
||||
return FALSE;
|
||||
#endif
|
||||
|
||||
if (pNamedPipe->pfnUnrefNamedPipe)
|
||||
pNamedPipe->pfnUnrefNamedPipe(pNamedPipe);
|
||||
|
||||
free(pNamedPipe->name);
|
||||
free(pNamedPipe->lpFileName);
|
||||
free(pNamedPipe->lpFilePath);
|
||||
|
||||
if (pNamedPipe->serverfd != -1)
|
||||
close(pNamedPipe->serverfd);
|
||||
|
||||
if (pNamedPipe->clientfd != -1)
|
||||
close(pNamedPipe->clientfd);
|
||||
|
||||
free(pNamedPipe);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL NamedPipeRead(PVOID Object, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
|
||||
LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped)
|
||||
{
|
||||
SSIZE_T io_status = 0;
|
||||
BOOL status = TRUE;
|
||||
|
||||
WINPR_NAMED_PIPE* pipe = (WINPR_NAMED_PIPE*)Object;
|
||||
|
||||
if (!(pipe->dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))
|
||||
{
|
||||
if (pipe->clientfd == -1)
|
||||
return FALSE;
|
||||
|
||||
do
|
||||
{
|
||||
io_status = read(pipe->clientfd, lpBuffer, nNumberOfBytesToRead);
|
||||
} while ((io_status < 0) && (errno == EINTR));
|
||||
|
||||
if (io_status == 0)
|
||||
{
|
||||
SetLastError(ERROR_BROKEN_PIPE);
|
||||
status = FALSE;
|
||||
}
|
||||
else if (io_status < 0)
|
||||
{
|
||||
status = FALSE;
|
||||
|
||||
switch (errno)
|
||||
{
|
||||
case EWOULDBLOCK:
|
||||
SetLastError(ERROR_NO_DATA);
|
||||
break;
|
||||
|
||||
default:
|
||||
SetLastError(ERROR_BROKEN_PIPE);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (lpNumberOfBytesRead)
|
||||
*lpNumberOfBytesRead = (DWORD)io_status;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Overlapped I/O */
|
||||
if (!lpOverlapped)
|
||||
{
|
||||
WLog_ERR(TAG, "requires lpOverlapped != nullptr as FILE_FLAG_OVERLAPPED is set");
|
||||
SetLastError(ERROR_NOT_SUPPORTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (pipe->clientfd == -1)
|
||||
return FALSE;
|
||||
|
||||
pipe->lpOverlapped = lpOverlapped;
|
||||
#ifdef WINPR_HAVE_SYS_AIO_H
|
||||
{
|
||||
int aio_status;
|
||||
struct aiocb cb = WINPR_C_ARRAY_INIT;
|
||||
|
||||
cb.aio_fildes = pipe->clientfd;
|
||||
cb.aio_buf = lpBuffer;
|
||||
cb.aio_nbytes = nNumberOfBytesToRead;
|
||||
cb.aio_offset = lpOverlapped->Offset;
|
||||
cb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
|
||||
cb.aio_sigevent.sigev_signo = SIGIO;
|
||||
cb.aio_sigevent.sigev_value.sival_ptr = (void*)lpOverlapped;
|
||||
InstallAioSignalHandler();
|
||||
aio_status = aio_read(&cb);
|
||||
WLog_DBG(TAG, "aio_read status: %d", aio_status);
|
||||
|
||||
if (aio_status < 0)
|
||||
status = FALSE;
|
||||
|
||||
return status;
|
||||
}
|
||||
#else
|
||||
/* synchronous behavior */
|
||||
lpOverlapped->Internal = 0;
|
||||
lpOverlapped->InternalHigh = (ULONG_PTR)nNumberOfBytesToRead;
|
||||
lpOverlapped->DUMMYUNIONNAME.Pointer = (PVOID)lpBuffer;
|
||||
(void)SetEvent(lpOverlapped->hEvent);
|
||||
#endif
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
BOOL NamedPipeWrite(PVOID Object, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite,
|
||||
LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
|
||||
{
|
||||
SSIZE_T io_status = 0;
|
||||
WINPR_NAMED_PIPE* pipe = nullptr;
|
||||
BOOL status = TRUE;
|
||||
|
||||
if (lpOverlapped)
|
||||
{
|
||||
WLog_ERR(TAG, "WinPR does not support the lpOverlapped parameter");
|
||||
SetLastError(ERROR_NOT_SUPPORTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pipe = (WINPR_NAMED_PIPE*)Object;
|
||||
|
||||
if (!(pipe->dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))
|
||||
{
|
||||
if (pipe->clientfd == -1)
|
||||
return FALSE;
|
||||
|
||||
do
|
||||
{
|
||||
io_status = write(pipe->clientfd, lpBuffer, nNumberOfBytesToWrite);
|
||||
} while ((io_status < 0) && (errno == EINTR));
|
||||
|
||||
if (io_status < 0)
|
||||
{
|
||||
*lpNumberOfBytesWritten = 0;
|
||||
|
||||
switch (errno)
|
||||
{
|
||||
case EWOULDBLOCK:
|
||||
io_status = 0;
|
||||
status = TRUE;
|
||||
break;
|
||||
|
||||
default:
|
||||
status = FALSE;
|
||||
}
|
||||
}
|
||||
|
||||
*lpNumberOfBytesWritten = (DWORD)io_status;
|
||||
return status;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Overlapped I/O */
|
||||
if (!lpOverlapped)
|
||||
return FALSE;
|
||||
|
||||
if (pipe->clientfd == -1)
|
||||
return FALSE;
|
||||
|
||||
pipe->lpOverlapped = lpOverlapped;
|
||||
#ifdef WINPR_HAVE_SYS_AIO_H
|
||||
{
|
||||
struct aiocb cb = WINPR_C_ARRAY_INIT;
|
||||
|
||||
cb.aio_fildes = pipe->clientfd;
|
||||
cb.aio_buf = (void*)lpBuffer;
|
||||
cb.aio_nbytes = nNumberOfBytesToWrite;
|
||||
cb.aio_offset = lpOverlapped->Offset;
|
||||
cb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
|
||||
cb.aio_sigevent.sigev_signo = SIGIO;
|
||||
cb.aio_sigevent.sigev_value.sival_ptr = (void*)lpOverlapped;
|
||||
InstallAioSignalHandler();
|
||||
io_status = aio_write(&cb);
|
||||
WLog_DBG("aio_write status: %" PRIdz, io_status);
|
||||
|
||||
if (io_status < 0)
|
||||
status = FALSE;
|
||||
|
||||
return status;
|
||||
}
|
||||
#else
|
||||
/* synchronous behavior */
|
||||
lpOverlapped->Internal = 1;
|
||||
lpOverlapped->InternalHigh = (ULONG_PTR)nNumberOfBytesToWrite;
|
||||
{
|
||||
union
|
||||
{
|
||||
LPCVOID cpv;
|
||||
PVOID pv;
|
||||
} cnv;
|
||||
cnv.cpv = lpBuffer;
|
||||
lpOverlapped->DUMMYUNIONNAME.Pointer = cnv.pv;
|
||||
}
|
||||
(void)SetEvent(lpOverlapped->hEvent);
|
||||
#endif
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static HANDLE_OPS namedOps = { NamedPipeIsHandled,
|
||||
NamedPipeCloseHandle,
|
||||
NamedPipeGetFd,
|
||||
nullptr, /* CleanupHandle */
|
||||
NamedPipeRead,
|
||||
nullptr,
|
||||
nullptr,
|
||||
NamedPipeWrite,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr };
|
||||
|
||||
static BOOL InitWinPRPipeModule(void)
|
||||
{
|
||||
if (g_NamedPipeServerSockets)
|
||||
return TRUE;
|
||||
|
||||
g_NamedPipeServerSockets = ArrayList_New(FALSE);
|
||||
return g_NamedPipeServerSockets != nullptr;
|
||||
}
|
||||
|
||||
/*
|
||||
* Unnamed pipe
|
||||
*/
|
||||
|
||||
BOOL CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes,
|
||||
DWORD nSize)
|
||||
{
|
||||
int pipe_fd[] = { -1, -1 };
|
||||
WINPR_PIPE* pReadPipe = nullptr;
|
||||
WINPR_PIPE* pWritePipe = nullptr;
|
||||
|
||||
WINPR_UNUSED(lpPipeAttributes);
|
||||
WINPR_UNUSED(nSize);
|
||||
|
||||
if (pipe(pipe_fd) < 0)
|
||||
{
|
||||
if (pipe_fd[0] >= 0)
|
||||
close(pipe_fd[0]);
|
||||
if (pipe_fd[1] >= 0)
|
||||
close(pipe_fd[1]);
|
||||
|
||||
WLog_ERR(TAG, "failed to create pipe");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pReadPipe = (WINPR_PIPE*)calloc(1, sizeof(WINPR_PIPE));
|
||||
pWritePipe = (WINPR_PIPE*)calloc(1, sizeof(WINPR_PIPE));
|
||||
|
||||
if (!pReadPipe || !pWritePipe)
|
||||
{
|
||||
if (pipe_fd[0] >= 0)
|
||||
close(pipe_fd[0]);
|
||||
if (pipe_fd[1] >= 0)
|
||||
close(pipe_fd[1]);
|
||||
free(pReadPipe);
|
||||
free(pWritePipe);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pReadPipe->fd = pipe_fd[0];
|
||||
pWritePipe->fd = pipe_fd[1];
|
||||
WINPR_HANDLE_SET_TYPE_AND_MODE(pReadPipe, HANDLE_TYPE_ANONYMOUS_PIPE, WINPR_FD_READ);
|
||||
pReadPipe->common.ops = &ops;
|
||||
*((ULONG_PTR*)hReadPipe) = (ULONG_PTR)pReadPipe;
|
||||
WINPR_HANDLE_SET_TYPE_AND_MODE(pWritePipe, HANDLE_TYPE_ANONYMOUS_PIPE, WINPR_FD_READ);
|
||||
pWritePipe->common.ops = &ops;
|
||||
*((ULONG_PTR*)hWritePipe) = (ULONG_PTR)pWritePipe;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Named pipe
|
||||
*/
|
||||
|
||||
static void winpr_unref_named_pipe(WINPR_NAMED_PIPE* pNamedPipe)
|
||||
{
|
||||
NamedPipeServerSocketEntry* baseSocket = nullptr;
|
||||
|
||||
if (!pNamedPipe)
|
||||
return;
|
||||
|
||||
WINPR_ASSERT(pNamedPipe->name);
|
||||
WINPR_ASSERT(g_NamedPipeServerSockets);
|
||||
// WLog_VRB(TAG, "%p (%s)", (void*) pNamedPipe, pNamedPipe->name);
|
||||
ArrayList_Lock(g_NamedPipeServerSockets);
|
||||
|
||||
for (size_t index = 0; index < ArrayList_Count(g_NamedPipeServerSockets); index++)
|
||||
{
|
||||
baseSocket =
|
||||
(NamedPipeServerSocketEntry*)ArrayList_GetItem(g_NamedPipeServerSockets, index);
|
||||
WINPR_ASSERT(baseSocket->name);
|
||||
|
||||
if (!strcmp(baseSocket->name, pNamedPipe->name))
|
||||
{
|
||||
WINPR_ASSERT(baseSocket->references > 0);
|
||||
WINPR_ASSERT(baseSocket->serverfd != -1);
|
||||
|
||||
if (--baseSocket->references == 0)
|
||||
{
|
||||
// WLog_DBG(TAG, "removing shared server socked resource");
|
||||
// WLog_DBG(TAG, "closing shared serverfd %d", baseSocket->serverfd);
|
||||
ArrayList_Remove(g_NamedPipeServerSockets, baseSocket);
|
||||
close(baseSocket->serverfd);
|
||||
free(baseSocket->name);
|
||||
free(baseSocket);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ArrayList_Unlock(g_NamedPipeServerSockets);
|
||||
}
|
||||
|
||||
HANDLE CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances,
|
||||
DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut,
|
||||
LPSECURITY_ATTRIBUTES lpSecurityAttributes)
|
||||
{
|
||||
char* lpPipePath = nullptr;
|
||||
WINPR_NAMED_PIPE* pNamedPipe = nullptr;
|
||||
int serverfd = -1;
|
||||
NamedPipeServerSocketEntry* baseSocket = nullptr;
|
||||
|
||||
WINPR_UNUSED(lpSecurityAttributes);
|
||||
|
||||
if (dwOpenMode & FILE_FLAG_OVERLAPPED)
|
||||
{
|
||||
WLog_ERR(TAG, "WinPR does not support the FILE_FLAG_OVERLAPPED flag");
|
||||
SetLastError(ERROR_NOT_SUPPORTED);
|
||||
return INVALID_HANDLE_VALUE;
|
||||
}
|
||||
|
||||
if (!lpName)
|
||||
return INVALID_HANDLE_VALUE;
|
||||
|
||||
if (!InitWinPRPipeModule())
|
||||
return INVALID_HANDLE_VALUE;
|
||||
|
||||
pNamedPipe = (WINPR_NAMED_PIPE*)calloc(1, sizeof(WINPR_NAMED_PIPE));
|
||||
|
||||
if (!pNamedPipe)
|
||||
return INVALID_HANDLE_VALUE;
|
||||
|
||||
ArrayList_Lock(g_NamedPipeServerSockets);
|
||||
WINPR_HANDLE_SET_TYPE_AND_MODE(pNamedPipe, HANDLE_TYPE_NAMED_PIPE, WINPR_FD_READ);
|
||||
pNamedPipe->serverfd = -1;
|
||||
pNamedPipe->clientfd = -1;
|
||||
|
||||
if (!(pNamedPipe->name = _strdup(lpName)))
|
||||
goto out;
|
||||
|
||||
if (!(pNamedPipe->lpFileName = GetNamedPipeNameWithoutPrefixA(lpName)))
|
||||
goto out;
|
||||
|
||||
if (!(pNamedPipe->lpFilePath = GetNamedPipeUnixDomainSocketFilePathA(lpName)))
|
||||
goto out;
|
||||
|
||||
pNamedPipe->dwOpenMode = dwOpenMode;
|
||||
pNamedPipe->dwPipeMode = dwPipeMode;
|
||||
pNamedPipe->nMaxInstances = nMaxInstances;
|
||||
pNamedPipe->nOutBufferSize = nOutBufferSize;
|
||||
pNamedPipe->nInBufferSize = nInBufferSize;
|
||||
pNamedPipe->nDefaultTimeOut = nDefaultTimeOut;
|
||||
pNamedPipe->dwFlagsAndAttributes = dwOpenMode;
|
||||
pNamedPipe->clientfd = -1;
|
||||
pNamedPipe->ServerMode = TRUE;
|
||||
pNamedPipe->common.ops = &namedOps;
|
||||
|
||||
for (size_t index = 0; index < ArrayList_Count(g_NamedPipeServerSockets); index++)
|
||||
{
|
||||
baseSocket =
|
||||
(NamedPipeServerSocketEntry*)ArrayList_GetItem(g_NamedPipeServerSockets, index);
|
||||
|
||||
if (!strcmp(baseSocket->name, lpName))
|
||||
{
|
||||
serverfd = baseSocket->serverfd;
|
||||
// WLog_DBG(TAG, "using shared socked resource for pipe %p (%s)", (void*) pNamedPipe,
|
||||
// lpName);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* If this is the first instance of the named pipe... */
|
||||
if (serverfd == -1)
|
||||
{
|
||||
struct sockaddr_un s = WINPR_C_ARRAY_INIT;
|
||||
/* Create the UNIX domain socket and start listening. */
|
||||
if (!(lpPipePath = GetNamedPipeUnixDomainSocketBaseFilePathA()))
|
||||
goto out;
|
||||
|
||||
if (!winpr_PathFileExists(lpPipePath))
|
||||
{
|
||||
if (!CreateDirectoryA(lpPipePath, nullptr))
|
||||
{
|
||||
free(lpPipePath);
|
||||
goto out;
|
||||
}
|
||||
|
||||
UnixChangeFileMode(lpPipePath, 0xFFFF);
|
||||
}
|
||||
|
||||
free(lpPipePath);
|
||||
|
||||
if (winpr_PathFileExists(pNamedPipe->lpFilePath))
|
||||
winpr_DeleteFile(pNamedPipe->lpFilePath);
|
||||
|
||||
if ((serverfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
|
||||
{
|
||||
char ebuffer[256] = WINPR_C_ARRAY_INIT;
|
||||
WLog_ERR(TAG, "CreateNamedPipeA: socket error, %s",
|
||||
winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
|
||||
goto out;
|
||||
}
|
||||
|
||||
s.sun_family = AF_UNIX;
|
||||
(void)sprintf_s(s.sun_path, ARRAYSIZE(s.sun_path), "%s", pNamedPipe->lpFilePath);
|
||||
|
||||
if (bind(serverfd, (struct sockaddr*)&s, sizeof(struct sockaddr_un)) == -1)
|
||||
{
|
||||
char ebuffer[256] = WINPR_C_ARRAY_INIT;
|
||||
WLog_ERR(TAG, "CreateNamedPipeA: bind error, %s",
|
||||
winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (listen(serverfd, 2) == -1)
|
||||
{
|
||||
char ebuffer[256] = WINPR_C_ARRAY_INIT;
|
||||
WLog_ERR(TAG, "CreateNamedPipeA: listen error, %s",
|
||||
winpr_strerror(errno, ebuffer, sizeof(ebuffer)));
|
||||
goto out;
|
||||
}
|
||||
|
||||
UnixChangeFileMode(pNamedPipe->lpFilePath, 0xFFFF);
|
||||
|
||||
if (!(baseSocket = (NamedPipeServerSocketEntry*)malloc(sizeof(NamedPipeServerSocketEntry))))
|
||||
goto out;
|
||||
|
||||
if (!(baseSocket->name = _strdup(lpName)))
|
||||
{
|
||||
free(baseSocket);
|
||||
goto out;
|
||||
}
|
||||
|
||||
baseSocket->serverfd = serverfd;
|
||||
baseSocket->references = 0;
|
||||
|
||||
if (!ArrayList_Append(g_NamedPipeServerSockets, baseSocket))
|
||||
{
|
||||
free(baseSocket->name);
|
||||
free(baseSocket);
|
||||
goto out;
|
||||
}
|
||||
|
||||
// WLog_DBG(TAG, "created shared socked resource for pipe %p (%s). base serverfd = %d",
|
||||
// (void*) pNamedPipe, lpName, serverfd);
|
||||
}
|
||||
|
||||
pNamedPipe->serverfd = dup(baseSocket->serverfd);
|
||||
// WLog_DBG(TAG, "using serverfd %d (duplicated from %d)", pNamedPipe->serverfd,
|
||||
// baseSocket->serverfd);
|
||||
pNamedPipe->pfnUnrefNamedPipe = winpr_unref_named_pipe;
|
||||
baseSocket->references++;
|
||||
|
||||
if (dwOpenMode & FILE_FLAG_OVERLAPPED)
|
||||
{
|
||||
// TODO: Implement
|
||||
WLog_ERR(TAG, "TODO: implement this");
|
||||
}
|
||||
|
||||
// NOLINTNEXTLINE(clang-analyzer-unix.Malloc): ArrayList_Append takes ownership of baseSocket
|
||||
ArrayList_Unlock(g_NamedPipeServerSockets);
|
||||
return pNamedPipe;
|
||||
out:
|
||||
NamedPipeCloseHandle(pNamedPipe);
|
||||
|
||||
if (serverfd != -1)
|
||||
close(serverfd);
|
||||
|
||||
ArrayList_Unlock(g_NamedPipeServerSockets);
|
||||
return INVALID_HANDLE_VALUE;
|
||||
}
|
||||
|
||||
HANDLE CreateNamedPipeW(WINPR_ATTR_UNUSED LPCWSTR lpName, WINPR_ATTR_UNUSED DWORD dwOpenMode,
|
||||
WINPR_ATTR_UNUSED DWORD dwPipeMode, WINPR_ATTR_UNUSED DWORD nMaxInstances,
|
||||
WINPR_ATTR_UNUSED DWORD nOutBufferSize,
|
||||
WINPR_ATTR_UNUSED DWORD nInBufferSize,
|
||||
WINPR_ATTR_UNUSED DWORD nDefaultTimeOut,
|
||||
WINPR_ATTR_UNUSED LPSECURITY_ATTRIBUTES lpSecurityAttributes)
|
||||
{
|
||||
WLog_ERR(TAG, "is not implemented");
|
||||
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
BOOL ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped)
|
||||
{
|
||||
int status = 0;
|
||||
socklen_t length = 0;
|
||||
WINPR_NAMED_PIPE* pNamedPipe = nullptr;
|
||||
|
||||
if (lpOverlapped)
|
||||
{
|
||||
WLog_ERR(TAG, "WinPR does not support the lpOverlapped parameter");
|
||||
SetLastError(ERROR_NOT_SUPPORTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!hNamedPipe)
|
||||
return FALSE;
|
||||
|
||||
pNamedPipe = (WINPR_NAMED_PIPE*)hNamedPipe;
|
||||
|
||||
if (!(pNamedPipe->dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))
|
||||
{
|
||||
struct sockaddr_un s = WINPR_C_ARRAY_INIT;
|
||||
length = sizeof(struct sockaddr_un);
|
||||
status = accept(pNamedPipe->serverfd, (struct sockaddr*)&s, &length);
|
||||
|
||||
if (status < 0)
|
||||
{
|
||||
WLog_ERR(TAG, "ConnectNamedPipe: accept error");
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
pNamedPipe->clientfd = status;
|
||||
pNamedPipe->ServerMode = FALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!lpOverlapped)
|
||||
return FALSE;
|
||||
|
||||
if (pNamedPipe->serverfd == -1)
|
||||
return FALSE;
|
||||
|
||||
pNamedPipe->lpOverlapped = lpOverlapped;
|
||||
/* synchronous behavior */
|
||||
lpOverlapped->Internal = 2;
|
||||
lpOverlapped->InternalHigh = (ULONG_PTR)0;
|
||||
lpOverlapped->DUMMYUNIONNAME.Pointer = (PVOID) nullptr;
|
||||
(void)SetEvent(lpOverlapped->hEvent);
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL DisconnectNamedPipe(HANDLE hNamedPipe)
|
||||
{
|
||||
WINPR_NAMED_PIPE* pNamedPipe = nullptr;
|
||||
pNamedPipe = (WINPR_NAMED_PIPE*)hNamedPipe;
|
||||
|
||||
if (pNamedPipe->clientfd != -1)
|
||||
{
|
||||
close(pNamedPipe->clientfd);
|
||||
pNamedPipe->clientfd = -1;
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL PeekNamedPipe(WINPR_ATTR_UNUSED HANDLE hNamedPipe, WINPR_ATTR_UNUSED LPVOID lpBuffer,
|
||||
WINPR_ATTR_UNUSED DWORD nBufferSize, WINPR_ATTR_UNUSED LPDWORD lpBytesRead,
|
||||
WINPR_ATTR_UNUSED LPDWORD lpTotalBytesAvail,
|
||||
WINPR_ATTR_UNUSED LPDWORD lpBytesLeftThisMessage)
|
||||
{
|
||||
WLog_ERR(TAG, "Not implemented");
|
||||
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL TransactNamedPipe(WINPR_ATTR_UNUSED HANDLE hNamedPipe, WINPR_ATTR_UNUSED LPVOID lpInBuffer,
|
||||
WINPR_ATTR_UNUSED DWORD nInBufferSize, WINPR_ATTR_UNUSED LPVOID lpOutBuffer,
|
||||
WINPR_ATTR_UNUSED DWORD nOutBufferSize,
|
||||
WINPR_ATTR_UNUSED LPDWORD lpBytesRead,
|
||||
WINPR_ATTR_UNUSED LPOVERLAPPED lpOverlapped)
|
||||
{
|
||||
WLog_ERR(TAG, "Not implemented");
|
||||
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL WaitNamedPipeA(LPCSTR lpNamedPipeName, DWORD nTimeOut)
|
||||
{
|
||||
BOOL status = 0;
|
||||
DWORD nWaitTime = 0;
|
||||
char* lpFilePath = nullptr;
|
||||
DWORD dwSleepInterval = 0;
|
||||
|
||||
if (!lpNamedPipeName)
|
||||
return FALSE;
|
||||
|
||||
lpFilePath = GetNamedPipeUnixDomainSocketFilePathA(lpNamedPipeName);
|
||||
|
||||
if (!lpFilePath)
|
||||
return FALSE;
|
||||
|
||||
if (nTimeOut == NMPWAIT_USE_DEFAULT_WAIT)
|
||||
nTimeOut = 50;
|
||||
|
||||
nWaitTime = 0;
|
||||
status = TRUE;
|
||||
dwSleepInterval = 10;
|
||||
|
||||
while (!winpr_PathFileExists(lpFilePath))
|
||||
{
|
||||
Sleep(dwSleepInterval);
|
||||
nWaitTime += dwSleepInterval;
|
||||
|
||||
if (nWaitTime >= nTimeOut)
|
||||
{
|
||||
status = FALSE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
free(lpFilePath);
|
||||
return status;
|
||||
}
|
||||
|
||||
BOOL WaitNamedPipeW(WINPR_ATTR_UNUSED LPCWSTR lpNamedPipeName, WINPR_ATTR_UNUSED DWORD nTimeOut)
|
||||
{
|
||||
WLog_ERR(TAG, "Not implemented");
|
||||
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
// NOLINTBEGIN(readability-non-const-parameter)
|
||||
BOOL SetNamedPipeHandleState(HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,
|
||||
LPDWORD lpCollectDataTimeout)
|
||||
// NOLINTEND(readability-non-const-parameter)
|
||||
{
|
||||
int fd = 0;
|
||||
int flags = 0;
|
||||
WINPR_NAMED_PIPE* pNamedPipe = nullptr;
|
||||
pNamedPipe = (WINPR_NAMED_PIPE*)hNamedPipe;
|
||||
|
||||
if (lpMode)
|
||||
{
|
||||
pNamedPipe->dwPipeMode = *lpMode;
|
||||
fd = (pNamedPipe->ServerMode) ? pNamedPipe->serverfd : pNamedPipe->clientfd;
|
||||
|
||||
if (fd == -1)
|
||||
return FALSE;
|
||||
|
||||
flags = fcntl(fd, F_GETFL);
|
||||
|
||||
if (flags < 0)
|
||||
return FALSE;
|
||||
|
||||
if (pNamedPipe->dwPipeMode & PIPE_NOWAIT)
|
||||
flags = (flags | O_NONBLOCK);
|
||||
else
|
||||
flags = (flags & ~(O_NONBLOCK));
|
||||
|
||||
if (fcntl(fd, F_SETFL, flags) < 0)
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (lpMaxCollectionCount)
|
||||
{
|
||||
}
|
||||
|
||||
if (lpCollectDataTimeout)
|
||||
{
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL ImpersonateNamedPipeClient(WINPR_ATTR_UNUSED HANDLE hNamedPipe)
|
||||
{
|
||||
WLog_ERR(TAG, "Not implemented");
|
||||
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL GetNamedPipeClientComputerNameA(WINPR_ATTR_UNUSED HANDLE Pipe,
|
||||
WINPR_ATTR_UNUSED LPCSTR ClientComputerName,
|
||||
WINPR_ATTR_UNUSED ULONG ClientComputerNameLength)
|
||||
{
|
||||
WLog_ERR(TAG, "Not implemented");
|
||||
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
BOOL GetNamedPipeClientComputerNameW(WINPR_ATTR_UNUSED HANDLE Pipe,
|
||||
WINPR_ATTR_UNUSED LPCWSTR ClientComputerName,
|
||||
WINPR_ATTR_UNUSED ULONG ClientComputerNameLength)
|
||||
{
|
||||
WLog_ERR(TAG, "Not implemented");
|
||||
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user