00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
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;
00039
00040
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)
00058 {
00059 fServer = server;
00060
00061
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()
00071 {
00072 JackLog("JackClientPipeThread::Close %x %ld\n", this, fRefNum);
00073
00074
00075
00076
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
00093 JackRequest header;
00094 int res = header.Read(fPipe);
00095 int ret = 0;
00096
00097
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
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
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
00292
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) {
00303 JackLog("Kill a closed client\n");
00304 } else if (fRefNum == 0) {
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
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
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
00359
00360
00361
00362
00363
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
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
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
00425 fClientList.push_back(client);
00426 }
00427
00428 }
00429
00430