/**

 * 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

 * Copyright 2026 David Fort <contact@hardening-consulting.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.

 */

#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;

  }

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

  pNamedPipe->name = nullptr;

  free(pNamedPipe->lpFileName);

  pNamedPipe->lpFileName = nullptr;

  free(pNamedPipe->lpFilePath);

  pNamedPipe->lpFilePath = nullptr;

  if (pNamedPipe->serverfd != -1)

  {

    close(pNamedPipe->serverfd);

    pNamedPipe->serverfd = -1;

  }

  if (pNamedPipe->clientfd != -1)

  {

    close(pNamedPipe->clientfd);

    pNamedPipe->clientfd = -1;

  }

  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;

  const BOOL inherit = lpPipeAttributes && lpPipeAttributes->bInheritHandle;

  WINPR_UNUSED(nSize);

  /* match Windows semantics: handles are not inherited by a child process unless the creator

   * asks for it via bInheritHandle. Prefer the atomic pipe2(O_CLOEXEC) where available so

   * there's no window between pipe creation and marking it close-on-exec during which a

   * concurrent fork() elsewhere in the process could leak the fd into an unrelated child. */

#ifdef WINPR_HAVE_PIPE2

  const int pipe2flags = inherit ? 0 : O_CLOEXEC;

  if (pipe2(pipe_fd, pipe2flags) < 0)

#else

  if (pipe(pipe_fd) < 0 || !winpr_set_cloexec(pipe_fd[0], !inherit) ||

      !winpr_set_cloexec(pipe_fd[1], !inherit))

#endif

  {

    WLog_ERR(TAG, "failed to create and set cloexec pipe");

    goto fail_close_fd;

  }

  pReadPipe = (WINPR_PIPE*)calloc(1, sizeof(WINPR_PIPE));

  pWritePipe = (WINPR_PIPE*)calloc(1, sizeof(WINPR_PIPE));

  if (!pReadPipe || !pWritePipe)

  {

    WLog_ERR(TAG, "error allocating pipes");

    goto fail_free_pipes;

  }

  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;

fail_free_pipes:

  free(pReadPipe);

  free(pWritePipe);

fail_close_fd:

  if (pipe_fd[0] >= 0)

    close(pipe_fd[0]);

  if (pipe_fd[1] >= 0)

    close(pipe_fd[1]);

  return FALSE;

}

/* wraps an already-open fd (typically inherited across exec() from a parent process, e.g. via

 * winpr_importHandleFromString()) into a WINPR HANDLE with the same blocking read()/write()

 * behavior CreatePipe() hands out - the fd does not actually have to be a pipe, anything

 * read()/write()-able works (pipe, regular file, socket). */

HANDLE winpr_Pipe_FromFd(int fd)

{

  if (fd < 0)

    return INVALID_HANDLE_VALUE;

  WINPR_PIPE* pPipe = (WINPR_PIPE*)calloc(1, sizeof(WINPR_PIPE));

  if (!pPipe)

  {

    WLog_ERR(TAG, "error allocating pipe");

    return INVALID_HANDLE_VALUE;

  }

  pPipe->fd = fd;

  WINPR_HANDLE_SET_TYPE_AND_MODE(pPipe, HANDLE_TYPE_ANONYMOUS_PIPE, WINPR_FD_READ);

  pPipe->common.ops = &ops;

  return &pPipe->common;

}

/**

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

    }

    /* this is the shared listening socket kept in g_NamedPipeServerSockets, never handed out

     * as a HANDLE itself (each CreateNamedPipeA call gets its own close-on-exec duplicate

     * below) - still, it's a real fd in this process, so keep it from leaking into children */

    if (!winpr_set_cloexec(serverfd, TRUE))

    {

      WLog_ERR(TAG, "CreateNamedPipeA: failed to set close-on-exec on listening socket");

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

  }

  /* F_DUPFD_CLOEXEC rather than plain dup(): dup() always clears close-on-exec on the new fd

   * regardless of the source's own flags, so a plain dup() here would silently undo the

   * close-on-exec set on the shared listening socket above. */

  pNamedPipe->serverfd = fcntl(baseSocket->serverfd, F_DUPFD_CLOEXEC, 0);

  // 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);

  free(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);

#ifdef WINPR_HAVE_ACCEPT4

    status = accept4(pNamedPipe->serverfd, (struct sockaddr*)&s, &length, SOCK_CLOEXEC);

#else

    status = accept(pNamedPipe->serverfd, (struct sockaddr*)&s, &length);

#endif

    if (status < 0)

    {

      WLog_ERR(TAG, "ConnectNamedPipe: accept error");

      return FALSE;

    }

#ifndef WINPR_HAVE_ACCEPT4

    if (!winpr_set_cloexec(status, TRUE))

    {

      WLog_ERR(TAG, "ConnectNamedPipe: failed to set close-on-exec on accepted socket");

      close(status);

      return FALSE;

    }

#endif

    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;