Jack2: JackRequestDecoder.cpp Source File

00001 /*
00002 Copyright (C) 2012 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 #include "JackRequestDecoder.h"
00021 #include "JackServer.h"
00022 #include "JackLockedEngine.h"
00023 #include "JackChannel.h"
00024 
00025 #include <assert.h>
00026 #include <signal.h>
00027 
00028 using namespace std;
00029 
00030 namespace Jack
00031 {
00032 
00033 #define CheckRead(req, socket)          { if (req.Read(socket) <  0) { jack_error("CheckRead error"); return -1; } }
00034 #define CheckWriteName(error, socket)   { if (res.Write(socket) < 0) { jack_error("%s write error name = %s", error, req.fName); } }
00035 #define CheckWriteRefNum(error, socket) { if (res.Write(socket) < 0) { jack_error("%s write error ref = %d", error, req.fRefNum); } }
00036 #define CheckWrite(error, socket)       { if (res.Write(socket) < 0) { jack_error("%s write error", error); } }
00037 
00038 JackRequestDecoder::JackRequestDecoder(JackServer* server, JackClientHandlerInterface* handler)
00039     :fServer(server), fHandler(handler)
00040 {}
00041 
00042 JackRequestDecoder::~JackRequestDecoder()
00043 {}
00044 
00045 int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* socket, int type_aux)
00046 {
00047     JackRequest::RequestType type = (JackRequest::RequestType)type_aux;
00048 
00049     // Read data
00050     switch (type) {
00051 
00052         case JackRequest::kClientCheck: {
00053             jack_log("JackRequest::ClientCheck");
00054             JackClientCheckRequest req;
00055             JackClientCheckResult res;
00056             CheckRead(req, socket);
00057             res.fResult = fServer->GetEngine()->ClientCheck(req.fName, req.fUUID, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
00058             CheckWriteName("JackRequest::ClientCheck", socket);
00059             // Atomic ClientCheck followed by ClientOpen on same socket
00060             if (req.fOpen) {
00061                 JackRequest header;
00062                 header.Read(socket);
00063                 return HandleRequest(socket, header.fType);
00064             }
00065             break;
00066         }
00067 
00068         case JackRequest::kClientOpen: {
00069             jack_log("JackRequest::ClientOpen");
00070             JackClientOpenRequest req;
00071             JackClientOpenResult res;
00072             CheckRead(req, socket);
00073             fHandler->ClientAdd(socket, &req, &res);
00074             CheckWriteName("JackRequest::ClientOpen", socket);
00075             break;
00076         }
00077 
00078         case JackRequest::kClientClose: {
00079             jack_log("JackRequest::ClientClose");
00080             JackClientCloseRequest req;
00081             JackResult res;
00082             CheckRead(req, socket);
00083             res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
00084             CheckWriteRefNum("JackRequest::ClientClose", socket);
00085             fHandler->ClientRemove(socket, req.fRefNum);
00086             // Will cause the wrapping thread to stop
00087             return -1;
00088         }
00089 
00090         case JackRequest::kActivateClient: {
00091             JackActivateRequest req;
00092             JackResult res;
00093             jack_log("JackRequest::ActivateClient");
00094             CheckRead(req, socket);
00095             res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum, req.fIsRealTime);
00096             CheckWriteRefNum("JackRequest::ActivateClient", socket);
00097             break;
00098         }
00099 
00100         case JackRequest::kDeactivateClient: {
00101             jack_log("JackRequest::DeactivateClient");
00102             JackDeactivateRequest req;
00103             JackResult res;
00104             CheckRead(req, socket);
00105             res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
00106             CheckWriteRefNum("JackRequest::DeactivateClient", socket);
00107             break;
00108         }
00109 
00110         case JackRequest::kRegisterPort: {
00111             jack_log("JackRequest::RegisterPort");
00112             JackPortRegisterRequest req;
00113             JackPortRegisterResult res;
00114             CheckRead(req, socket);
00115             res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fPortType, req.fFlags, req.fBufferSize, &res.fPortIndex);
00116             CheckWriteRefNum("JackRequest::RegisterPort", socket);
00117             break;
00118         }
00119 
00120         case JackRequest::kUnRegisterPort: {
00121             jack_log("JackRequest::UnRegisterPort");
00122             JackPortUnRegisterRequest req;
00123             JackResult res;
00124             CheckRead(req, socket);
00125             res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);
00126             CheckWriteRefNum("JackRequest::UnRegisterPort", socket);
00127             break;
00128         }
00129 
00130         case JackRequest::kConnectNamePorts: {
00131             jack_log("JackRequest::ConnectNamePorts");
00132             JackPortConnectNameRequest req;
00133             JackResult res;
00134             CheckRead(req, socket);
00135             res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
00136             CheckWriteRefNum("JackRequest::ConnectNamePorts", socket);
00137             break;
00138         }
00139 
00140         case JackRequest::kDisconnectNamePorts: {
00141             jack_log("JackRequest::DisconnectNamePorts");
00142             JackPortDisconnectNameRequest req;
00143             JackResult res;
00144             CheckRead(req, socket);
00145             res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
00146             CheckWriteRefNum("JackRequest::DisconnectNamePorts", socket);
00147             break;
00148         }
00149 
00150         case JackRequest::kConnectPorts: {
00151             jack_log("JackRequest::ConnectPorts");
00152             JackPortConnectRequest req;
00153             JackResult res;
00154             CheckRead(req, socket);
00155             res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
00156             CheckWriteRefNum("JackRequest::ConnectPorts", socket);
00157             break;
00158         }
00159 
00160         case JackRequest::kDisconnectPorts: {
00161             jack_log("JackRequest::DisconnectPorts");
00162             JackPortDisconnectRequest req;
00163             JackResult res;
00164             CheckRead(req, socket);
00165             res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
00166             CheckWriteRefNum("JackRequest::DisconnectPorts", socket);
00167             break;
00168         }
00169 
00170         case JackRequest::kPortRename: {
00171             jack_log("JackRequest::PortRename");
00172             JackPortRenameRequest req;
00173             JackResult res;
00174             CheckRead(req, socket);
00175             res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
00176             CheckWriteRefNum("JackRequest::PortRename", socket);
00177             break;
00178         }
00179 
00180         case JackRequest::kSetBufferSize: {
00181             jack_log("JackRequest::SetBufferSize");
00182             JackSetBufferSizeRequest req;
00183             JackResult res;
00184             CheckRead(req, socket);
00185             res.fResult = fServer->SetBufferSize(req.fBufferSize);
00186             CheckWrite("JackRequest::SetBufferSize", socket);
00187             break;
00188         }
00189 
00190         case JackRequest::kSetFreeWheel: {
00191             jack_log("JackRequest::SetFreeWheel");
00192             JackSetFreeWheelRequest req;
00193             JackResult res;
00194             CheckRead(req, socket);
00195             res.fResult = fServer->SetFreewheel(req.fOnOff);
00196             CheckWrite("JackRequest::SetFreeWheel", socket);
00197             break;
00198         }
00199 
00200          case JackRequest::kComputeTotalLatencies: {
00201             jack_log("JackRequest::ComputeTotalLatencies");
00202             JackComputeTotalLatenciesRequest req;
00203             JackResult res;
00204             CheckRead(req, socket);
00205             res.fResult = fServer->GetEngine()->ComputeTotalLatencies();
00206             CheckWrite("JackRequest::ComputeTotalLatencies", socket);
00207             break;
00208         }
00209 
00210         case JackRequest::kReleaseTimebase: {
00211             jack_log("JackRequest::ReleaseTimebase");
00212             JackReleaseTimebaseRequest req;
00213             JackResult res;
00214             CheckRead(req, socket);
00215             res.fResult = fServer->ReleaseTimebase(req.fRefNum);
00216             CheckWriteRefNum("JackRequest::ReleaseTimebase", socket);
00217             break;
00218         }
00219 
00220         case JackRequest::kSetTimebaseCallback: {
00221             jack_log("JackRequest::SetTimebaseCallback");
00222             JackSetTimebaseCallbackRequest req;
00223             JackResult res;
00224             CheckRead(req, socket);
00225             res.fResult = fServer->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
00226             CheckWriteRefNum("JackRequest::SetTimebaseCallback", socket);
00227             break;
00228         }
00229 
00230         case JackRequest::kGetInternalClientName: {
00231             jack_log("JackRequest::GetInternalClientName");
00232             JackGetInternalClientNameRequest req;
00233             JackGetInternalClientNameResult res;
00234             CheckRead(req, socket);
00235             res.fResult = fServer->GetEngine()->GetInternalClientName(req.fIntRefNum, res.fName);
00236             CheckWriteRefNum("JackRequest::GetInternalClientName", socket);
00237             break;
00238         }
00239 
00240         case JackRequest::kInternalClientHandle: {
00241             jack_log("JackRequest::InternalClientHandle");
00242             JackInternalClientHandleRequest req;
00243             JackInternalClientHandleResult res;
00244             CheckRead(req, socket);
00245             res.fResult = fServer->GetEngine()->InternalClientHandle(req.fName, &res.fStatus, &res.fIntRefNum);
00246             CheckWriteRefNum("JackRequest::InternalClientHandle", socket);
00247             break;
00248         }
00249 
00250         case JackRequest::kInternalClientLoad: {
00251             jack_log("JackRequest::InternalClientLoad");
00252             JackInternalClientLoadRequest req;
00253             JackInternalClientLoadResult res;
00254             CheckRead(req, socket);
00255             res.fResult = fServer->InternalClientLoad1(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, req.fUUID, &res.fStatus);
00256             CheckWriteName("JackRequest::InternalClientLoad", socket);
00257             break;
00258         }
00259 
00260         case JackRequest::kInternalClientUnload: {
00261             jack_log("JackRequest::InternalClientUnload");
00262             JackInternalClientUnloadRequest req;
00263             JackInternalClientUnloadResult res;
00264             CheckRead(req, socket);
00265             res.fResult = fServer->GetEngine()->InternalClientUnload(req.fIntRefNum, &res.fStatus);
00266             CheckWriteRefNum("JackRequest::InternalClientUnload", socket);
00267             break;
00268         }
00269 
00270         case JackRequest::kNotification: {
00271             jack_log("JackRequest::Notification");
00272             JackClientNotificationRequest req;
00273             CheckRead(req, socket);
00274             if (req.fNotify == kQUIT) {
00275                 jack_log("JackRequest::Notification kQUIT");
00276                 throw JackQuitException();
00277             } else {
00278                 fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
00279             }
00280             break;
00281         }
00282 
00283         case JackRequest::kSessionNotify: {
00284             jack_log("JackRequest::SessionNotify");
00285             JackSessionNotifyRequest req;
00286             CheckRead(req, socket);
00287             fServer->GetEngine()->SessionNotify(req.fRefNum, req.fDst, req.fEventType, req.fPath, socket, NULL);
00288             break;
00289         }
00290 
00291         case JackRequest::kSessionReply: {
00292             jack_log("JackRequest::SessionReply");
00293             JackSessionReplyRequest req;
00294             JackResult res;
00295             CheckRead(req, socket);
00296             res.fResult = fServer->GetEngine()->SessionReply(req.fRefNum);
00297             CheckWrite("JackRequest::SessionReply", socket);
00298             break;
00299         }
00300 
00301         case JackRequest::kGetClientByUUID: {
00302             jack_log("JackRequest::GetClientByUUID");
00303             JackGetClientNameRequest req;
00304             JackClientNameResult res;
00305             CheckRead(req, socket);
00306             res.fResult = fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName);
00307             CheckWrite("JackRequest::GetClientByUUID", socket);
00308             break;
00309         }
00310 
00311         case JackRequest::kGetUUIDByClient: {
00312             jack_log("JackRequest::GetUUIDByClient");
00313             JackGetUUIDRequest req;
00314             JackUUIDResult res;
00315             CheckRead(req, socket);
00316             res.fResult = fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID);
00317             CheckWrite("JackRequest::GetUUIDByClient", socket);
00318             break;
00319         }
00320 
00321         case JackRequest::kReserveClientName: {
00322             jack_log("JackRequest::ReserveClientName");
00323             JackReserveNameRequest req;
00324             JackResult res;
00325             CheckRead(req, socket);
00326             res.fResult = fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID);
00327             CheckWrite("JackRequest::ReserveClientName", socket);
00328             break;
00329         }
00330 
00331         case JackRequest::kClientHasSessionCallback: {
00332             jack_log("JackRequest::ClientHasSessionCallback");
00333             JackClientHasSessionCallbackRequest req;
00334             JackResult res;
00335             CheckRead(req, socket);
00336             res.fResult = fServer->GetEngine()->ClientHasSessionCallback(req.fName);
00337             CheckWrite("JackRequest::ClientHasSessionCallback", socket);
00338             break;
00339         }
00340 
00341         default:
00342             jack_error("Unknown request %ld", type);
00343             return -1;
00344     }
00345 
00346     return 0;
00347 }
00348 
00349 } // end of namespace
00350 
00351