windows/JackWinNamedPipe.h

   1 /*
   2  Copyright (C) 2004-2008 Grame
   3
   4  This program is free software; you can redistribute it and/or modify
   5  it under the terms of the GNU Lesser General Public License as published by
   6  the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  13
  14  You should have received a copy of the GNU Lesser General Public License
  15  along with this program; if not, write to the Free Software
  16  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18  */
  19
  20
  21 #ifndef __JackWinNamedPipe__
  22 #define __JackWinNamedPipe__
  23
  24 #ifdef __MINGW32__
  25 #include <winsock2.h>
  26 #endif
  27 #include <windows.h>
  28
  29 #include "JackChannel.h"
  30
  31 namespace Jack
  32 {
  33
  34 class JackWinNamedPipeAux
  35 {
  36
  37     protected:
  38
  39         HANDLE fNamedPipe;
  40         char fName[256];
  41
  42         int ReadAux(void* data, int len);
  43         int WriteAux(void* data, int len);
  44
  45     public:
  46
  47         JackWinNamedPipeAux(): fNamedPipe(INVALID_HANDLE_VALUE)
  48         {}
  49         JackWinNamedPipeAux(HANDLE pipe): fNamedPipe(pipe)
  50         {}
  51         virtual ~JackWinNamedPipeAux()
  52         {}
  53
  54 };
  55
  56
  57 class JackWinNamedPipe : public JackWinNamedPipeAux, public detail::JackChannelTransactionInterface
  58 {
  59
  60     public:
  61
  62         JackWinNamedPipe():JackWinNamedPipeAux()
  63         {}
  64         JackWinNamedPipe(HANDLE pipe):JackWinNamedPipeAux(pipe)
  65         {}
  66         virtual ~JackWinNamedPipe()
  67         {}
  68
  69         virtual int Read(void* data, int len)
  70         {
  71             return ReadAux(data, len);
  72         }
  73         virtual int Write(void* data, int len)
  74         {
  75             return WriteAux(data, len);
  76         }
  77 };
  78
  79 /*!
  80 \brief Client named pipe.
  81 */
  82
  83 class JackWinNamedPipeClient : public JackWinNamedPipeAux, public detail::JackClientRequestInterface
  84 {
  85
  86     protected:
  87
  88         int ConnectAux();
  89
  90     public:
  91
  92         JackWinNamedPipeClient():JackWinNamedPipeAux()
  93         {}
  94         JackWinNamedPipeClient(HANDLE pipe, const char* name):JackWinNamedPipeAux(pipe)
  95         {
  96             strcpy(fName, name);
  97         }
  98
  99         virtual ~JackWinNamedPipeClient()
 100         {}
 101
 102         virtual int Connect(const char* dir, int which);
 103         virtual int Connect(const char* dir, const char* name, int which);
 104         virtual int Close();
 105
 106         virtual int Read(void* data, int len)
 107         {
 108             return ReadAux(data, len);
 109         }
 110         virtual int Write(void* data, int len)
 111         {
 112             return WriteAux(data, len);
 113         }
 114
 115         virtual void SetReadTimeOut(long sec);
 116         virtual void SetWriteTimeOut(long sec);
 117
 118         virtual void SetNonBlocking(bool onoff);
 119 };
 120
 121 class JackWinAsyncNamedPipeClient : public JackWinNamedPipeClient
 122 {
 123         enum kIOState {kIdle = 0, kConnecting, kReading, kWriting};
 124
 125     private:
 126
 127         bool fPendingIO;
 128         kIOState fIOState;
 129         OVERLAPPED fOverlap;
 130
 131     public:
 132
 133         JackWinAsyncNamedPipeClient();
 134         JackWinAsyncNamedPipeClient(HANDLE pipe, const char* name, bool pending);
 135         virtual ~JackWinAsyncNamedPipeClient();
 136
 137         virtual int Read(void* data, int len);
 138         virtual int Write(void* data, int len);
 139
 140         HANDLE GetEvent()
 141         {
 142             return (HANDLE)fOverlap.hEvent;
 143         }
 144
 145         kIOState GetIOState()
 146         {
 147             return fIOState;
 148         }
 149
 150         bool GetPending()
 151         {
 152             return fPendingIO;
 153         }
 154
 155         int FinishIO();
 156 };
 157
 158 /*!
 159 \brief Server named pipe.
 160 */
 161
 162 class JackWinNamedPipeServer : public JackWinNamedPipe
 163 {
 164     private:
 165
 166         int BindAux();
 167
 168     public:
 169
 170         JackWinNamedPipeServer(): JackWinNamedPipe()
 171         {}
 172         virtual ~JackWinNamedPipeServer()
 173         {}
 174
 175         virtual int Bind(const char* dir, int which);
 176         virtual int Bind(const char* dir, const char* name, int which);
 177         virtual bool Accept();
 178         virtual JackWinNamedPipeClient* AcceptClient();
 179         int Close();
 180 };
 181
 182 /*!
 183 \brief Server async named pipe.
 184 */
 185
 186 class JackWinAsyncNamedPipeServer : public JackWinNamedPipeServer
 187 {
 188
 189     private:
 190
 191         int BindAux();
 192
 193     public:
 194
 195         JackWinAsyncNamedPipeServer(): JackWinNamedPipeServer()
 196         {}
 197         virtual ~JackWinAsyncNamedPipeServer()
 198         {}
 199
 200         int Bind(const char* dir, int which);
 201         int Bind(const char* dir, const char* name, int which);
 202         bool Accept();
 203         JackWinNamedPipeClient* AcceptClient();
 204         int Close();
 205 };
 206
 207 } // end of namespace
 208
 209
 210 #endif
 211