common/JackInternalClient.cpp

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2008 Grame
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #include "JackSystemDeps.h"
  22 #include "JackServerGlobals.h"
  23 #include "JackGraphManager.h"
  24 #include "JackConstants.h"
  25 #include "JackInternalClient.h"
  26 #include "JackLockedEngine.h"
  27 #include "JackServer.h"
  28 #include "JackEngineControl.h"
  29 #include "JackClientControl.h"
  30 #include "JackInternalClientChannel.h"
  31 #include "JackTools.h"
  32 #include <assert.h>
  33
  34 namespace Jack
  35 {
  36
  37 JackGraphManager* JackInternalClient::fGraphManager = NULL;
  38 JackEngineControl* JackInternalClient::fEngineControl = NULL;
  39
  40 // Used for external C API (JackAPI.cpp)
  41 SERVER_EXPORT JackGraphManager* GetGraphManager()
  42 {
  43     return JackServerGlobals::fInstance->GetGraphManager();
  44 }
  45
  46 SERVER_EXPORT JackEngineControl* GetEngineControl()
  47 {
  48     return JackServerGlobals::fInstance->GetEngineControl();
  49 }
  50
  51 SERVER_EXPORT JackSynchro* GetSynchroTable()
  52 {
  53     return JackServerGlobals::fInstance->GetSynchroTable();
  54 }
  55
  56 JackInternalClient::JackInternalClient(JackServer* server, JackSynchro* table): JackClient(table)
  57 {
  58     fChannel = new JackInternalClientChannel(server);
  59 }
  60
  61 JackInternalClient::~JackInternalClient()
  62 {
  63     delete fChannel;
  64 }
  65
  66 int JackInternalClient::Open(const char* server_name, const char* name, jack_uuid_t uuid, jack_options_t options, jack_status_t* status)
  67 {
  68     int result;
  69     jack_log("JackInternalClient::Open name = %s", name);
  70
  71     if (strlen(name) >= JACK_CLIENT_NAME_SIZE) {
  72         jack_error("\"%s\" is too long to be used as a JACK client name.\n"
  73                    "Please use %lu characters or less",
  74                    name,
  75                    JACK_CLIENT_NAME_SIZE - 1);
  76         return -1;
  77     }
  78
  79     strncpy(fServerName, server_name, sizeof(fServerName));
  80     fServerName[sizeof(fServerName) - 1] = 0;
  81
  82     // Open server/client direct channel
  83     char name_res[JACK_CLIENT_NAME_SIZE + 1];
  84     fChannel->ClientCheck(name, uuid, name_res, JACK_PROTOCOL_VERSION, (int)options, (int*)status, &result, false);
  85     if (result < 0) {
  86         int status1 = *status;
  87         if (status1 & JackVersionError) {
  88             jack_error("JACK protocol mismatch %d", JACK_PROTOCOL_VERSION);
  89         } else {
  90             jack_error("Client name = %s conflits with another running client", name);
  91         }
  92         goto error;
  93     }
  94
  95     strcpy(fClientControl.fName, name_res);
  96
  97     // Require new client
  98     fChannel->ClientOpen(name_res, &fClientControl.fRefNum, &fEngineControl, &fGraphManager, this, &result);
  99     if (result < 0) {
 100         jack_error("Cannot open client name = %s", name_res);
 101         goto error;
 102     }
 103
 104     SetupDriverSync(false);
 105     JackGlobals::fClientTable[fClientControl.fRefNum] = this;
 106     JackGlobals::fServerRunning = true;
 107     jack_log("JackInternalClient::Open name = %s refnum = %ld", name_res, fClientControl.fRefNum);
 108     return 0;
 109
 110 error:
 111     fChannel->Close();
 112     return -1;
 113 }
 114
 115 void JackInternalClient::ShutDown(jack_status_t code, const char* message)
 116 {
 117     jack_log("JackInternalClient::ShutDown");
 118     JackClient::ShutDown(code, message);
 119 }
 120
 121 JackGraphManager* JackInternalClient::GetGraphManager() const
 122 {
 123     assert(fGraphManager);
 124     return fGraphManager;
 125 }
 126
 127 JackEngineControl* JackInternalClient::GetEngineControl() const
 128 {
 129     assert(fEngineControl);
 130     return fEngineControl;
 131 }
 132
 133 JackClientControl* JackInternalClient::GetClientControl() const
 134 {
 135     return const_cast<JackClientControl*>(&fClientControl);
 136 }
 137
 138 int JackLoadableInternalClient::Init(const char* so_name)
 139 {
 140     char path_to_so[JACK_PATH_MAX + 1];
 141     BuildClientPath(path_to_so, sizeof(path_to_so), so_name);
 142
 143     fHandle = LoadJackModule(path_to_so);
 144     jack_log("JackLoadableInternalClient::JackLoadableInternalClient path_to_so = %s", path_to_so);
 145
 146     if (fHandle == NULL) {
 147         PrintLoadError(so_name);
 148         return -1;
 149     }
 150
 151     fFinish = (FinishCallback)GetJackProc(fHandle, "jack_finish");
 152     if (fFinish == NULL) {
 153         UnloadJackModule(fHandle);
 154         jack_error("symbol jack_finish cannot be found in %s", so_name);
 155         return -1;
 156     }
 157
 158     fDescriptor = (JackDriverDescFunction)GetJackProc(fHandle, "jack_get_descriptor");
 159     if (fDescriptor == NULL) {
 160         jack_info("No jack_get_descriptor entry-point for %s", so_name);
 161     }
 162     return 0;
 163 }
 164
 165 int JackLoadableInternalClient1::Init(const char* so_name)
 166 {
 167     if (JackLoadableInternalClient::Init(so_name) < 0) {
 168         return -1;
 169     }
 170
 171     fInitialize = (InitializeCallback)GetJackProc(fHandle, "jack_initialize");
 172     if (fInitialize == NULL) {
 173         UnloadJackModule(fHandle);
 174         jack_error("symbol jack_initialize cannot be found in %s", so_name);
 175         return -1;
 176     }
 177
 178     return 0;
 179 }
 180
 181 int JackLoadableInternalClient2::Init(const char* so_name)
 182 {
 183     if (JackLoadableInternalClient::Init(so_name) < 0) {
 184         return -1;
 185     }
 186
 187     fInitialize = (InternalInitializeCallback)GetJackProc(fHandle, "jack_internal_initialize");
 188     if (fInitialize == NULL) {
 189         UnloadJackModule(fHandle);
 190         jack_error("symbol jack_internal_initialize cannot be found in %s", so_name);
 191         return -1;
 192     }
 193
 194     return 0;
 195 }
 196
 197 JackLoadableInternalClient1::JackLoadableInternalClient1(JackServer* server, JackSynchro* table, const char* object_data)
 198         : JackLoadableInternalClient(server, table)
 199 {
 200     if (object_data != NULL)
 201         strncpy(fObjectData, object_data, JACK_LOAD_INIT_LIMIT);
 202     else
 203         memset(fObjectData, 0, sizeof(fObjectData));
 204 }
 205
 206 JackLoadableInternalClient2::JackLoadableInternalClient2(JackServer* server, JackSynchro* table, const JSList*  parameters)
 207         : JackLoadableInternalClient(server, table)
 208 {
 209     fParameters = parameters;
 210 }
 211
 212 JackLoadableInternalClient::~JackLoadableInternalClient()
 213 {
 214     if (fFinish != NULL) {
 215         fFinish(fProcessArg);
 216     }
 217     if (fHandle != NULL) {
 218         UnloadJackModule(fHandle);
 219     }
 220 }
 221
 222 int JackLoadableInternalClient1::Open(const char* server_name, const char* name, jack_uuid_t uuid, jack_options_t options, jack_status_t* status)
 223 {
 224     int res = -1;
 225
 226     if (JackInternalClient::Open(server_name, name, uuid, options, status) == 0) {
 227         if (fInitialize((jack_client_t*)this, fObjectData) == 0) {
 228             res = 0;
 229         } else {
 230             JackInternalClient::Close();
 231             fFinish = NULL;
 232         }
 233     }
 234
 235     return res;
 236 }
 237
 238 int JackLoadableInternalClient2::Open(const char* server_name, const char* name, jack_uuid_t uuid, jack_options_t options, jack_status_t* status)
 239 {
 240     int res = -1;
 241
 242     if (JackInternalClient::Open(server_name, name, uuid, options, status) == 0) {
 243         if (fInitialize((jack_client_t*)this, fParameters) == 0) {
 244             res = 0;
 245         } else {
 246             JackInternalClient::Close();
 247             fFinish = NULL;
 248         }
 249     }
 250
 251     return res;
 252 }
 253
 254 } // end of namespace
 255