JackSocketServerChannel.cpp

00001 /*
00002 Copyright (C) 2004-2006 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 "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     // Prepare request socket
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     // Prepare for poll
00059     BuildPoolTable();
00060 
00061     // Start listening
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) {  // Should never happen... correspond to a client that started the socket but never opened...
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     // Read header
00145     JackRequest header;
00146     if (header.Read(socket) < 0) {
00147         jack_error("HandleRequest: cannot read header");
00148         return -1;
00149     }
00150 
00151     // Read data
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         // First fd is the server request socket
00371         fPollTable[0].fd = fRequestListenSocket.GetFd();
00372         fPollTable[0].events = POLLIN | POLLERR;
00373 
00374         // Next fd for clients
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     // Global poll
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         // Poll all clients
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                     //ClientRemove(fd); TO CHECK
00405                 }
00406             }
00407         }
00408 
00409         // Check the server request socket */
00410         if (fPollTable[0].revents & POLLERR) {
00411             jack_error("Error on server request socket err = %s", strerror(errno));
00412             //return false; TO CHECK
00413         }
00414 
00415         if (fPollTable[0].revents & POLLIN) {
00416             CreateClient();
00417         }
00418     }
00419 
00420     BuildPoolTable();
00421     return true;
00422 }
00423 
00424 } // end of namespace
00425 
00426 

Generated on Mon Oct 15 17:11:14 2007 for Jackdmp by  doxygen 1.5.1