/**

 * 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 = NULL;

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 = NULL;

  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;

    }

  }

  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 = NULL;

  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,

                        NULL, /* CleanupHandle */

                        PipeRead,

                        NULL, /* FileReadEx */

                        NULL, /* FileReadScatter */

                        PipeWrite,

                        NULL, /* FileWriteEx */

                        NULL, /* FileWriteGather */

                        NULL, /* FileGetFileSize */

                        NULL, /*  FlushFileBuffers */

                        NULL, /* FileSetEndOfFile */

                        NULL, /* FileSetFilePointer */

                        NULL, /* SetFilePointerEx */

                        NULL, /* FileLockFile */

                        NULL, /* FileLockFileEx */

                        NULL, /* FileUnlockFile */

                        NULL, /* FileUnlockFileEx */

                        NULL  /* SetFileTime */

                        ,

                        NULL };

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;

  WINPR_NAMED_PIPE* pipe = NULL;

  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 = 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)

      return FALSE;

    if (pipe->clientfd == -1)

      return FALSE;

    pipe->lpOverlapped = lpOverlapped;

#ifdef WINPR_HAVE_SYS_AIO_H

    {

      int aio_status;

      struct aiocb cb = { 0 };

      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->Pointer = (PVOID)lpBuffer;

    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 = NULL;

  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 = { 0 };

      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->Pointer = cnv.pv;

    }

    SetEvent(lpOverlapped->hEvent);

#endif

  }

  return TRUE;

}

static HANDLE_OPS namedOps = { NamedPipeIsHandled,

                             NamedPipeCloseHandle,

                             NamedPipeGetFd,

                             NULL, /* CleanupHandle */

                             NamedPipeRead,

                             NULL,

                             NULL,

                             NamedPipeWrite,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL,

                             NULL };

static BOOL InitWinPRPipeModule(void)

{

  if (g_NamedPipeServerSockets)

    return TRUE;

  g_NamedPipeServerSockets = ArrayList_New(FALSE);

  return g_NamedPipeServerSockets != NULL;

}

/*

 * Unnamed pipe

 */

BOOL CreatePipe(PHANDLE hReadPipe, PHANDLE hWritePipe, LPSECURITY_ATTRIBUTES lpPipeAttributes,

                DWORD nSize)

{

  int pipe_fd[2];

  WINPR_PIPE* pReadPipe = NULL;

  WINPR_PIPE* pWritePipe = NULL;

  WINPR_UNUSED(lpPipeAttributes);

  WINPR_UNUSED(nSize);

  pipe_fd[0] = -1;

  pipe_fd[1] = -1;

  if (pipe(pipe_fd) < 0)

  {

    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)

  {

    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 = NULL;

  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 = NULL;

  WINPR_NAMED_PIPE* pNamedPipe = NULL;

  int serverfd = -1;

  NamedPipeServerSocketEntry* baseSocket = NULL;

  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 = { 0 };

    /* Create the UNIX domain socket and start listening. */

    if (!(lpPipePath = GetNamedPipeUnixDomainSocketBaseFilePathA()))

      goto out;

    if (!winpr_PathFileExists(lpPipePath))

    {

      if (!CreateDirectoryA(lpPipePath, 0))

      {

        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] = { 0 };

      WLog_ERR(TAG, "CreateNamedPipeA: socket error, %s",

               winpr_strerror(errno, ebuffer, sizeof(ebuffer)));

      goto out;

    }

    s.sun_family = AF_UNIX;

    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] = { 0 };

      WLog_ERR(TAG, "CreateNamedPipeA: bind error, %s",

               winpr_strerror(errno, ebuffer, sizeof(ebuffer)));

      goto out;

    }

    if (listen(serverfd, 2) == -1)

    {

      char ebuffer[256] = { 0 };

      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)

  {

#if 0

    int flags = fcntl(pNamedPipe->serverfd, F_GETFL);

    if (flags != -1)

      fcntl(pNamedPipe->serverfd, F_SETFL, flags | O_NONBLOCK);

#endif

  }

  // 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(LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances,

                        DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut,

                        LPSECURITY_ATTRIBUTES lpSecurityAttributes)

{

  WLog_ERR(TAG, "is not implemented");

  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

  return NULL;

}

BOOL ConnectNamedPipe(HANDLE hNamedPipe, LPOVERLAPPED lpOverlapped)

{

  int status = 0;

  socklen_t length = 0;

  WINPR_NAMED_PIPE* pNamedPipe = NULL;

  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 = { 0 };

    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->Pointer = (PVOID)NULL;

    SetEvent(lpOverlapped->hEvent);

  }

  return TRUE;

}

BOOL DisconnectNamedPipe(HANDLE hNamedPipe)

{

  WINPR_NAMED_PIPE* pNamedPipe = NULL;

  pNamedPipe = (WINPR_NAMED_PIPE*)hNamedPipe;

  if (pNamedPipe->clientfd != -1)

  {

    close(pNamedPipe->clientfd);

    pNamedPipe->clientfd = -1;

  }

  return TRUE;

}

BOOL PeekNamedPipe(HANDLE hNamedPipe, LPVOID lpBuffer, DWORD nBufferSize, LPDWORD lpBytesRead,

                   LPDWORD lpTotalBytesAvail, LPDWORD lpBytesLeftThisMessage)

{

  WLog_ERR(TAG, "Not implemented");

  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

  return FALSE;

}

BOOL TransactNamedPipe(HANDLE hNamedPipe, LPVOID lpInBuffer, DWORD nInBufferSize,

                       LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesRead,

                       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 = NULL;

  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(LPCWSTR lpNamedPipeName, DWORD nTimeOut)

{

  WLog_ERR(TAG, "Not implemented");

  SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

  return FALSE;

}

BOOL SetNamedPipeHandleState(HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount,

                             LPDWORD lpCollectDataTimeout)

{

  int fd = 0;

  int flags = 0;

  WINPR_NAMED_PIPE* pNamedPipe = NULL;

  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;

}