JackWinNamedPipe.cpp
/*
Copyright (C) 2004-2008 Grame
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "JackWinNamedPipe.h"
#include "JackError.h"
#include <assert.h>
#include <stdio.h>
#define BUFSIZE 4096
namespace Jack
{
int JackWinNamedPipeAux::ReadAux(void* data, int len)
{
DWORD read;
BOOL res = ReadFile(fNamedPipe, data, len, &read, NULL);
if (res && read == (DWORD)len) {
return 0;
} else {
jack_log("Cannot read named pipe name = %s err = %ld", fName, GetLastError());
return -1;
}
}
int JackWinNamedPipeAux::WriteAux(void* data, int len)
{
DWORD written;
BOOL res = WriteFile(fNamedPipe, data, len, &written, NULL);
if (res && written == (DWORD)len) {
return 0;
} else {
jack_log("Cannot write named pipe name = %s err = %ld", fName, GetLastError());
return -1;
}
}
/*
See :
http://answers.google.com/answers/threadview?id=430173
http://msdn.microsoft.com/en-us/library/windows/desktop/aa365800(v=vs.85).aspx
*/
/*
int JackWinNamedPipeClient::ConnectAux()
{
fNamedPipe = CreateFile(fName, // pipe name
GENERIC_READ | // read and write access
GENERIC_WRITE,
0, // no sharing
NULL, // default security attributes
OPEN_EXISTING, // opens existing pipe
0, // default attributes
NULL); // no template file
if (fNamedPipe == INVALID_HANDLE_VALUE) {
jack_error("Cannot connect to named pipe = %s err = %ld", fName, GetLastError());
return -1;
} else {
return 0;
}
}
*/
int JackWinNamedPipeClient::ConnectAux()
{
jack_log("JackWinNamedPipeClient::ConnectAux : fName %s", fName);
while (true) {
fNamedPipe = CreateFile(fName, // pipe name
GENERIC_READ | // read and write access
GENERIC_WRITE,
0, // no sharing
NULL, // default security attributes
OPEN_EXISTING, // opens existing pipe
0, // default attributes
NULL); // no template file
// Break if the pipe handle is valid.
if (fNamedPipe != INVALID_HANDLE_VALUE) {
return 0;
}
// Exit if an error other than ERROR_PIPE_BUSY or ERROR_FILE_NOT_FOUND occurs.
if ((GetLastError() != ERROR_PIPE_BUSY) && (GetLastError() != ERROR_FILE_NOT_FOUND)) {
jack_error("Cannot connect to named pipe = %s err = %ld", fName, GetLastError());
return -1;
}
// All pipe instances are busy, so wait for 2 seconds.
if (!WaitNamedPipe(fName, 2000)) {
jack_error("Cannot connect to named pipe after wait = %s err = %ld", fName, GetLastError());
return -1;
}
}
}
int JackWinNamedPipeClient::Connect(const char* dir, int which)
{
snprintf(fName, sizeof(fName), "\\\\.\\pipe\\%s_jack_%d", dir, which);
return ConnectAux();
}
int JackWinNamedPipeClient::Connect(const char* dir, const char* name, int which)
{
snprintf(fName, sizeof(fName), "\\\\.\\pipe\\%s_jack_%s_%d", dir, name, which);
return ConnectAux();
}
int JackWinNamedPipeClient::Close()
{
if (fNamedPipe != INVALID_HANDLE_VALUE) {
CloseHandle(fNamedPipe);
fNamedPipe = INVALID_HANDLE_VALUE;
return 0;
} else {
return -1;
}
}
void JackWinNamedPipeClient::SetReadTimeOut(long sec)
{
/*
COMMTIMEOUTS timeout;
if (GetCommTimeouts(fNamedPipe, &timeout)) {
jack_info("JackWinNamedPipeClient::SetReadTimeOut ReadIntervalTimeout = %d", timeout.ReadIntervalTimeout);
jack_info("JackWinNamedPipeClient::SetReadTimeOut ReadTotalTimeoutMultiplier = %d", timeout.ReadTotalTimeoutMultiplier);
jack_info("JackWinNamedPipeClient::SetReadTimeOut ReadTotalTimeoutConstant = %d", timeout.ReadTotalTimeoutConstant);
} else {
jack_error("JackWinNamedPipeClient::SetReadTimeOut err %d", GetLastError());
}
*/
}
void JackWinNamedPipeClient::SetWriteTimeOut(long sec)
{
/*
COMMTIMEOUTS timeout;
if (GetCommTimeouts(fNamedPipe, &timeout)) {
jack_info("JackWinNamedPipeClient::SetWriteTimeOut WriteTotalTimeoutMultiplier = %d", timeout.WriteTotalTimeoutMultiplier);
jack_info("JackWinNamedPipeClient::SetWriteTimeOut WriteTotalTimeoutConstant = %d", timeout.WriteTotalTimeoutConstant);
}
*/
}
void JackWinNamedPipeClient::SetNonBlocking(bool onoff)
{}
JackWinAsyncNamedPipeClient::JackWinAsyncNamedPipeClient()
: JackWinNamedPipeClient(), fPendingIO(false), fIOState(kIdle)
{
fIOState = kIdle;
fOverlap.hEvent = CreateEvent(NULL, // default security attribute
TRUE, // manual-reset event
TRUE, // initial state = signaled
NULL); // unnamed event object
}
JackWinAsyncNamedPipeClient::JackWinAsyncNamedPipeClient(HANDLE pipe, const char* name, bool pending)
: JackWinNamedPipeClient(pipe, name), fPendingIO(pending), fIOState(kIdle)
{
fOverlap.hEvent = CreateEvent(NULL, // default security attribute
TRUE, // manual-reset event
TRUE, // initial state = signaled
NULL); // unnamed event object
if (!fPendingIO) {
SetEvent(fOverlap.hEvent);
}
fIOState = (fPendingIO) ? kConnecting : kReading;
}
JackWinAsyncNamedPipeClient::~JackWinAsyncNamedPipeClient()
{
CloseHandle(fOverlap.hEvent);
}
int JackWinAsyncNamedPipeClient::FinishIO()
{
DWORD success, ret;
success = GetOverlappedResult(fNamedPipe, // handle to pipe
&fOverlap, // OVERLAPPED structure
&ret, // bytes transferred
FALSE); // do not wait
switch (fIOState) {
case kConnecting:
if (!success) {
jack_error("Conection error");
return -1;
} else {
fIOState = kReading;
// Prepare connection for new client ??
}
break;
case kReading:
if (!success || ret == 0) {
return -1;
}
fIOState = kWriting;
break;
case kWriting:
if (!success || ret == 0) {
return -1;
}
fIOState = kReading;
break;
default:
break;
}
return 0;
}
int JackWinAsyncNamedPipeClient::Read(void* data, int len)
{
DWORD read;
jack_log("JackWinNamedPipeClient::Read len = %ld", len);
BOOL res = ReadFile(fNamedPipe, data, len, &read, &fOverlap);
if (res && read != 0) {
fPendingIO = false;
fIOState = kWriting;
return 0;
} else if (!res && GetLastError() == ERROR_IO_PENDING) {
fPendingIO = true;
return 0;
} else {
jack_error("Cannot read named pipe err = %ld", GetLastError());
return -1;
}
}
int JackWinAsyncNamedPipeClient::Write(void* data, int len)
{
DWORD written;
jack_log("JackWinNamedPipeClient::Write len = %ld", len);
BOOL res = WriteFile(fNamedPipe, data, len, &written, &fOverlap);
if (res && written != 0) {
fPendingIO = false;
fIOState = kWriting;
return 0;
} else if (!res && GetLastError() == ERROR_IO_PENDING) {
fPendingIO = true;
return 0;
} else {
jack_error("Cannot write named pipe err = %ld", GetLastError());
return -1;
}
}
// Server side
int JackWinNamedPipeServer::BindAux()
{
jack_log("JackWinNamedPipeServer::BindAux : fName %s", fName);
if ((fNamedPipe = CreateNamedPipe(fName,
PIPE_ACCESS_DUPLEX, // read/write access
PIPE_TYPE_MESSAGE | // message type pipe
PIPE_READMODE_MESSAGE | // message-read mode
PIPE_WAIT, // blocking mode
PIPE_UNLIMITED_INSTANCES, // max. instances
BUFSIZE, // output buffer size
BUFSIZE, // input buffer size
INFINITE, // client time-out
NULL)) == INVALID_HANDLE_VALUE) { // no security
jack_error("Cannot bind server to pipe err = %ld", GetLastError());
return -1;
} else {
return 0;
}
}
int JackWinNamedPipeServer::Bind(const char* dir, int which)
{
snprintf(fName, sizeof(fName), "\\\\.\\pipe\\%s_jack_%d", dir, which);
return BindAux();
}
int JackWinNamedPipeServer::Bind(const char* dir, const char* name, int which)
{
snprintf(fName, sizeof(fName), "\\\\.\\pipe\\%s_jack_%s_%d", dir, name, which);
return BindAux();
}
bool JackWinNamedPipeServer::Accept()
{
if (ConnectNamedPipe(fNamedPipe, NULL)) {
return true;
} else {
jack_error("Cannot connect server pipe name = %s err = %ld", fName, GetLastError());
if (GetLastError() == ERROR_PIPE_CONNECTED) {
jack_error("Pipe already connnected = %s", fName);
return true;
} else {
return false;
}
}
}
JackWinNamedPipeClient* JackWinNamedPipeServer::AcceptClient()
{
if (ConnectNamedPipe(fNamedPipe, NULL)) {
JackWinNamedPipeClient* client = new JackWinNamedPipeClient(fNamedPipe, fName);
// Init the pipe to the default value
fNamedPipe = INVALID_HANDLE_VALUE;
return client;
} else {
switch (GetLastError()) {
case ERROR_PIPE_CONNECTED:
return new JackWinNamedPipeClient(fNamedPipe, fName);
default:
jack_error("Cannot connect server pipe name = %s err = %ld", fName, GetLastError());
return NULL;
}
}
}
int JackWinNamedPipeServer::Close()
{
jack_log("JackWinNamedPipeServer::Close");
if (fNamedPipe != INVALID_HANDLE_VALUE) {
DisconnectNamedPipe(fNamedPipe);
CloseHandle(fNamedPipe);
fNamedPipe = INVALID_HANDLE_VALUE;
return 0;
} else {
return -1;
}
}
// Server side
int JackWinAsyncNamedPipeServer::BindAux()
{
jack_log("JackWinAsyncNamedPipeServer::BindAux : fName %s", fName);
if ((fNamedPipe = CreateNamedPipe(fName,
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, // read/write access
PIPE_TYPE_MESSAGE | // message type pipe
PIPE_READMODE_MESSAGE | // message-read mode
PIPE_WAIT, // blocking mode
PIPE_UNLIMITED_INSTANCES, // max. instances
BUFSIZE, // output buffer size
BUFSIZE, // input buffer size
INFINITE, // client time-out
NULL)) == INVALID_HANDLE_VALUE) { // no security a
jack_error("Cannot bind server to pipe err = %ld", GetLastError());
return -1;
} else {
return 0;
}
}
int JackWinAsyncNamedPipeServer::Bind(const char* dir, int which)
{
snprintf(fName, sizeof(fName), "\\\\.\\pipe\\%s_jack_%d", dir, which);
return BindAux();
}
int JackWinAsyncNamedPipeServer::Bind(const char* dir, const char* name, int which)
{
snprintf(fName, sizeof(fName), "\\\\.\\pipe\\%s_jack_%s_%d", dir, name, which);
return BindAux();
}
bool JackWinAsyncNamedPipeServer::Accept()
{
return false;
}
JackWinNamedPipeClient* JackWinAsyncNamedPipeServer::AcceptClient()
{
if (ConnectNamedPipe(fNamedPipe, NULL)) {
return new JackWinAsyncNamedPipeClient(fNamedPipe, fName, false);
} else {
switch (GetLastError()) {
case ERROR_IO_PENDING:
return new JackWinAsyncNamedPipeClient(fNamedPipe, fName, true);
case ERROR_PIPE_CONNECTED:
return new JackWinAsyncNamedPipeClient(fNamedPipe, fName, false);
default:
jack_error("Cannot connect server pipe name = %s err = %ld", fName, GetLastError());
return NULL;
break;
}
}
}
} // end of namespace
Jack
Definition: JackAC3Encoder.cpp:30
jack_error
SERVER_EXPORT void jack_error(const char *fmt,...)
Definition: JackError.cpp:92
jack_log
SERVER_EXPORT void jack_log(const char *fmt,...)
Definition: JackError.cpp:108