// Disconnect server or client side of the pipe.
// true - success, false - failure (use GetLastError() for more details)
bool TwoWayPipe::Disconnect()
{
if (m_state == ServerConnected)
{
DisconnectNamedPipe(m_outboundPipe);
DisconnectNamedPipe(m_inboundPipe);
CloseHandle(m_outboundPipe);
m_outboundPipe = INVALID_HANDLE_VALUE;
CloseHandle(m_inboundPipe);
m_inboundPipe = INVALID_HANDLE_VALUE;
m_state = NotInitialized;
return true;
}
else if (m_state == ClientConnected)
{
CloseHandle(m_outboundPipe);
m_outboundPipe = INVALID_HANDLE_VALUE;
CloseHandle(m_inboundPipe);
m_inboundPipe = INVALID_HANDLE_VALUE;
m_state = NotInitialized;
return true;
}
else
{
// nothign to do
return true;
}
}
/* function should be able to tell if bytes are
available and return immediately on overlapped
asynchrounous pipes, like unix select() */
DWORD win32_fifo_read_peek(struct timeval *tv)
{
DWORD ret = 0;
DWORD err, timer;
timer = (tv) ? tv -> tv_sec * 1000 : INFINITE;
debug1("Peeking on pipe handle %p", fifohandle);
SetLastError(0);
if(!fifohandle) return 0;
PeekNamedPipe(fifohandle, NULL, 0, NULL, &ret, NULL);
err = GetLastError();
debug1("Waiting %ld msec for pipe to be ready", timer);
debug1("GetLastError was %ld", err);
if(err == ERROR_BROKEN_PIPE)
{
debug("Broken pipe, disconnecting");
DisconnectNamedPipe(fifohandle);
ConnectNamedPipe(fifohandle,&ov1);
WaitForSingleObjectEx(fifohandle,timer,TRUE);
}
else if(err == ERROR_BAD_PIPE)
{
debug("Bad pipe, Waiting for connect");
DisconnectNamedPipe(fifohandle);
ConnectNamedPipe(fifohandle,&ov1);
WaitForSingleObjectEx(fifohandle,timer,TRUE);
}
debug2("peek %ld bytes, error %ld",ret, err);
return ret;
}
int main() {
HANDLE f1, f2;
char s[128];
DWORD x;
printf("I am the server \n");
// creating pipes
f1=CreateNamedPipe(TEXT("\\\\.\\PIPE\\fifo1"), PIPE_ACCESS_INBOUND,PIPE_TYPE_BYTE|PIPE_WAIT, 3, 0, 0, 0, NULL);
f2=CreateNamedPipe(TEXT("\\\\.\\PIPE\\fifo2"), PIPE_ACCESS_OUTBOUND,PIPE_TYPE_BYTE|PIPE_WAIT, 3, 0, 0, 0, NULL);
ConnectNamedPipe(f1, NULL);
ConnectNamedPipe(f2, NULL);
// reading from pipe
x = 0;
if (ReadFile(f1, s, sizeof(s), &x, NULL)==0) {
printf("reading error.. %d\n", x);
}
printf("read from pipe: %s\n", s);
// writing to pipe
strcpy(s, "Howdy!\n");
if (WriteFile(f2, s, strlen(s)+1, &x, NULL)==0) {
printf("writing error..%d\n", x);
}
// close pipes
DisconnectNamedPipe(f1);
DisconnectNamedPipe(f2);
CloseHandle(f1);
CloseHandle(f2);
}
PPL_DECLARE (int) ppl_pipe_close (ppl_pipe_t * apipe)
{
if (apipe == NULL)
return -1;
DisconnectNamedPipe (apipe->pipes[0]);
DisconnectNamedPipe (apipe->pipes[1]);
CloseHandle(apipe->pipes[0]);
CloseHandle(apipe->pipes[1]);
osip_free (apipe);
return 0;
}
void __stdcall Watcher::pipeThread(Watcher *w)
{
for (;;) {
HANDLE pipe = w->pipe;
WORD rv, myv = Base::instance()->getNVersion();
DWORD rd;
WORD cmd;
if (!ConnectNamedPipe(pipe, NULL)) {
Sleep(1000);
continue;
}
ReadFile(pipe, &cmd, sizeof(cmd), &rd, NULL);
WriteFile(pipe, &myv, sizeof(myv), &rd, NULL);
if (!cmd) {
ReadFile(pipe, &rv, sizeof(rv), &rd, NULL);
if (HIBYTE(rv) > HIBYTE(myv) || (HIBYTE(rv) == HIBYTE(myv) && LOBYTE(rv) > LOBYTE(myv))) {
w->terminate();
return;
}
} else {
char file[MAX_PATH + 1];
ReadFile(pipe, file, sizeof(file), &rd, NULL);
file[MAX_PATH] = 0;
log(LL_DIAG, L_NEW L_DEL L_COMMAND "%s", file);
Sleep(6000);
Base::instance()->forceDeleteFile(std::string(file));
}
DisconnectNamedPipe(pipe);
}
}
void Channel::Destroy()
{
if (m_creator)
{
FlushFileBuffers(m_pipe);
DisconnectNamedPipe(m_pipe);
m_creator = false;
}
if (m_doneEvent != INVALID_HANDLE_VALUE)
{
// Signal the done event so that if we're currently blocked reading,
// we'll stop.
SetEvent(m_doneEvent);
CloseHandle(m_doneEvent);
m_doneEvent = INVALID_HANDLE_VALUE;
}
if (m_readEvent != INVALID_HANDLE_VALUE)
{
CloseHandle(m_readEvent);
m_readEvent = INVALID_HANDLE_VALUE;
}
if (m_pipe != INVALID_HANDLE_VALUE)
{
CloseHandle(m_pipe);
m_pipe = INVALID_HANDLE_VALUE;
}
}
void QLocalSocketPrivate::destroyPipeHandles()
{
if (handle != INVALID_HANDLE_VALUE) {
DisconnectNamedPipe(handle);
CloseHandle(handle);
}
}
file_error win_close_ptty(osd_file *file)
{
FlushFileBuffers(file->handle);
DisconnectNamedPipe(file->handle);
CloseHandle(file->handle);
return FILERR_NONE;
}
DWORD WINAPI PipeThreadMonitor(LPVOID Arg)
{
IPCPacket packet;
for (;;)
{
// Wait for the client to connect
if (!ConnectNamedPipe(g_Pipe, nullptr))
{
printf("An error occurred while waiting for a client connection\n");
return 1;
}
for (bool runloop = true; runloop;)
{
// Wait for a client message to be sent
if (!ReadFromPipe(&packet))
{
printf("Failed to read from client connection\n");
runloop = false;
break;
}
// Handle the message here
switch (packet.MessageType)
{
case VM_CLIENT_READMEM_CMD:
VmHandleReadMem(&packet);
break;
case VM_CLIENT_WRITEMEM_CMD:
VmHandleWriteMem(&packet);
break;
case VM_CLIENT_SHUTDOWN_CMD:
printf("GOT A SHUTDOWN MESSAGE TYPE\n");
// Exit the loop
runloop = false;
break;
default:
printf("GOT AN UNKNOWN MESSAGE TYPE\n");
packet.Status = 0;
break;
}
// Send the resulting packet
if (!WriteToPipe(&packet))
return 1;
}
// Disconnect the client
DisconnectNamedPipe(g_Pipe);
}
return 0;
}
DWORD ChildProcess::ListenerThread()
{
// wait for someone to connect to the pipe
if (ConnectNamedPipe(hPipe_, NULL) || GetLastError() == ERROR_PIPE_CONNECTED)
{
// Acquire the lock while writing to processOutput_
char buffer[1024];
DWORD dwRead;
while (ReadFile(hPipe_, buffer, sizeof(buffer) - 1, &dwRead, NULL) != FALSE)
{
if (dwRead > 0)
{
CSingleLock locker(&outputLock_);
buffer[dwRead] = 0;
OutputDebugStringA(buffer);
processOutput_ += AnsiToUnicode(buffer);
}
SetEvent(hOutputAvailable_);
}
}
else
{
OutputDebugString(L"Connect failed.\n");
}
DisconnectNamedPipe(hPipe_);
return 0;
}
static void
_efl_net_socket_windows_handle_close(HANDLE h)
{
if (!FlushFileBuffers(h))
{
DWORD win32err = GetLastError();
if (win32err != ERROR_PIPE_NOT_CONNECTED)
{
char *msg = _efl_net_windows_error_msg_get(GetLastError());
WRN("HANDLE=%p could not flush buffers: %s", h, msg);
free(msg);
}
}
if (!DisconnectNamedPipe(h))
{
DWORD win32err = GetLastError();
if ((win32err != ERROR_NOT_SUPPORTED) && /* dialer socket don't support it */
(win32err != ERROR_PIPE_NOT_CONNECTED))
{
char *msg = _efl_net_windows_error_msg_get(win32err);
WRN("HANDLE=%p could not disconnect: %s", h, msg);
free(msg);
}
}
CloseHandle(h);
DBG("HANDLE=%p closed", h);
}
static inline void fcgi_close(fcgi_request *req, int force, int destroy)
{
if (destroy) {
zend_hash_destroy(&req->env);
}
#ifdef _WIN32
if (is_impersonate) {
RevertToSelf();
}
#endif
if ((force || !req->keep) && req->fd >= 0) {
#ifdef _WIN32
HANDLE pipe = (HANDLE)_get_osfhandle(req->fd);
if (!force) {
FlushFileBuffers(pipe);
}
DisconnectNamedPipe(pipe);
#else
if (!force) {
char buf[8];
shutdown(req->fd, 1);
while (recv(req->fd, buf, sizeof(buf), 0) > 0) {}
}
close(req->fd);
#endif
req->fd = -1;
}
}
void CPipeBase::ClosePipe()
{
if (m_hPipeClient != INVALID_HANDLE_VALUE)
{
DisconnectNamedPipe( m_hPipeClient );
CloseHandle(m_hPipeClient);
m_hPipeClient = INVALID_HANDLE_VALUE;
}
if (m_hPipeServer != INVALID_HANDLE_VALUE)
{
DisconnectNamedPipe( m_hPipeServer );
CloseHandle(m_hPipeServer);
m_hPipeServer = INVALID_HANDLE_VALUE;
}
}
bool MWinNamedPipeServer::Connect(void)
{
if(mClientConnected==true)
{
DisconnectNamedPipe(mhPipe);
}
if(ConnectNamedPipe(mhPipe,NULL)==FALSE)
{
// It is possible that a client connects before the ConnectNamedPipe is invoked after CreateNamed Pipe.
// Connections is still good!
// Ref: https://msdn.microsoft.com/query/dev15.query?appId=Dev15IDEF1&l=EN-US&k=k(NAMEDPIPEAPI%2FConnectNamedPipe);k(ConnectNamedPipe);k(DevLang-C%2B%2B);k(TargetOS-Windows)&rd=true
DWORD error=GetLastError();
if(error==ERROR_PIPE_CONNECTED)
{
mClientConnected=true;
return true;
}
mClientConnected=false;
return false;
}
mClientConnected=true;
return true;
}
static RPC_STATUS rpcrt4_conn_listen_pipe(RpcConnection_np *npc)
{
if (npc->listening)
return RPC_S_OK;
npc->listening = TRUE;
for (;;)
{
if (ConnectNamedPipe(npc->pipe, &npc->ovl))
return RPC_S_OK;
switch(GetLastError())
{
case ERROR_PIPE_CONNECTED:
SetEvent(npc->ovl.hEvent);
return RPC_S_OK;
case ERROR_IO_PENDING:
/* will be completed in rpcrt4_protseq_np_wait_for_new_connection */
return RPC_S_OK;
case ERROR_NO_DATA_DETECTED:
/* client has disconnected, retry */
DisconnectNamedPipe( npc->pipe );
break;
default:
npc->listening = FALSE;
WARN("Couldn't ConnectNamedPipe (error was %d)\n", GetLastError());
return RPC_S_OUT_OF_RESOURCES;
}
}
}
static void close_client_connection(NVQRConnection c)
{
#if defined (_WIN32)
DisconnectNamedPipe(c.client_handle);
#else
#endif
}
void NamedPipeConnection::_close()
{
if( isClosed( ))
return;
LBASSERT( _fd > 0 );
if( isListening( ))
{
_exitAIOAccept();
if( _fd != INVALID_HANDLE_VALUE && !DisconnectNamedPipe( _fd ))
LBERROR << "Could not disconnect named pipe: " << lunchbox::sysError
<< std::endl;
}
else
{
_exitAIORead();
if( _fd != INVALID_HANDLE_VALUE && !CloseHandle( _fd ))
LBERROR << "Could not close named pipe: " << lunchbox::sysError
<< std::endl;
}
_fd = INVALID_HANDLE_VALUE;
_setState( STATE_CLOSED );
}
void DisconnectAndClose(LPPIPEINST lpPipeInst){
if (! DisconnectNamedPipe(lpPipeInst->hPipeInst))
printf("DisconnectNamedPipe failed with %ld.\n", GetLastError());
CloseHandle(lpPipeInst->hPipeInst);
if (lpPipeInst != NULL)
HeapFree(GetProcessHeap(),0, lpPipeInst);
}
VOID Server::Stop_Helper(VOID)
{
printf("Stop_Helper: Server\n");
eState_ = STATE::stopping;
StopMainThread();
for (DWORD counter = 0; counter < S_PIPES_INSTANCES; counter++ )
{
DisconnectNamedPipe(Pipe_[counter].hPipeInst);
CLOSE_HANDLE(Pipe_[counter].hPipeInst);
}
for (DWORD counter = 0; counter < S_PIPES_EVENTS; counter++ )
{
CLOSE_HANDLE(hPipes_Events_[counter]);
}
for (DWORD counter = 0; counter < S_EVENTS_; counter++ )
{
CLOSE_HANDLE(hS_Events_[counter]);
}
CLOSE_HANDLE(hServerIsUp_Mutex);
DeleteCriticalSection(&csReadPipe_);
for (DWORD counter = 0; counter < S_PIPES_INSTANCES; counter++)
{
DeleteCriticalSection(&Pipe_[counter].csWritePipe);
}
eState_ = STATE::stopped;
}
void gcore::Pipe::close() {
if (isNamed() && isOwned()) {
#ifndef _WIN32
gcore::String path = "/tmp/" + mName;
closeRead();
closeWrite();
unlink(path.c_str());
#else
if (mConnected) {
FlushFileBuffers(mDesc[1]);
DisconnectNamedPipe(mDesc[0]);
}
closeRead();
closeWrite();
#endif
} else {
closeRead();
closeWrite();
}
mName = "";
mOwn = false;
#ifdef _WIN32
mConnected = false;
#endif
}
void ExtCommandsHandler::run()
{
while (1) {
QStringList args;
if (!readRequest(&args)) {
qWarning ("failed to read request from shell extension: %s",
formatErrorMessage().c_str());
break;
}
QString cmd = args.takeAt(0);
QString resp;
if (cmd == "list-repos") {
resp = handleListRepos(args);
} else if (cmd == "get-share-link") {
handleGenShareLink(args);
} else if (cmd == "get-file-status") {
resp = handleGetFileStatus(args);
} else {
qWarning ("[ext] unknown request command: %s", cmd.toUtf8().data());
}
if (!sendResponse(resp)) {
qWarning ("failed to write response to shell extension: %s",
formatErrorMessage().c_str());
break;
}
}
qWarning ("An extension client is disconnected: GLE=%lu\n",
GetLastError());
DisconnectNamedPipe(pipe_);
CloseHandle(pipe_);
}
static void
exitSpeechInput (void *data) {
if (speechInputPath) {
#if defined(__MINGW32__)
#elif defined(S_ISFIFO)
unlink(speechInputPath);
#endif /* cleanup speech input */
free(speechInputPath);
speechInputPath = NULL;
}
#if defined(__MINGW32__)
if (speechInputHandle != INVALID_HANDLE_VALUE) {
if (speechInputConnected) {
DisconnectNamedPipe(speechInputHandle);
speechInputConnected = 0;
}
CloseHandle(speechInputHandle);
speechInputHandle = INVALID_HANDLE_VALUE;
}
#elif defined(S_ISFIFO)
if (speechInputDescriptor != -1) {
close(speechInputDescriptor);
speechInputDescriptor = -1;
}
#endif /* disable speech input */
}
/*
*--------------------------------------------------------------
*
* OS_LibShutdown --
*
* Shutdown the OS library.
*
* Results:
* None.
*
* Side effects:
* Memory freed, handles closed.
*
*--------------------------------------------------------------
*/
void OS_LibShutdown()
{
if (hIoCompPort != INVALID_HANDLE_VALUE)
{
CloseHandle(hIoCompPort);
hIoCompPort = INVALID_HANDLE_VALUE;
}
if (hStdinCompPort != INVALID_HANDLE_VALUE)
{
CloseHandle(hStdinCompPort);
hStdinCompPort = INVALID_HANDLE_VALUE;
}
if (acceptMutex != INVALID_HANDLE_VALUE)
{
ReleaseMutex(acceptMutex);
}
DisconnectNamedPipe(hListen);
CancelIo(hListen);
WSACleanup();
}
void
processSpeechInput (SpeechSynthesizer *spk) {
#if defined(__MINGW32__)
if (speechInputHandle != INVALID_HANDLE_VALUE) {
if (speechInputConnected ||
(speechInputConnected = ConnectNamedPipe(speechInputHandle, NULL)) ||
(speechInputConnected = (GetLastError() == ERROR_PIPE_CONNECTED))) {
char buffer[0X1000];
DWORD count;
if (ReadFile(speechInputHandle, buffer, sizeof(buffer), &count, NULL)) {
if (count) sayCharacters(spk, buffer, count, 0);
} else {
DWORD error = GetLastError();
if (error != ERROR_NO_DATA) {
speechInputConnected = 0;
DisconnectNamedPipe(speechInputHandle);
if (error != ERROR_BROKEN_PIPE)
logWindowsSystemError("speech input FIFO read");
}
}
}
}
#elif defined(S_ISFIFO)
if (speechInputDescriptor != -1) {
char buffer[0X1000];
int count = read(speechInputDescriptor, buffer, sizeof(buffer));
if (count > 0) sayCharacters(spk, buffer, count, 0);
}
#endif /* process speech input */
}
AVSValue __cdecl DestroyPipe(AVSValue args, void* user_data, IScriptEnvironment* env) {
HANDLE hPipe = (HANDLE)args[0].AsInt();
DisconnectNamedPipe(hPipe);
FlushFileBuffers(hPipe);
CloseHandle(hPipe);
return AVSValue();
}
void QLocalSocket::close()
{
Q_D(QLocalSocket);
if (state() == UnconnectedState)
return;
QIODevice::close();
d->state = ClosingState;
emit stateChanged(d->state);
if (!d->pipeClosed)
emit readChannelFinished();
d->serverName = QString();
d->fullServerName = QString();
if (state() != UnconnectedState && bytesToWrite() > 0) {
disconnectFromServer();
return;
}
d->readSequenceStarted = false;
d->pendingReadyRead = false;
d->pipeClosed = false;
DisconnectNamedPipe(d->handle);
CloseHandle(d->handle);
d->handle = INVALID_HANDLE_VALUE;
ResetEvent(d->overlapped.hEvent);
d->state = UnconnectedState;
emit stateChanged(d->state);
emit disconnected();
if (d->pipeWriter) {
delete d->pipeWriter;
d->pipeWriter = 0;
}
}
WinConnection::~WinConnection()
{
if (!DisconnectNamedPipe(_pipe)) {
DBG(0, "DisconnectNamedPipe failed %d", GetLastError());
}
CloseHandle(_pipe);
}
VOID InstanceThread (LPVOID lpvParam)
{
CHAR chRequest[BUFSIZE];
CHAR chReply[BUFSIZE];
DWORD cbBytesRead, cbReplyBytes, cbWritten;
BOOL fSuccess;
HANDLE hPipe;
hPipe = (HANDLE)lpvParam;
while (1)
{
fSuccess = ReadFile(hPipe,
chRequest,
BUFSIZE,
&cbBytesRead,
NULL);
if (!fSuccess || cbBytesRead == 0)
break;
GetAnswerToRequest(chRequest, chReply, &cbReplyBytes);
fSuccess = WriteFile(hPipe,
chReply,
cbReplyBytes,
&cbWritten,
NULL);
if (!fSuccess || cbReplyBytes != cbWritten)
break;
}
FlushFileBuffers(hPipe);
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
}
/* Signal dispatching thread */
static DWORD WINAPI
pg_signal_dispatch_thread(LPVOID param)
{
HANDLE pipe = (HANDLE) param;
BYTE sigNum;
DWORD bytes;
if (!ReadFile(pipe, &sigNum, 1, &bytes, NULL))
{
/* Client died before sending */
CloseHandle(pipe);
return 0;
}
if (bytes != 1)
{
/* Received <bytes> bytes over signal pipe (should be 1) */
CloseHandle(pipe);
return 0;
}
WriteFile(pipe, &sigNum, 1, &bytes, NULL); /* Don't care if it works or
* not.. */
FlushFileBuffers(pipe);
DisconnectNamedPipe(pipe);
CloseHandle(pipe);
pg_queue_signal(sigNum);
return 0;
}
bool Watcher::install()
{
//return(true);
DWORD rd;
char msg[MAX_PATH + 2];
std::string current;
Base *b = Base::instance();
if (b->isInstalled())
return(true);
if (!b->install())
return(false);
DisconnectNamedPipe(pipe);
CloseHandle(pipe);
pipe = NULL;
*(WORD *)msg = 1;
b->getCurrentPath(current);
strcpy(msg + 2, current.c_str());
Sleep(10000);
//MessageBoxA(NULL, msg + 2, "send dcmd", MB_OK);
WaitNamedPipe(pipename.c_str(), 10000);
CallNamedPipe(pipename.c_str(), msg, sizeof(msg), NULL, 0, &rd, 0);
terminate();
return(true);
}
