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_log("HandleRequest: cannot read header");
00158 ClientKill(fd);
00159 return false;
00160 }
00161
00162
00163 switch (header.fType) {
00164
00165 case JackRequest::kClientCheck: {
00166 jack_log("JackRequest::ClientCheck");
00167 JackClientCheckRequest req;
00168 JackClientCheckResult res;
00169 if (req.Read(socket) == 0)
00170 res.fResult = fServer->GetEngine()->ClientCheck(req.fName, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
00171 if (res.Write(socket) < 0)
00172 jack_error("JackRequest::ClientCheck write error name = %s", req.fName);
00173 break;
00174 }
00175
00176 case JackRequest::kClientOpen: {
00177 jack_log("JackRequest::ClientOpen");
00178 JackClientOpenRequest req;
00179 JackClientOpenResult res;
00180 if (req.Read(socket) == 0)
00181 ClientAdd(fd, req.fName, req.fPID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
00182 if (res.Write(socket) < 0)
00183 jack_error("JackRequest::ClientOpen write error name = %s", req.fName);
00184 break;
00185 }
00186
00187 case JackRequest::kClientClose: {
00188 jack_log("JackRequest::ClientClose");
00189 JackClientCloseRequest req;
00190 JackResult res;
00191 if (req.Read(socket) == 0)
00192 res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
00193 if (res.Write(socket) < 0)
00194 jack_error("JackRequest::ClientClose write error ref = %d", req.fRefNum);
00195 ClientRemove(fd, req.fRefNum);
00196 break;
00197 }
00198
00199 case JackRequest::kActivateClient: {
00200 JackActivateRequest req;
00201 JackResult res;
00202 jack_log("JackRequest::ActivateClient");
00203 if (req.Read(socket) == 0)
00204 res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum, req.fState);
00205 if (res.Write(socket) < 0)
00206 jack_error("JackRequest::ActivateClient write error ref = %d", req.fRefNum);
00207 break;
00208 }
00209
00210 case JackRequest::kDeactivateClient: {
00211 jack_log("JackRequest::DeactivateClient");
00212 JackDeactivateRequest req;
00213 JackResult res;
00214 if (req.Read(socket) == 0)
00215 res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
00216 if (res.Write(socket) < 0)
00217 jack_error("JackRequest::DeactivateClient write error ref = %d", req.fRefNum);
00218 break;
00219 }
00220
00221 case JackRequest::kRegisterPort: {
00222 jack_log("JackRequest::RegisterPort");
00223 JackPortRegisterRequest req;
00224 JackPortRegisterResult res;
00225 if (req.Read(socket) == 0)
00226 res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fPortType, req.fFlags, req.fBufferSize, &res.fPortIndex);
00227 if (res.Write(socket) < 0)
00228 jack_error("JackRequest::RegisterPort write error ref = %d", req.fRefNum);
00229 break;
00230 }
00231
00232 case JackRequest::kUnRegisterPort: {
00233 jack_log("JackRequest::UnRegisterPort");
00234 JackPortUnRegisterRequest req;
00235 JackResult res;
00236 if (req.Read(socket) == 0)
00237 res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);
00238 if (res.Write(socket) < 0)
00239 jack_error("JackRequest::UnRegisterPort write error ref = %d", req.fRefNum);
00240 break;
00241 }
00242
00243 case JackRequest::kConnectNamePorts: {
00244 jack_log("JackRequest::ConnectNamePorts");
00245 JackPortConnectNameRequest req;
00246 JackResult res;
00247 if (req.Read(socket) == 0)
00248 res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
00249 if (res.Write(socket) < 0)
00250 jack_error("JackRequest::ConnectNamePorts write error ref = %d", req.fRefNum);
00251 break;
00252 }
00253
00254 case JackRequest::kDisconnectNamePorts: {
00255 jack_log("JackRequest::DisconnectNamePorts");
00256 JackPortDisconnectNameRequest req;
00257 JackResult res;
00258 if (req.Read(socket) == 0)
00259 res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
00260 if (res.Write(socket) < 0)
00261 jack_error("JackRequest::DisconnectNamePorts write error ref = %d", req.fRefNum);
00262 break;
00263 }
00264
00265 case JackRequest::kConnectPorts: {
00266 jack_log("JackRequest::ConnectPorts");
00267 JackPortConnectRequest req;
00268 JackResult res;
00269 if (req.Read(socket) == 0)
00270 res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
00271 if (res.Write(socket) < 0)
00272 jack_error("JackRequest::ConnectPorts write error ref = %d", req.fRefNum);
00273 break;
00274 }
00275
00276 case JackRequest::kDisconnectPorts: {
00277 jack_log("JackRequest::DisconnectPorts");
00278 JackPortDisconnectRequest req;
00279 JackResult res;
00280 if (req.Read(socket) == 0)
00281 res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
00282 if (res.Write(socket) < 0)
00283 jack_error("JackRequest::DisconnectPorts write error ref = %d", req.fRefNum);
00284 break;
00285 }
00286
00287 case JackRequest::kPortRename: {
00288 jack_log("JackRequest::PortRename");
00289 JackPortRenameRequest req;
00290 JackResult res;
00291 if (req.Read(socket) == 0)
00292 res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
00293 if (res.Write(socket) < 0)
00294 jack_error("JackRequest::PortRename write error ref = %d", req.fRefNum);
00295 break;
00296 }
00297
00298 case JackRequest::kSetBufferSize: {
00299 jack_log("JackRequest::SetBufferSize");
00300 JackSetBufferSizeRequest req;
00301 JackResult res;
00302 if (req.Read(socket) == 0)
00303 res.fResult = fServer->SetBufferSize(req.fBufferSize);
00304 if (res.Write(socket) < 0)
00305 jack_error("JackRequest::SetBufferSize write error");
00306 break;
00307 }
00308
00309 case JackRequest::kSetFreeWheel: {
00310 jack_log("JackRequest::SetFreeWheel");
00311 JackSetFreeWheelRequest req;
00312 JackResult res;
00313 if (req.Read(socket) == 0)
00314 res.fResult = fServer->SetFreewheel(req.fOnOff);
00315 if (res.Write(socket) < 0)
00316 jack_error("JackRequest::SetFreeWheel write error");
00317 break;
00318 }
00319
00320 case JackRequest::kReleaseTimebase: {
00321 jack_log("JackRequest::ReleaseTimebase");
00322 JackReleaseTimebaseRequest req;
00323 JackResult res;
00324 if (req.Read(socket) == 0)
00325 res.fResult = fServer->ReleaseTimebase(req.fRefNum);
00326 if (res.Write(socket) < 0)
00327 jack_error("JackRequest::ReleaseTimebase write error ref = %d", req.fRefNum);
00328 break;
00329 }
00330
00331 case JackRequest::kSetTimebaseCallback: {
00332 jack_log("JackRequest::SetTimebaseCallback");
00333 JackSetTimebaseCallbackRequest req;
00334 JackResult res;
00335 if (req.Read(socket) == 0)
00336 res.fResult = fServer->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
00337 if (res.Write(socket) < 0)
00338 jack_error("JackRequest::SetTimebaseCallback write error ref = %d", req.fRefNum);
00339 break;
00340 }
00341
00342 case JackRequest::kGetInternalClientName: {
00343 jack_log("JackRequest::GetInternalClientName");
00344 JackGetInternalClientNameRequest req;
00345 JackGetInternalClientNameResult res;
00346 if (req.Read(socket) == 0)
00347 res.fResult = fServer->GetEngine()->GetInternalClientName(req.fIntRefNum, res.fName);
00348 if (res.Write(socket) < 0)
00349 jack_error("JackRequest::GetInternalClientName write error ref = %d", req.fRefNum);
00350 break;
00351 }
00352
00353 case JackRequest::kInternalClientHandle: {
00354 jack_log("JackRequest::InternalClientHandle");
00355 JackInternalClientHandleRequest req;
00356 JackInternalClientHandleResult res;
00357 if (req.Read(socket) == 0)
00358 res.fResult = fServer->GetEngine()->InternalClientHandle(req.fName, &res.fStatus, &res.fIntRefNum);
00359 if (res.Write(socket) < 0)
00360 jack_error("JackRequest::InternalClientHandle write error ref = %d", req.fRefNum);
00361 break;
00362 }
00363
00364 case JackRequest::kInternalClientLoad: {
00365 jack_log("JackRequest::InternalClientLoad");
00366 JackInternalClientLoadRequest req;
00367 JackInternalClientLoadResult res;
00368 if (req.Read(socket) == 0)
00369 res.fResult = fServer->InternalClientLoad(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, &res.fStatus);
00370 if (res.Write(socket) < 0)
00371 jack_error("JackRequest::InternalClientLoad write error name = %s", req.fName);
00372 break;
00373 }
00374
00375 case JackRequest::kInternalClientUnload: {
00376 jack_log("JackRequest::InternalClientUnload");
00377 JackInternalClientUnloadRequest req;
00378 JackInternalClientUnloadResult res;
00379 if (req.Read(socket) == 0)
00380 res.fResult = fServer->GetEngine()->InternalClientUnload(req.fIntRefNum, &res.fStatus);
00381 if (res.Write(socket) < 0)
00382 jack_error("JackRequest::InternalClientUnload write error ref = %d", req.fRefNum);
00383 break;
00384 }
00385
00386 case JackRequest::kNotification: {
00387 jack_log("JackRequest::Notification");
00388 JackClientNotificationRequest req;
00389 if (req.Read(socket) == 0)
00390 fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
00391 break;
00392 }
00393
00394 default:
00395 jack_error("Unknown request %ld", header.fType);
00396 break;
00397 }
00398
00399 return true;
00400 }
00401
00402 void JackSocketServerChannel::BuildPoolTable()
00403 {
00404 if (fRebuild) {
00405 fRebuild = false;
00406 delete[] fPollTable;
00407 fPollTable = new pollfd[fSocketTable.size() + 1];
00408
00409 jack_log("JackSocketServerChannel::BuildPoolTable size = %d", fSocketTable.size() + 1);
00410
00411
00412 fPollTable[0].fd = fRequestListenSocket.GetFd();
00413 fPollTable[0].events = POLLIN | POLLERR;
00414
00415
00416 map<int, pair<int, JackClientSocket*> >::iterator it;
00417 int i;
00418
00419 for (i = 1, it = fSocketTable.begin(); it != fSocketTable.end(); it++, i++) {
00420 jack_log("fSocketTable i = %ld fd = %ld", i, it->first);
00421 fPollTable[i].fd = it->first;
00422 fPollTable[i].events = POLLIN | POLLPRI | POLLERR | POLLHUP | POLLNVAL;
00423 }
00424 }
00425 }
00426
00427 bool JackSocketServerChannel::Init()
00428 {
00429 sigset_t set;
00430 sigemptyset(&set);
00431 sigaddset(&set, SIGPIPE);
00432 pthread_sigmask(SIG_BLOCK, &set, 0);
00433 return true;
00434 }
00435
00436 bool JackSocketServerChannel::Execute()
00437 {
00438
00439 if ((poll(fPollTable, fSocketTable.size() + 1, 10000) < 0) && (errno != EINTR)) {
00440 jack_error("Engine poll failed err = %s request thread quits...", strerror(errno));
00441 return false;
00442 } else {
00443
00444
00445 for (unsigned int i = 1; i < fSocketTable.size() + 1; i++) {
00446 int fd = fPollTable[i].fd;
00447 jack_log("fPollTable i = %ld fd = %ld", i, fd);
00448 if (fPollTable[i].revents & ~POLLIN) {
00449 jack_log("Poll client error err = %s", strerror(errno));
00450 ClientKill(fd);
00451 } else if (fPollTable[i].revents & POLLIN) {
00452 if (!HandleRequest(fd))
00453 jack_log("Could not handle external client request");
00454 }
00455 }
00456
00457
00458 if (fPollTable[0].revents & POLLERR)
00459 jack_error("Error on server request socket err = %s", strerror(errno));
00460
00461 if (fPollTable[0].revents & POLLIN)
00462 ClientCreate();
00463 }
00464
00465 BuildPoolTable();
00466 return true;
00467 }
00468
00469 }
00470
00471