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