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