windows/JackWinNamedPipe.cpp

   1 /*
   2 Copyright (C) 2004-2006 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation; either version 2 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program; if not, write to the Free Software
  16   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #include "JackWinNamedPipe.h"
  21 #include "JackError.h"
  22 #include <assert.h>
  23 #include <stdio.h>
  24
  25 #define BUFSIZE 4096
  26
  27 namespace Jack
  28 {
  29
  30 int JackWinNamedPipe::Read(void* data, int len)
  31 {
  32     DWORD read;
  33     BOOL res = ReadFile(fNamedPipe, data, len, &read, NULL);
  34     if (res && read == (DWORD)len) {
  35         return 0;
  36     } else {
  37         jack_error("Cannot read named pipe err = %ld", GetLastError());
  38         return -1;
  39     }
  40 }
  41
  42 int JackWinNamedPipe::Write(void* data, int len)
  43 {
  44     DWORD written;
  45     BOOL res = WriteFile(fNamedPipe, data, len, &written, NULL);
  46     if (res && written == (DWORD)len) {
  47         return 0;
  48     } else {
  49         jack_error("Cannot write named pipe err = %ld", GetLastError());
  50         return -1;
  51     }
  52 }
  53
  54 int JackWinNamedPipeClient::Connect(const char* dir, int which)
  55 {
  56     sprintf(fName, "\\\\.\\pipe\\%s_jack_%d", dir, which);
  57     jack_log("Connect: fName %s", fName);
  58
  59     fNamedPipe = CreateFile(fName,                       // pipe name
  60                             GENERIC_READ |   // read and write access
  61                             GENERIC_WRITE,
  62                             0,               // no sharing
  63                             NULL,            // default security attributes
  64                             OPEN_EXISTING,   // opens existing pipe
  65                             0,               // default attributes
  66                             NULL);          // no template file
  67
  68     if (fNamedPipe == INVALID_HANDLE_VALUE) {
  69         jack_error("Cannot connect to named pipe = %s err = %ld", fName, GetLastError());
  70         return -1;
  71     } else {
  72         return 0;
  73     }
  74 }
  75
  76 int JackWinNamedPipeClient::Connect(const char* dir, const char* name, int which)
  77 {
  78     sprintf(fName, "\\\\.\\pipe\\%s_jack_%s_%d", dir, name, which);
  79     jack_log("Connect: fName %s", fName);
  80
  81     fNamedPipe = CreateFile(fName,                       // pipe name
  82                             GENERIC_READ |   // read and write access
  83                             GENERIC_WRITE,
  84                             0,               // no sharing
  85                             NULL,            // default security attributes
  86                             OPEN_EXISTING,   // opens existing pipe
  87                             0,               // default attributes
  88                             NULL);          // no template file
  89
  90     if (fNamedPipe == INVALID_HANDLE_VALUE) {
  91         jack_error("Cannot connect to named pipe = %s err = %ld", fName, GetLastError());
  92         return -1;
  93     } else {
  94         return 0;
  95     }
  96 }
  97
  98 int JackWinNamedPipeClient::Close()
  99 {
 100     if (fNamedPipe != INVALID_HANDLE_VALUE) {
 101         CloseHandle(fNamedPipe);
 102         fNamedPipe = INVALID_HANDLE_VALUE;
 103         return 0;
 104     } else {
 105         return -1;
 106     }
 107 }
 108
 109 void JackWinNamedPipeClient::SetReadTimeOut(long sec)
 110 {}
 111
 112 void JackWinNamedPipeClient::SetWriteTimeOut(long sec)
 113 {}
 114
 115 JackWinAsyncNamedPipeClient::JackWinAsyncNamedPipeClient()
 116         : JackWinNamedPipeClient(), fPendingIO(false), fIOState(kIdle)
 117 {
 118     fIOState = kIdle;
 119     fOverlap.hEvent = CreateEvent(NULL,     // default security attribute
 120                                   TRUE,     // manual-reset event
 121                                   TRUE,     // initial state = signaled
 122                                   NULL);    // unnamed event object
 123 }
 124
 125 JackWinAsyncNamedPipeClient::JackWinAsyncNamedPipeClient(HANDLE pipe, bool pending)
 126         : JackWinNamedPipeClient(pipe), fPendingIO(pending), fIOState(kIdle)
 127 {
 128     fOverlap.hEvent = CreateEvent(NULL,     // default security attribute
 129                                   TRUE,     // manual-reset event
 130                                   TRUE,     // initial state = signaled
 131                                   NULL);        // unnamed event object
 132
 133     if (!fPendingIO)
 134         SetEvent(fOverlap.hEvent);
 135
 136     fIOState = (fPendingIO) ? kConnecting : kReading;
 137 }
 138
 139 JackWinAsyncNamedPipeClient::~JackWinAsyncNamedPipeClient()
 140 {
 141     CloseHandle(fOverlap.hEvent);
 142 }
 143
 144 int JackWinAsyncNamedPipeClient::FinishIO()
 145 {
 146     DWORD success, ret;
 147     success = GetOverlappedResult(fNamedPipe,   // handle to pipe
 148                                   &fOverlap,    // OVERLAPPED structure
 149                                   &ret,         // bytes transferred
 150                                   FALSE);       // do not wait
 151
 152     switch (fIOState) {
 153
 154         case kConnecting:
 155             if (!success) {
 156                 jack_error("Conection error");
 157                 return -1;
 158             } else {
 159                 fIOState = kReading;
 160                 // Prepare connection for new client ??
 161             }
 162             break;
 163
 164         case kReading:
 165             if (!success || ret == 0) {
 166                 return -1;
 167             }
 168             fIOState = kWriting;
 169             break;
 170
 171         case kWriting:
 172             if (!success || ret == 0) {
 173                 return -1;
 174             }
 175             fIOState = kReading;
 176             break;
 177
 178         default:
 179             break;
 180     }
 181
 182     return 0;
 183 }
 184
 185 int JackWinAsyncNamedPipeClient::Read(void* data, int len)
 186 {
 187     DWORD read;
 188     jack_log("JackWinNamedPipeClient::Read len = %ld", len);
 189     BOOL res = ReadFile(fNamedPipe, data, len, &read, &fOverlap);
 190     jack_log("JackWinNamedPipeClient::Read res = %ld read %ld", res, read);
 191
 192     if (res && read != 0) {
 193         fPendingIO = false;
 194         fIOState = kWriting;
 195         return 0;
 196     } else if (!res && GetLastError() == ERROR_IO_PENDING) {
 197         fPendingIO = true;
 198         return 0;
 199     } else {
 200         jack_error("Cannot read named pipe err = %ld", GetLastError());
 201         return -1;
 202     }
 203 }
 204
 205 int JackWinAsyncNamedPipeClient::Write(void* data, int len)
 206 {
 207     DWORD written;
 208     jack_log("JackWinNamedPipeClient::Write len = %ld", len);
 209     BOOL res = WriteFile(fNamedPipe, data, len, &written, &fOverlap);
 210
 211     if (res && written != 0) {
 212         fPendingIO = false;
 213         fIOState = kWriting;
 214         return 0;
 215     } else if (!res && GetLastError() == ERROR_IO_PENDING) {
 216         fPendingIO = true;
 217         return 0;
 218     } else {
 219         jack_error("Cannot write named pipe err = %ld", GetLastError());
 220         return -1;
 221     }
 222 }
 223
 224 // Server side
 225
 226 int JackWinNamedPipeServer::Bind(const char* dir, int which)
 227 {
 228     sprintf(fName, "\\\\.\\pipe\\%s_jack_%d", dir, which);
 229     jack_log("Bind: fName %s", fName);
 230
 231     if ((fNamedPipe = CreateNamedPipe(fName,
 232                                       PIPE_ACCESS_DUPLEX,  // read/write access
 233                                       PIPE_TYPE_MESSAGE |  // message type pipe
 234                                       PIPE_READMODE_MESSAGE |  // message-read mode
 235                                       PIPE_WAIT,  // blocking mode
 236                                       PIPE_UNLIMITED_INSTANCES,  // max. instances
 237                                       BUFSIZE,  // output buffer size
 238                                       BUFSIZE,  // input buffer size
 239                                       INFINITE,  // client time-out
 240                                       NULL)) == INVALID_HANDLE_VALUE) { // no security a
 241         jack_error("Cannot bind server to pipe err = %ld", GetLastError());
 242         return -1;
 243     } else {
 244         return 0;
 245     }
 246 }
 247
 248 int JackWinNamedPipeServer::Bind(const char* dir, const char* name, int which)
 249 {
 250     sprintf(fName, "\\\\.\\pipe\\%s_jack_%s_%d", dir, name, which);
 251     jack_log("Bind: fName %s", fName);
 252
 253     if ((fNamedPipe = CreateNamedPipe(fName,
 254                                       PIPE_ACCESS_DUPLEX,  // read/write access
 255                                       PIPE_TYPE_MESSAGE |  // message type pipe
 256                                       PIPE_READMODE_MESSAGE |  // message-read mode
 257                                       PIPE_WAIT,  // blocking mode
 258                                       PIPE_UNLIMITED_INSTANCES,  // max. instances
 259                                       BUFSIZE,  // output buffer size
 260                                       BUFSIZE,  // input buffer size
 261                                       INFINITE,  // client time-out
 262                                       NULL)) == INVALID_HANDLE_VALUE) { // no security a
 263         jack_error("Cannot bind server to pipe err = %ld", GetLastError());
 264         return -1;
 265     } else {
 266         return 0;
 267     }
 268 }
 269
 270 bool JackWinNamedPipeServer::Accept()
 271 {
 272     if (ConnectNamedPipe(fNamedPipe, NULL)) {
 273         return true;
 274     } else {
 275         jack_error("Cannot bind server pipe name = %s err = %ld", fName, GetLastError());
 276         if (GetLastError() == ERROR_PIPE_CONNECTED) {
 277             jack_error("pipe already connnected = %s ", fName);
 278             return true;
 279         } else {
 280             return false;
 281         }
 282     }
 283 }
 284
 285 JackWinNamedPipeClient* JackWinNamedPipeServer::AcceptClient()
 286 {
 287     if (ConnectNamedPipe(fNamedPipe, NULL)) {
 288         JackWinNamedPipeClient* client = new JackWinNamedPipeClient(fNamedPipe);
 289         // Init the pipe to the default value
 290         fNamedPipe = INVALID_HANDLE_VALUE;
 291         return client;
 292     } else {
 293         switch (GetLastError()) {
 294
 295             case ERROR_PIPE_CONNECTED:
 296                 return new JackWinNamedPipeClient(fNamedPipe);
 297
 298             default:
 299                 jack_error("Cannot connect server pipe name = %s  err = %ld", fName, GetLastError());
 300                 return NULL;
 301                 break;
 302         }
 303     }
 304 }
 305
 306 int JackWinNamedPipeServer::Close()
 307 {
 308     jack_log("JackWinNamedPipeServer::Close");
 309
 310     if (fNamedPipe != INVALID_HANDLE_VALUE) {
 311         DisconnectNamedPipe(fNamedPipe);
 312         CloseHandle(fNamedPipe);
 313         fNamedPipe = INVALID_HANDLE_VALUE;
 314         return 0;
 315     } else {
 316         return -1;
 317     }
 318 }
 319
 320 // Server side
 321
 322 int JackWinAsyncNamedPipeServer::Bind(const char* dir, int which)
 323 {
 324     sprintf(fName, "\\\\.\\pipe\\%s_jack_%d", dir, which);
 325     jack_log("Bind: fName %s", fName);
 326
 327     if ((fNamedPipe = CreateNamedPipe(fName,
 328                                       PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,  // read/write access
 329                                       PIPE_TYPE_MESSAGE |  // message type pipe
 330                                       PIPE_READMODE_MESSAGE |  // message-read mode
 331                                       PIPE_WAIT,  // blocking mode
 332                                       PIPE_UNLIMITED_INSTANCES,  // max. instances
 333                                       BUFSIZE,  // output buffer size
 334                                       BUFSIZE,  // input buffer size
 335                                       INFINITE,  // client time-out
 336                                       NULL)) == INVALID_HANDLE_VALUE) { // no security a
 337         jack_error("Cannot bind server to pipe err = %ld", GetLastError());
 338         return -1;
 339     } else {
 340         return 0;
 341     }
 342 }
 343
 344 int JackWinAsyncNamedPipeServer::Bind(const char* dir, const char* name, int which)
 345 {
 346     sprintf(fName, "\\\\.\\pipe\\%s_jack_%s_%d", dir, name, which);
 347     jack_log("Bind: fName %s", fName);
 348
 349     if ((fNamedPipe = CreateNamedPipe(fName,
 350                                       PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,  // read/write access
 351                                       PIPE_TYPE_MESSAGE |  // message type pipe
 352                                       PIPE_READMODE_MESSAGE |  // message-read mode
 353                                       PIPE_WAIT,  // blocking mode
 354                                       PIPE_UNLIMITED_INSTANCES,  // max. instances
 355                                       BUFSIZE,  // output buffer size
 356                                       BUFSIZE,  // input buffer size
 357                                       INFINITE,  // client time-out
 358                                       NULL)) == INVALID_HANDLE_VALUE) { // no security a
 359         jack_error("Cannot bind server to pipe err = %ld", GetLastError());
 360         return -1;
 361     } else {
 362         return 0;
 363     }
 364 }
 365
 366 bool JackWinAsyncNamedPipeServer::Accept()
 367 {
 368     return false;
 369 }
 370
 371 JackWinNamedPipeClient* JackWinAsyncNamedPipeServer::AcceptClient()
 372 {
 373     if (ConnectNamedPipe(fNamedPipe, NULL)) {
 374         return new JackWinAsyncNamedPipeClient(fNamedPipe, false);
 375     } else {
 376         switch (GetLastError()) {
 377
 378             case ERROR_IO_PENDING:
 379                 return new JackWinAsyncNamedPipeClient(fNamedPipe, true);
 380
 381             case ERROR_PIPE_CONNECTED:
 382                 return new JackWinAsyncNamedPipeClient(fNamedPipe, false);
 383
 384             default:
 385                 jack_error("Cannot connect server pipe name = %s  err = %ld", fName, GetLastError());
 386                 return NULL;
 387                 break;
 388         }
 389     }
 390 }
 391
 392 } // end of namespace
 393