Jack2 1.9.10
|
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