JackWinNamedPipeServerChannel.cpp

00001 /*
00002 Copyright (C) 2004-2006 Grame  
00003   
00004   This program is free software; you can redistribute it and/or modify
00005   it under the terms of the GNU Lesser General Public License as published by
00006   the Free Software Foundation; either version 2.1 of the License, or
00007   (at your option) any later version.
00008   
00009   This program is distributed in the hope that it will be useful,
00010   but WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012   GNU Lesser General Public License for more details.
00013   
00014   You should have received a copy of the GNU Lesser General Public License
00015   along with this program; if not, write to the Free Software 
00016   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00017 
00018 */
00019 
00020 #ifdef WIN32 
00021 #pragma warning (disable : 4786)
00022 #endif
00023 
00024 #include "JackWinNamedPipeServerChannel.h"
00025 #include "JackNotification.h"
00026 #include "JackRequest.h"
00027 #include "JackServer.h"
00028 #include "JackEngine.h"
00029 #include "JackGlobals.h"
00030 #include "JackClient.h"
00031 #include <assert.h>
00032 
00033 using namespace std;
00034 
00035 namespace Jack
00036 {
00037 
00038 HANDLE JackClientPipeThread::fMutex = NULL;  // never released....
00039 
00040 // fRefNum = -1 correspond to already removed client
00041 
00042 JackClientPipeThread::JackClientPipeThread(JackWinNamedPipeClient* pipe)
00043         : fPipe(pipe), fServer(NULL), fRefNum(0)
00044 {
00045     fThread = JackGlobals::MakeThread(this);
00046     if (fMutex == NULL)
00047         fMutex = CreateMutex(NULL, FALSE, NULL);
00048 }
00049 
00050 JackClientPipeThread::~JackClientPipeThread()
00051 {
00052         JackLog("JackClientPipeThread::~JackClientPipeThread\n");
00053     delete fPipe;
00054     delete fThread;
00055 }
00056 
00057 int JackClientPipeThread::Open(JackServer* server)      // Open the Server/Client connection
00058 {
00059     fServer = server;
00060 
00061     // Start listening
00062     if (fThread->Start() != 0) {
00063         jack_error("Cannot start Jack server listener\n");
00064         return -1;
00065     } else {
00066         return 0;
00067     }
00068 }
00069 
00070 void JackClientPipeThread::Close()                                      // Close the Server/Client connection
00071 {
00072         JackLog("JackClientPipeThread::Close %x %ld\n", this, fRefNum);
00073         /*
00074                 TODO : solve WIN32 thread Kill issue
00075                 This would hang.. since Close will be followed by a delete, 
00076                 all ressources will be desallocated at the end.
00077         */
00078         
00079         fThread->Kill();
00080         fPipe->Close();
00081         fRefNum = -1;   
00082 }
00083 
00084 bool JackClientPipeThread::Execute()
00085 {
00086     JackLog("JackClientPipeThread::Execute\n");
00087         return (HandleRequest() == 0);
00088 }
00089 
00090 int JackClientPipeThread::HandleRequest()
00091 {
00092     // Read header
00093     JackRequest header;
00094         int res = header.Read(fPipe);
00095         int ret = 0;
00096 
00097     // Lock the global mutex
00098     if (WaitForSingleObject(fMutex, INFINITE) == WAIT_FAILED)
00099         jack_error("JackClientPipeThread::HandleRequest: mutex wait error");
00100 
00101         if (res < 0) {
00102                 jack_error("HandleRequest: cannot read header");
00103                 ClientKill();
00104                 ret = -1;
00105         } else {
00106 
00107                 // Read data
00108                 switch (header.fType) {
00109                 
00110                 case JackRequest::kClientCheck: {
00111                         JackLog("JackRequest::kClientCheck\n");
00112                         JackClientCheckRequest req;
00113                         JackClientCheckResult res;
00114                         if (req.Read(fPipe) == 0)
00115                                 res.fResult = fServer->GetEngine()->ClientCheck(req.fName, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
00116                         res.Write(fPipe);
00117                         break;
00118                 }
00119                         
00120                 case JackRequest::kClientOpen: {
00121                         JackLog("JackRequest::ClientOpen\n");
00122                         JackClientOpenRequest req;
00123                         JackClientOpenResult res;
00124                         if (req.Read(fPipe) == 0) 
00125                                 ClientAdd(req.fName, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);  
00126                         res.Write(fPipe);
00127                         break;
00128                 }
00129                         
00130                 case JackRequest::kClientClose: {
00131                         JackLog("JackRequest::ClientClose\n");
00132                         JackClientCloseRequest req;
00133                         JackResult res;
00134                         if (req.Read(fPipe) == 0) 
00135                                 res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);           
00136                         res.Write(fPipe);
00137                         ClientRemove();
00138                         ret = -1;
00139                         break;
00140                 }
00141                         
00142                 case JackRequest::kActivateClient: {
00143                         JackActivateRequest req;
00144                         JackResult res;
00145                         JackLog("JackRequest::ActivateClient\n");
00146                         if (req.Read(fPipe) == 0) 
00147                                 res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum);
00148                         res.Write(fPipe);
00149                         break;
00150                 }
00151                         
00152                 case JackRequest::kDeactivateClient: {
00153                         JackLog("JackRequest::DeactivateClient\n");
00154                         JackDeactivateRequest req;
00155                         JackResult res;
00156                         if (req.Read(fPipe) == 0) 
00157                                 res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
00158                         res.Write(fPipe);
00159                         break;
00160                 }
00161                         
00162                 case JackRequest::kRegisterPort: {
00163                         JackLog("JackRequest::RegisterPort\n");
00164                         JackPortRegisterRequest req;
00165                         JackPortRegisterResult res;
00166                         if (req.Read(fPipe) == 0) 
00167                                 res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fFlags, req.fBufferSize, &res.fPortIndex);         
00168                         res.Write(fPipe);
00169                         break;
00170                 }
00171                         
00172                 case JackRequest::kUnRegisterPort: {
00173                         JackLog("JackRequest::UnRegisterPort\n");
00174                         JackPortUnRegisterRequest req;
00175                         JackResult res;
00176                         if (req.Read(fPipe) == 0) 
00177                                 res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);                
00178                         res.Write(fPipe);
00179                         break;
00180                 }
00181                         
00182                 case JackRequest::kConnectNamePorts: {
00183                         JackLog("JackRequest::ConnectPorts\n");
00184                         JackPortConnectNameRequest req;
00185                         JackResult res;
00186                         if (req.Read(fPipe) == 0) 
00187                                 res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);                       
00188                         res.Write(fPipe);
00189                         break;
00190                 }
00191                         
00192                 case JackRequest::kDisconnectNamePorts: {
00193                         JackLog("JackRequest::DisconnectPorts\n");
00194                         JackPortDisconnectNameRequest req;
00195                         JackResult res;
00196                         if (req.Read(fPipe) == 0) 
00197                                 res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
00198                         res.Write(fPipe);
00199                         break;
00200                 }
00201                         
00202                 case JackRequest::kConnectPorts: {
00203                         JackLog("JackRequest::ConnectPorts\n");
00204                         JackPortConnectRequest req;
00205                         JackResult res;
00206                         if (req.Read(fPipe) == 0) 
00207                                 res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
00208                         res.Write(fPipe);
00209                         break;
00210                 }
00211                         
00212                 case JackRequest::kDisconnectPorts: {
00213                         JackLog("JackRequest::DisconnectPorts\n");
00214                         JackPortDisconnectRequest req;
00215                         JackResult res;
00216                         if (req.Read(fPipe) == 0) 
00217                                 res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
00218                         res.Write(fPipe);
00219                         break;
00220                 }
00221                         
00222                 case JackRequest::kSetBufferSize: {
00223                         JackLog("JackRequest::SetBufferSize\n");
00224                         JackSetBufferSizeRequest req;
00225                         JackResult res;
00226                         if (req.Read(fPipe) == 0) 
00227                                 res.fResult = fServer->SetBufferSize(req.fBufferSize);
00228                         res.Write(fPipe);
00229                         break;
00230                 }
00231                         
00232                 case JackRequest::kSetFreeWheel: {
00233                         JackLog("JackRequest::SetFreeWheel\n");
00234                         JackSetFreeWheelRequest req;
00235                         JackResult res;
00236                         if (req.Read(fPipe) == 0) 
00237                                 res.fResult = fServer->SetFreewheel(req.fOnOff);
00238                         res.Write(fPipe);
00239                         break;
00240                 }
00241                         
00242                 case JackRequest::kReleaseTimebase: {
00243                         JackLog("JackRequest::kReleaseTimebase\n");
00244                         JackReleaseTimebaseRequest req;
00245                         JackResult res;
00246                         if (req.Read(fPipe) == 0) 
00247                                 res.fResult = fServer->GetEngine()->ReleaseTimebase(req.fRefNum);
00248                         res.Write(fPipe);
00249                         break;
00250                 }
00251                         
00252                 case JackRequest::kSetTimebaseCallback: {
00253                         JackLog("JackRequest::kSetTimebaseCallback\n");
00254                         JackSetTimebaseCallbackRequest req;
00255                         JackResult res;
00256                         if (req.Read(fPipe) == 0) 
00257                                 res.fResult = fServer->GetEngine()->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
00258                         res.Write(fPipe);
00259                         break;
00260                 }
00261                         
00262                 case JackRequest::kNotification: {
00263                         JackLog("JackRequest::Notification\n");
00264                         JackClientNotificationRequest req;
00265                         if (req.Read(fPipe) == 0) 
00266                                 fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
00267                         break;
00268                 }
00269                         
00270                 default:
00271                         JackLog("Unknown request %ld\n", header.fType);
00272                         break;
00273                 }
00274         }
00275 
00276     // Unlock the global mutex
00277     ReleaseMutex(fMutex);
00278     return ret;
00279 }
00280 
00281 void JackClientPipeThread::ClientAdd(char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
00282 {
00283     JackLog("JackClientPipeThread::ClientAdd %s\n", name);
00284     fRefNum = -1;
00285     *result = fServer->GetEngine()->ClientExternalOpen(name, &fRefNum, shared_engine, shared_client, shared_graph);
00286 }
00287 
00288 void JackClientPipeThread::ClientRemove()
00289 {
00290     JackLog("JackClientPipeThread::ClientRemove ref = %d\n", fRefNum);
00291          /* TODO : solve WIN32 thread Kill issue
00292                 Close();
00293         */
00294         fRefNum = -1;
00295         fPipe->Close();
00296 }
00297 
00298 void JackClientPipeThread::ClientKill()
00299 {
00300     JackLog("JackClientPipeThread::ClientKill ref = %d\n", fRefNum);
00301 
00302     if (fRefNum == -1) {                // Correspond to an already removed client.
00303         JackLog("Kill a closed client\n");
00304         } else if (fRefNum == 0) {  // Correspond to a still not opened client.
00305         JackLog("Kill a not opened client\n");  
00306     } else {
00307         fServer->Notify(fRefNum, kDeadClient, 0);
00308     }
00309 
00310     Close();
00311 }
00312 
00313 JackWinNamedPipeServerChannel::JackWinNamedPipeServerChannel()
00314 {
00315     fThread = JackGlobals::MakeThread(this);
00316 }
00317 
00318 JackWinNamedPipeServerChannel::~JackWinNamedPipeServerChannel()
00319 {
00320         std::list<JackClientPipeThread*>::iterator it;
00321 
00322         for (it = fClientList.begin(); it !=  fClientList.end(); it++) {
00323                 JackClientPipeThread* client = *it;
00324                 client->Close();
00325                 delete client;
00326         }
00327 
00328     delete fThread;
00329 }
00330 
00331 int JackWinNamedPipeServerChannel::Open(JackServer* server)
00332 {
00333     JackLog("JackWinNamedPipeServerChannel::Open \n");
00334 
00335     fServer = server;
00336 
00337     // Needed for internal connection from JackWinNamedPipeServerNotifyChannel object
00338     if (fRequestListenPipe.Bind(jack_server_dir, 0) < 0) {
00339         jack_error("JackWinNamedPipeServerChannel::Open : cannot create result listen pipe");
00340         return false;
00341     }
00342 
00343     // Start listening
00344     if (fThread->Start() != 0) {
00345         jack_error("Cannot start Jack server listener\n");
00346         goto error;
00347     }
00348 
00349     return 0;
00350 
00351 error:
00352     fRequestListenPipe.Close();
00353     return -1;
00354 }
00355 
00356 void JackWinNamedPipeServerChannel::Close()
00357 {
00358         /* TODO : solve WIN32 thread Kill issue
00359                 This would hang the server... since we are quitting it, its not really problematic, 
00360                 all ressources will be desallocated at the end.
00361                 
00362                 fRequestListenPipe.Close();
00363                 fThread->Stop();
00364         */
00365         
00366         fThread->Kill();
00367         fRequestListenPipe.Close();
00368 }
00369 
00370 bool JackWinNamedPipeServerChannel::Init()
00371 {
00372     JackLog("JackWinNamedPipeServerChannel::Init \n");
00373     JackWinNamedPipeClient* pipe;
00374 
00375         // Accept first client, that is the JackWinNamedPipeServerNotifyChannel object
00376     if ((pipe = fRequestListenPipe.AcceptClient()) == NULL) {
00377         jack_error("JackWinNamedPipeServerChannel::Init : cannot connect pipe");
00378         return false;
00379     } else {
00380         ClientAdd(pipe);
00381         return true;
00382     }
00383 }
00384 
00385 bool JackWinNamedPipeServerChannel::Execute()
00386 {
00387     JackWinNamedPipeClient* pipe;
00388 
00389     if (fRequestListenPipe.Bind(jack_server_dir, 0) < 0) {
00390         jack_error("JackWinNamedPipeServerChannel::Open : cannot create result listen pipe");
00391         return false;
00392     }
00393 
00394     if ((pipe = fRequestListenPipe.AcceptClient()) == NULL) {
00395         jack_error("JackWinNamedPipeServerChannel::Open : cannot connect pipe");
00396         return false;
00397     }
00398 
00399     ClientAdd(pipe);
00400     return true;
00401 }
00402 
00403 void JackWinNamedPipeServerChannel::ClientAdd(JackWinNamedPipeClient* pipe)
00404 {
00405     // Remove dead (= not running anymore) clients.
00406     std::list<JackClientPipeThread*>::iterator it = fClientList.begin();
00407     JackClientPipeThread* client;
00408 
00409         JackLog("ClientAdd size  %ld\n", fClientList.size());
00410 
00411     while (it != fClientList.end()) {           
00412         client = *it;
00413                 JackLog("Remove dead client = %x running =  %ld\n", client, client->IsRunning());
00414         if (client->IsRunning()) {
00415                         it++;         
00416         } else {  
00417             it = fClientList.erase(it);
00418             delete client;
00419         }
00420     }
00421 
00422     client = new JackClientPipeThread(pipe);
00423     client->Open(fServer);
00424         // Here we are sure that the client is running (because it's thread is in "running" state).
00425     fClientList.push_back(client);
00426 }
00427 
00428 } // end of namespace
00429 
00430 

Generated on Mon Oct 15 17:11:14 2007 for Jackdmp by  doxygen 1.5.1