00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackSocketServerChannel.h"
00021 #include "JackRequest.h"
00022 #include "JackServer.h"
00023 #include "JackLockedEngine.h"
00024 #include "JackGlobals.h"
00025 #include "JackClient.h"
00026 #include "JackNotification.h"
00027 #include <assert.h>
00028 #include <signal.h>
00029
00030 using namespace std;
00031
00032 namespace Jack
00033 {
00034
00035 JackSocketServerChannel::JackSocketServerChannel():
00036 fThread(this)
00037 {
00038 fPollTable = NULL;
00039 fRebuild = true;
00040 }
00041
00042 JackSocketServerChannel::~JackSocketServerChannel()
00043 {
00044 delete[] fPollTable;
00045 }
00046
00047 int JackSocketServerChannel::Open(const char* server_name, JackServer* server)
00048 {
00049 jack_log("JackSocketServerChannel::Open ");
00050 fServer = server;
00051
00052
00053 if (fRequestListenSocket.Bind(jack_server_dir, server_name, 0) < 0) {
00054 jack_log("JackSocketServerChannel::Open : cannot create result listen socket");
00055 return -1;
00056 }
00057
00058
00059 BuildPoolTable();
00060
00061
00062 if (fThread.Start() != 0) {
00063 jack_error("Cannot start Jack server listener");
00064 goto error;
00065 }
00066
00067 return 0;
00068
00069 error:
00070 fRequestListenSocket.Close();
00071 return -1;
00072 }
00073
00074 void JackSocketServerChannel::Close()
00075 {
00076 fThread.Kill();
00077 fRequestListenSocket.Close();
00078
00079
00080 std::map<int, std::pair<int, JackClientSocket*> >::iterator it;
00081 for (it = fSocketTable.begin(); it != fSocketTable.end(); it++) {
00082 pair<int, JackClientSocket*> elem = (*it).second;
00083 JackClientSocket* socket = elem.second;
00084 assert(socket);
00085 socket->Close();
00086 delete socket;
00087 }
00088 }
00089
00090 void JackSocketServerChannel::ClientCreate()
00091 {
00092 jack_log("JackSocketServerChannel::ClientCreate socket");
00093 JackClientSocket* socket = fRequestListenSocket.Accept();
00094 if (socket) {
00095 fSocketTable[socket->GetFd()] = make_pair( -1, socket);
00096 fRebuild = true;
00097 } else {
00098 jack_error("Client socket cannot be created");
00099 }
00100 }
00101
00102 void JackSocketServerChannel::ClientAdd(int fd, char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
00103 {
00104 jack_log("JackSocketServerChannel::ClientAdd");
00105 int refnum = -1;
00106 *result = fServer->GetEngine()->ClientExternalOpen(name, pid, &refnum, shared_engine, shared_client, shared_graph);
00107 if (*result == 0) {
00108 fSocketTable[fd].first = refnum;
00109 fRebuild = true;
00110 } else {
00111 jack_error("Cannot create new client");
00112 }
00113 }
00114
00115 void JackSocketServerChannel::ClientRemove(int fd, int refnum)
00116 {
00117 pair<int, JackClientSocket*> elem = fSocketTable[fd];
00118 JackClientSocket* socket = elem.second;
00119 assert(socket);
00120 jack_log("JackSocketServerChannel::ClientRemove ref = %d", refnum);
00121 fSocketTable.erase(fd);
00122 socket->Close();
00123 delete socket;
00124 fRebuild = true;
00125 }
00126
00127 void JackSocketServerChannel::ClientKill(int fd)
00128 {
00129 pair<int, JackClientSocket*> elem = fSocketTable[fd];
00130 JackClientSocket* socket = elem.second;
00131 int refnum = elem.first;
00132
00133 assert(socket);
00134 jack_log("JackSocketServerChannel::ClientKill ref = %d", refnum);
00135
00136 if (refnum == -1) {
00137 jack_log("Client was not opened : probably correspond to server_check");
00138 } else {
00139 fServer->ClientKill(refnum);
00140 }
00141
00142 fSocketTable.erase(fd);
00143 socket->Close();
00144 delete socket;
00145 fRebuild = true;
00146 }
00147
00148 bool JackSocketServerChannel::HandleRequest(int fd)
00149 {
00150 pair<int, JackClientSocket*> elem = fSocketTable[fd];
00151 JackClientSocket* socket = elem.second;
00152 assert(socket);
00153
00154
00155 JackRequest header;
00156 if (header.Read(socket) < 0) {
00157 jack_error("HandleRequest: cannot read header");
00158 return false;
00159 }
00160
00161
00162 switch (header.fType) {
00163
00164 case JackRequest::kClientCheck: {
00165 jack_log("JackRequest::ClientCheck");
00166 JackClientCheckRequest req;
00167 JackClientCheckResult res;
00168 if (req.Read(socket) == 0)
00169 res.fResult = fServer->GetEngine()->ClientCheck(req.fName, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
00170 if (res.Write(socket) < 0)
00171 jack_error("JackRequest::ClientCheck write error name = %s", req.fName);
00172 break;
00173 }
00174
00175 case JackRequest::kClientOpen: {
00176 jack_log("JackRequest::ClientOpen");
00177 JackClientOpenRequest req;
00178 JackClientOpenResult res;
00179 if (req.Read(socket) == 0)
00180 ClientAdd(fd, req.fName, req.fPID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
00181 if (res.Write(socket) < 0)
00182 jack_error("JackRequest::ClientOpen write error name = %s", req.fName);
00183 break;
00184 }
00185
00186 case JackRequest::kClientClose: {
00187 jack_log("JackRequest::ClientClose");
00188 JackClientCloseRequest req;
00189 JackResult res;
00190 if (req.Read(socket) == 0)
00191 res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
00192 if (res.Write(socket) < 0)
00193 jack_error("JackRequest::ClientClose write error ref = %d", req.fRefNum);
00194 ClientRemove(fd, req.fRefNum);
00195 break;
00196 }
00197
00198 case JackRequest::kActivateClient: {
00199 JackActivateRequest req;
00200 JackResult res;
00201 jack_log("JackRequest::ActivateClient");
00202 if (req.Read(socket) == 0)
00203 res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum, req.fState);
00204 if (res.Write(socket) < 0)
00205 jack_error("JackRequest::ActivateClient write error ref = %d", req.fRefNum);
00206 break;
00207 }
00208
00209 case JackRequest::kDeactivateClient: {
00210 jack_log("JackRequest::DeactivateClient");
00211 JackDeactivateRequest req;
00212 JackResult res;
00213 if (req.Read(socket) == 0)
00214 res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
00215 if (res.Write(socket) < 0)
00216 jack_error("JackRequest::DeactivateClient write error ref = %d", req.fRefNum);
00217 break;
00218 }
00219
00220 case JackRequest::kRegisterPort: {
00221 jack_log("JackRequest::RegisterPort");
00222 JackPortRegisterRequest req;
00223 JackPortRegisterResult res;
00224 if (req.Read(socket) == 0)
00225 res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fPortType, req.fFlags, req.fBufferSize, &res.fPortIndex);
00226 if (res.Write(socket) < 0)
00227 jack_error("JackRequest::RegisterPort write error ref = %d", req.fRefNum);
00228 break;
00229 }
00230
00231 case JackRequest::kUnRegisterPort: {
00232 jack_log("JackRequest::UnRegisterPort");
00233 JackPortUnRegisterRequest req;
00234 JackResult res;
00235 if (req.Read(socket) == 0)
00236 res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);
00237 if (res.Write(socket) < 0)
00238 jack_error("JackRequest::UnRegisterPort write error ref = %d", req.fRefNum);
00239 break;
00240 }
00241
00242 case JackRequest::kConnectNamePorts: {
00243 jack_log("JackRequest::ConnectNamePorts");
00244 JackPortConnectNameRequest req;
00245 JackResult res;
00246 if (req.Read(socket) == 0)
00247 res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
00248 if (res.Write(socket) < 0)
00249 jack_error("JackRequest::ConnectNamePorts write error ref = %d", req.fRefNum);
00250 break;
00251 }
00252
00253 case JackRequest::kDisconnectNamePorts: {
00254 jack_log("JackRequest::DisconnectNamePorts");
00255 JackPortDisconnectNameRequest req;
00256 JackResult res;
00257 if (req.Read(socket) == 0)
00258 res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
00259 if (res.Write(socket) < 0)
00260 jack_error("JackRequest::DisconnectNamePorts write error ref = %d", req.fRefNum);
00261 break;
00262 }
00263
00264 case JackRequest::kConnectPorts: {
00265 jack_log("JackRequest::ConnectPorts");
00266 JackPortConnectRequest req;
00267 JackResult res;
00268 if (req.Read(socket) == 0)
00269 res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
00270 if (res.Write(socket) < 0)
00271 jack_error("JackRequest::ConnectPorts write error ref = %d", req.fRefNum);
00272 break;
00273 }
00274
00275 case JackRequest::kDisconnectPorts: {
00276 jack_log("JackRequest::DisconnectPorts");
00277 JackPortDisconnectRequest req;
00278 JackResult res;
00279 if (req.Read(socket) == 0)
00280 res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
00281 if (res.Write(socket) < 0)
00282 jack_error("JackRequest::DisconnectPorts write error ref = %d", req.fRefNum);
00283 break;
00284 }
00285
00286 case JackRequest::kPortRename: {
00287 jack_log("JackRequest::PortRename");
00288 JackPortRenameRequest req;
00289 JackResult res;
00290 if (req.Read(socket) == 0)
00291 res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
00292 if (res.Write(socket) < 0)
00293 jack_error("JackRequest::PortRename write error ref = %d", req.fRefNum);
00294 break;
00295 }
00296
00297 case JackRequest::kSetBufferSize: {
00298 jack_log("JackRequest::SetBufferSize");
00299 JackSetBufferSizeRequest req;
00300 JackResult res;
00301 if (req.Read(socket) == 0)
00302 res.fResult = fServer->SetBufferSize(req.fBufferSize);
00303 if (res.Write(socket) < 0)
00304 jack_error("JackRequest::SetBufferSize write error");
00305 break;
00306 }
00307
00308 case JackRequest::kSetFreeWheel: {
00309 jack_log("JackRequest::SetFreeWheel");
00310 JackSetFreeWheelRequest req;
00311 JackResult res;
00312 if (req.Read(socket) == 0)
00313 res.fResult = fServer->SetFreewheel(req.fOnOff);
00314 if (res.Write(socket) < 0)
00315 jack_error("JackRequest::SetFreeWheel write error");
00316 break;
00317 }
00318
00319 case JackRequest::kReleaseTimebase: {
00320 jack_log("JackRequest::ReleaseTimebase");
00321 JackReleaseTimebaseRequest req;
00322 JackResult res;
00323 if (req.Read(socket) == 0)
00324 res.fResult = fServer->ReleaseTimebase(req.fRefNum);
00325 if (res.Write(socket) < 0)
00326 jack_error("JackRequest::ReleaseTimebase write error ref = %d", req.fRefNum);
00327 break;
00328 }
00329
00330 case JackRequest::kSetTimebaseCallback: {
00331 jack_log("JackRequest::SetTimebaseCallback");
00332 JackSetTimebaseCallbackRequest req;
00333 JackResult res;
00334 if (req.Read(socket) == 0)
00335 res.fResult = fServer->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
00336 if (res.Write(socket) < 0)
00337 jack_error("JackRequest::SetTimebaseCallback write error ref = %d", req.fRefNum);
00338 break;
00339 }
00340
00341 case JackRequest::kGetInternalClientName: {
00342 jack_log("JackRequest::GetInternalClientName");
00343 JackGetInternalClientNameRequest req;
00344 JackGetInternalClientNameResult res;
00345 if (req.Read(socket) == 0)
00346 res.fResult = fServer->GetEngine()->GetInternalClientName(req.fIntRefNum, res.fName);
00347 if (res.Write(socket) < 0)
00348 jack_error("JackRequest::GetInternalClientName write error ref = %d", req.fRefNum);
00349 break;
00350 }
00351
00352 case JackRequest::kInternalClientHandle: {
00353 jack_log("JackRequest::InternalClientHandle");
00354 JackInternalClientHandleRequest req;
00355 JackInternalClientHandleResult res;
00356 if (req.Read(socket) == 0)
00357 res.fResult = fServer->GetEngine()->InternalClientHandle(req.fName, &res.fStatus, &res.fIntRefNum);
00358 if (res.Write(socket) < 0)
00359 jack_error("JackRequest::InternalClientHandle write error ref = %d", req.fRefNum);
00360 break;
00361 }
00362
00363 case JackRequest::kInternalClientLoad: {
00364 jack_log("JackRequest::InternalClientLoad");
00365 JackInternalClientLoadRequest req;
00366 JackInternalClientLoadResult res;
00367 if (req.Read(socket) == 0)
00368 res.fResult = fServer->InternalClientLoad(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, &res.fStatus);
00369 if (res.Write(socket) < 0)
00370 jack_error("JackRequest::InternalClientLoad write error name = %s", req.fName);
00371 break;
00372 }
00373
00374 case JackRequest::kInternalClientUnload: {
00375 jack_log("JackRequest::InternalClientUnload");
00376 JackInternalClientUnloadRequest req;
00377 JackInternalClientUnloadResult res;
00378 if (req.Read(socket) == 0)
00379 res.fResult = fServer->GetEngine()->InternalClientUnload(req.fIntRefNum, &res.fStatus);
00380 if (res.Write(socket) < 0)
00381 jack_error("JackRequest::InternalClientUnload write error ref = %d", req.fRefNum);
00382 break;
00383 }
00384
00385 case JackRequest::kNotification: {
00386 jack_log("JackRequest::Notification");
00387 JackClientNotificationRequest req;
00388 if (req.Read(socket) == 0)
00389 fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
00390 break;
00391 }
00392
00393 default:
00394 jack_log("Unknown request %ld", header.fType);
00395 break;
00396 }
00397
00398 return true;
00399 }
00400
00401 void JackSocketServerChannel::BuildPoolTable()
00402 {
00403 if (fRebuild) {
00404 fRebuild = false;
00405 delete[] fPollTable;
00406 fPollTable = new pollfd[fSocketTable.size() + 1];
00407
00408 jack_log("JackSocketServerChannel::BuildPoolTable size = %d", fSocketTable.size() + 1);
00409
00410
00411 fPollTable[0].fd = fRequestListenSocket.GetFd();
00412 fPollTable[0].events = POLLIN | POLLERR;
00413
00414
00415 map<int, pair<int, JackClientSocket*> >::iterator it;
00416 int i;
00417
00418 for (i = 1, it = fSocketTable.begin(); it != fSocketTable.end(); it++, i++) {
00419 jack_log("fSocketTable i = %ld fd = %ld", i, it->first);
00420 fPollTable[i].fd = it->first;
00421 fPollTable[i].events = POLLIN | POLLPRI | POLLERR | POLLHUP | POLLNVAL;
00422 }
00423 }
00424 }
00425
00426 bool JackSocketServerChannel::Init()
00427 {
00428 sigset_t set;
00429 sigemptyset(&set);
00430 sigaddset(&set, SIGPIPE);
00431 pthread_sigmask(SIG_BLOCK, &set, 0);
00432 return true;
00433 }
00434
00435 bool JackSocketServerChannel::Execute()
00436 {
00437
00438 if ((poll(fPollTable, fSocketTable.size() + 1, 10000) < 0) && (errno != EINTR)) {
00439 jack_error("Engine poll failed err = %s request thread quits...", strerror(errno));
00440 return false;
00441 } else {
00442
00443
00444 for (unsigned int i = 1; i < fSocketTable.size() + 1; i++) {
00445 int fd = fPollTable[i].fd;
00446 jack_log("fPollTable i = %ld fd = %ld", i, fd);
00447 if (fPollTable[i].revents & ~POLLIN) {
00448 jack_log("Poll client error err = %s", strerror(errno));
00449 ClientKill(fd);
00450 } else if (fPollTable[i].revents & POLLIN) {
00451 if (!HandleRequest(fd))
00452 jack_error("Could not handle external client request");
00453 }
00454 }
00455
00456
00457 if (fPollTable[0].revents & POLLERR)
00458 jack_error("Error on server request socket err = %s", strerror(errno));
00459
00460 if (fPollTable[0].revents & POLLIN)
00461 ClientCreate();
00462 }
00463
00464 BuildPoolTable();
00465 return true;
00466 }
00467
00468 }
00469
00470