add uuid parameter to jack_client_open...

common/JackChannel.h

@@ -76,7 +76,7 @@ class JackClientChannelInterface
 
         virtual void ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result)
         {}
-        virtual void ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+        virtual void ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
         {}
         virtual void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
         {}

common/JackClient.h

@@ -123,7 +123,7 @@ class JackClient : public JackClientInterface, public JackRunnableInterface
         JackClient(JackSynchro* table);
         virtual ~JackClient();
 
-        virtual int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status) = 0;
+        virtual int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid) = 0;
         virtual int Close();
 
         virtual JackGraphManager* GetGraphManager() const = 0;

common/JackClientControl.h

@@ -50,22 +50,22 @@ struct JackClientControl : public JackShmMemAble
     char fSessionCommand[256 + 1];
     jack_session_flags_t fSessionFlags;
 
-    JackClientControl(const char* name, int pid, int refnum)
+    JackClientControl(const char* name, int pid, int refnum, int uuid)
     {
-        Init(name, pid, refnum);
+        Init(name, pid, refnum, uuid);
     }
 
     JackClientControl(const char* name)
     {
-        Init(name, 0, -1);
+        Init(name, 0, -1, -1);
     }
 
     JackClientControl()
     {
-        Init("", 0, -1);
+        Init("", 0, -1, -1);
     }
 
-    void Init(const char* name, int pid, int refnum)
+    void Init(const char* name, int pid, int refnum, int uuid)
     {
         strcpy(fName, name);
         for (int i = 0; i < kMaxNotification; i++)
@@ -84,7 +84,7 @@ struct JackClientControl : public JackShmMemAble
         fTransportTimebase = false;
         fActive = false;
 
-	fSessionID = 0;
+	fSessionID = uuid;
     }
 
 } POST_PACKED_STRUCTURE;

common/JackControlAPI.cpp

@@ -1179,7 +1179,7 @@ EXPORT bool jackctl_server_load_internal(
 {
     int status;
     if (server_ptr->engine != NULL) {
-        server_ptr->engine->InternalClientLoad(internal->desc_ptr->name, internal->desc_ptr->name, internal->set_parameters, JackNullOption, &internal->refnum, &status);
+        server_ptr->engine->InternalClientLoad(internal->desc_ptr->name, internal->desc_ptr->name, internal->set_parameters, JackNullOption, &internal->refnum, &status, -1);
         return (internal->refnum > 0);
     } else {
         return false;

common/JackDebugClient.cpp

@@ -78,9 +78,9 @@ JackDebugClient::~JackDebugClient()
     delete fClient;
 }
 
-int JackDebugClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
+int JackDebugClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid)
 {
-    int res = fClient->Open(server_name, name, options, status);
+    int res = fClient->Open(server_name, name, options, status, uuid);
     char provstr[256];
     char buffer[256];
     time_t curtime;

common/JackDebugClient.h

@@ -68,7 +68,7 @@ class JackDebugClient : public JackClient
         JackDebugClient(JackClient* fTheClient);
         virtual ~JackDebugClient();
 
-        virtual int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
+        virtual int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid);
         int Close();
 
         virtual JackGraphManager* GetGraphManager() const;

common/JackEngine.cpp

@@ -460,9 +460,32 @@ bool JackEngine::ClientCheckName(const char* name)
             return true;
     }
 
+    for (std::map<int,std::string>::iterator i=fReservationMap.begin(); i!=fReservationMap.end(); i++) {
+	if (i->second == name)
+	    return true;
+    }
+
     return false;
 }
 
+int JackEngine::GetNewUUID()
+{
+    return fMaxUUID++;
+}
+
+void JackEngine::EnsureUUID(int uuid)
+{
+    if (uuid > fMaxUUID)
+	fMaxUUID = uuid+1;
+
+    for (int i = 0; i < CLIENT_NUM; i++) {
+        JackClientInterface* client = fClientTable[i];
+        if (client && (client->GetClientControl()->fSessionID==uuid)) {
+	    client->GetClientControl()->fSessionID = GetNewUUID();
+	}
+    }
+}
+
 int JackEngine::GetClientPID(const char* name)
 {
     for (int i = 0; i < CLIENT_NUM; i++) {
@@ -486,9 +509,26 @@ int JackEngine::GetClientRefNum(const char* name)
 }
 
 // Used for external clients
-int JackEngine::ClientExternalOpen(const char* name, int pid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
+int JackEngine::ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
 {
-    jack_log("JackEngine::ClientExternalOpen: name = %s ", name);
+    char real_name[JACK_CLIENT_NAME_SIZE+1];
+
+    if (uuid < 0) {
+	uuid = GetNewUUID();
+	strncpy( real_name, name, JACK_CLIENT_NAME_SIZE );
+    } else {
+	std::map<int,std::string>::iterator res = fReservationMap.find(uuid);
+	if (res != fReservationMap.end()) {
+	    strncpy( real_name, res->second.c_str(), JACK_CLIENT_NAME_SIZE );
+	    fReservationMap.erase(uuid);
+	} else {
+	    strncpy( real_name, name, JACK_CLIENT_NAME_SIZE );
+	}
+
+	EnsureUUID(uuid);
+    }
+
+    jack_log("JackEngine::ClientExternalOpen: name = %s ", real_name);
 
     int refnum = AllocateRefnum();
     if (refnum < 0) {
@@ -498,12 +538,17 @@ int JackEngine::ClientExternalOpen(const char* name, int pid, int* ref, int* sha
 
     JackExternalClient* client = new JackExternalClient();
 
-    if (!fSynchroTable[refnum].Allocate(name, fEngineControl->fServerName, 0)) {
+    if (!fSynchroTable[refnum].Allocate(real_name, fEngineControl->fServerName, 0)) {
         jack_error("Cannot allocate synchro");
         goto error;
     }
 
-    if (client->Open(name, pid, refnum, shared_client) < 0) {
+    if (uuid < 0)
+	uuid = GetNewUUID();
+    else
+	EnsureUUID(uuid);
+
+    if (client->Open(real_name, pid, refnum, uuid, shared_client) < 0) {
         jack_error("Cannot open client");
         goto error;
     }
@@ -516,7 +561,7 @@ int JackEngine::ClientExternalOpen(const char* name, int pid, int* ref, int* sha
 
     fClientTable[refnum] = client;
 
-    if (NotifyAddClient(client, name, refnum) < 0) {
+    if (NotifyAddClient(client, real_name, refnum) < 0) {
         jack_error("Cannot notify add client");
         goto error;
     }

common/JackEngine.h

@@ -97,7 +97,7 @@ class SERVER_EXPORT JackEngine : public JackLockAble
   
         // Client management
         int ClientCheck(const char* name, char* name_res, int protocol, int options, int* status);
-        int ClientExternalOpen(const char* name, int pid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager);
+        int ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager);
         int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait);
 
         int ClientExternalClose(int refnum);

common/JackExternalClient.cpp

@@ -41,7 +41,7 @@ int JackExternalClient::ClientNotify(int refnum, const char* name, int notify, i
     return result;
 }
 
-int JackExternalClient::Open(const char* name, int pid, int refnum, int* shared_client)
+int JackExternalClient::Open(const char* name, int pid, int refnum, int uuid, int* shared_client)
 {
     try {
 
@@ -53,7 +53,7 @@ int JackExternalClient::Open(const char* name, int pid, int refnum, int* shared_
         // Use "placement new" to allocate object in shared memory
         JackShmMemAble* shared_mem = static_cast<JackShmMemAble*>(JackShmMem::operator new(sizeof(JackClientControl)));
         shared_mem->Init();
-        fClientControl = new(shared_mem) JackClientControl(name, pid, refnum);
+        fClientControl = new(shared_mem) JackClientControl(name, pid, refnum, uuid);
       
         if (!fClientControl) {
             jack_error("Cannot allocate client shared memory segment");

common/JackExternalClient.h

@@ -46,7 +46,7 @@ class JackExternalClient : public JackClientInterface
         JackExternalClient();
         virtual ~JackExternalClient();
 
-        int Open(const char* name, int pid, int refnum, int* shared_client);
+        int Open(const char* name, int pid, int refnum, int uuid, int* shared_client);
         int Close();
 
         int ClientNotify(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);

common/JackInternalClient.cpp

@@ -63,7 +63,7 @@ JackInternalClient::~JackInternalClient()
     delete fChannel;
 }
 
-int JackInternalClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
+int JackInternalClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid)
 {
     int result;
     char name_res[JACK_CLIENT_NAME_SIZE + 1];
@@ -198,11 +198,11 @@ JackLoadableInternalClient::~JackLoadableInternalClient()
         UnloadJackModule(fHandle);
 }
 
-int JackLoadableInternalClient1::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
+int JackLoadableInternalClient1::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid)
 {
     int res = -1;
     
-    if (JackInternalClient::Open(server_name, name, options, status) == 0) {
+    if (JackInternalClient::Open(server_name, name, options, status, uuid) == 0) {
         if (fInitialize((jack_client_t*)this, fObjectData) == 0) {
             res = 0;
         } else {
@@ -214,11 +214,11 @@ int JackLoadableInternalClient1::Open(const char* server_name, const char* name,
     return res;
 }
 
-int JackLoadableInternalClient2::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
+int JackLoadableInternalClient2::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid)
 {
     int res = -1;
     
-    if (JackInternalClient::Open(server_name, name, options, status) == 0) {
+    if (JackInternalClient::Open(server_name, name, options, status, uuid) == 0) {
         if (fInitialize((jack_client_t*)this, fParameters) == 0) {
             res = 0;
         } else {

common/JackInternalClient.h

@@ -46,7 +46,7 @@ class JackInternalClient : public JackClient
         JackInternalClient(JackServer* server, JackSynchro* table);
         virtual ~JackInternalClient();
 
-        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
+        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid);
 
         JackGraphManager* GetGraphManager() const;
         JackEngineControl* GetEngineControl() const;
@@ -100,7 +100,7 @@ class JackLoadableInternalClient1 : public JackLoadableInternalClient
         {}
 
         int Init(const char* so_name);
-        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
+        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid);
 
 };
 
@@ -119,7 +119,7 @@ class JackLoadableInternalClient2 : public JackLoadableInternalClient
         {}
 
         int Init(const char* so_name);
-        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
+        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid);
 
 };
 

common/JackInternalClientChannel.h

@@ -137,9 +137,9 @@ class JackInternalClientChannel : public detail::JackClientChannelInterface
             *result = fEngine->InternalClientHandle(client_name, status, int_ref);
         }
 
-        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result)
+        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result, int uuid)
         {
-            *result = fServer->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, status);	
+            *result = fServer->InternalClientLoad(client_name, so_name, objet_data, options, int_ref, status, uuid);	
         }
 
         void InternalClientUnload(int refnum, int int_ref, int* status, int* result)

common/JackLibAPI.cpp

@@ -96,7 +96,7 @@ jack_client_t* jack_client_new_aux(const char* client_name, jack_options_t optio
         client = new JackLibClient(GetSynchroTable());
     }
 
-    int res = client->Open(va.server_name, client_name, options, status);
+    int res = client->Open(va.server_name, client_name, options, status, va.session_id);
     if (res < 0) {
         delete client;
         JackLibGlobals::Destroy(); // jack library destruction

common/JackLibClient.cpp

@@ -67,7 +67,7 @@ JackLibClient::~JackLibClient()
     delete fChannel;
 }
 
-int JackLibClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status)
+int JackLibClient::Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid)
 {
     int shared_engine, shared_client, shared_graph, result;
     jack_log("JackLibClient::Open name = %s", name);
@@ -88,7 +88,7 @@ int JackLibClient::Open(const char* server_name, const char* name, jack_options_
     }
 
     // Require new client
-    fChannel->ClientOpen(name_res, JackTools::GetPID(), &shared_engine, &shared_client, &shared_graph, &result);
+    fChannel->ClientOpen(name_res, JackTools::GetPID(), uuid, &shared_engine, &shared_client, &shared_graph, &result);
     if (result < 0) {
         jack_error("Cannot open %s client", name_res);
         goto error;

common/JackLibClient.h

@@ -44,7 +44,7 @@ class JackLibClient : public JackClient
         JackLibClient(JackSynchro* table);
         virtual ~JackLibClient();
 
-        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status);
+        int Open(const char* server_name, const char* name, jack_options_t options, jack_status_t* status, int uuid);
 
         int ClientNotifyImp(int refnum, const char* name, int notify, int sync, const char* message, int value1, int value2);
 

common/JackLockedEngine.h

@@ -103,11 +103,11 @@ class SERVER_EXPORT JackLockedEngine
             return fEngine.ClientCheck(name, name_res, protocol, options, status);
             CATCH_EXCEPTION_RETURN
         }
-        int ClientExternalOpen(const char* name, int pid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
+        int ClientExternalOpen(const char* name, int pid, int uuid, int* ref, int* shared_engine, int* shared_client, int* shared_graph_manager)
         {
             TRY_CALL
             JackLock lock(&fEngine);
-            return fEngine.ClientExternalOpen(name, pid, ref, shared_engine, shared_client, shared_graph_manager);
+            return fEngine.ClientExternalOpen(name, pid, uuid, ref, shared_engine, shared_client, shared_graph_manager);
             CATCH_EXCEPTION_RETURN
         }
         int ClientInternalOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, bool wait)

common/JackRequest.h

@@ -205,19 +205,23 @@ struct JackClientOpenRequest : public JackRequest
 {
 
     int fPID;
+    int fUUID;
     char fName[JACK_CLIENT_NAME_SIZE + 1];
+ 
 
     JackClientOpenRequest()
     {}
-    JackClientOpenRequest(const char* name, int pid): JackRequest(JackRequest::kClientOpen)
+    JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)
     {
         snprintf(fName, sizeof(fName), "%s", name);
         fPID = pid;
+	fUUID = uuid;
     }
 
     int Read(JackChannelTransaction* trans)
     {
         CheckRes(trans->Read(&fPID, sizeof(int)));
+        CheckRes(trans->Read(&fUUID, sizeof(int)));
         return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
     }
 
@@ -225,6 +229,7 @@ struct JackClientOpenRequest : public JackRequest
     {
         CheckRes(JackRequest::Write(trans));
         CheckRes(trans->Write(&fPID, sizeof(int)));
+        CheckRes(trans->Write(&fUUID, sizeof(int)));
         return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
     }
     
@@ -910,15 +915,17 @@ struct JackInternalClientLoadRequest : public JackRequest
     char fDllName[MAX_PATH + 1];
     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
     int fOptions;
+    int fUUID;
 
     JackInternalClientLoadRequest()
     {}
-    JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options)
-            : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options)
+    JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int uuid )
+            : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
     {
         snprintf(fName, sizeof(fName), "%s", client_name);
         snprintf(fDllName, sizeof(fDllName), "%s", so_name);
         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
+        snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
     }
 
     int Read(JackChannelTransaction* trans)
@@ -927,6 +934,7 @@ struct JackInternalClientLoadRequest : public JackRequest
         CheckRes(trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1));
         CheckRes(trans->Read(&fDllName, MAX_PATH + 1));
         CheckRes(trans->Read(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
+        CheckRes(trans->Read(&fUUID, sizeof(int)));
         return trans->Read(&fOptions, sizeof(int));
     }
 
@@ -937,6 +945,7 @@ struct JackInternalClientLoadRequest : public JackRequest
         CheckRes(trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1));
         CheckRes(trans->Write(&fDllName, MAX_PATH + 1));
         CheckRes(trans->Write(&fLoadInitName, JACK_LOAD_INIT_LIMIT + 1));
+        CheckRes(trans->Write(&fUUID, sizeof(int)));
         return trans->Write(&fOptions, sizeof(int));
     }
     

common/JackServer.cpp

@@ -136,25 +136,25 @@ int JackServer::Close()
     return 0;
 }
 
-int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int* status)
+int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int* status, int uuid)
 {
     JackLoadableInternalClient* client = new JackLoadableInternalClient1(JackServerGlobals::fInstance, GetSynchroTable(), objet_data);
     assert(client);
-    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, status);
+    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, status, uuid);
  }
 
-int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int* status)
+int JackServer::InternalClientLoad(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int* status, int uuid)
 {
     JackLoadableInternalClient* client = new JackLoadableInternalClient2(JackServerGlobals::fInstance, GetSynchroTable(), parameters);
     assert(client);
-    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, status);
+    return InternalClientLoadAux(client, so_name, client_name, options, int_ref, status, uuid);
 }
 
-int JackServer::InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int* status)
+int JackServer::InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int* status, int uuid)
 {
     // Clear status
     *status = 0;
-    if ((client->Init(so_name) < 0) || (client->Open(JACK_DEFAULT_SERVER_NAME, client_name, (jack_options_t)options, (jack_status_t*)status) < 0)) {
+    if ((client->Init(so_name) < 0) || (client->Open(JACK_DEFAULT_SERVER_NAME, client_name, (jack_options_t)options, (jack_status_t*)status, uuid) < 0)) {
         delete client;
         int my_status1 = *status | JackFailure;
         *status = (jack_status_t)my_status1;

common/JackServer.h

@@ -58,7 +58,7 @@ class SERVER_EXPORT JackServer
         JackSynchro fSynchroTable[CLIENT_NUM];
         bool fFreewheel;
         
-        int InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int* status);
+        int InternalClientLoadAux(JackLoadableInternalClient* client, const char* so_name, const char* client_name, int options, int* int_ref, int* status, int uuid);
 
     public:
 
@@ -77,8 +77,8 @@ class SERVER_EXPORT JackServer
         // Command thread : API
         int SetBufferSize(jack_nframes_t buffer_size);
         int SetFreewheel(bool onoff);
-        int InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int* status);
-        int InternalClientLoad(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int* status);
+        int InternalClientLoad(const char* client_name, const char* so_name, const char* objet_data, int options, int* int_ref, int* statu, int uuid);
+        int InternalClientLoad(const char* client_name, const char* so_name, const JSList * parameters, int options, int* int_ref, int* status, int uuid);
         void ClientKill(int refnum);
 
         // Transport management

common/JackServerAPI.cpp

@@ -90,7 +90,7 @@ jack_client_t* jack_client_new_aux(const char* client_name, jack_options_t optio
         client = new JackInternalClient(JackServerGlobals::fInstance, GetSynchroTable());
     }
 
-    int res = client->Open(va.server_name, client_name, options, status);
+    int res = client->Open(va.server_name, client_name, options, status, va.session_id);
     if (res < 0) {
         delete client;
         JackServerGlobals::Destroy(); // jack server destruction

common/varargs.h

@@ -35,6 +35,7 @@ extern "C"
         char *server_name;		/* server name */
         char *load_name;		/* load module name */
         char *load_init;		/* initialization string */
+        int   session_id;		/* requested session_id */
     }
     jack_varargs_t;
 
@@ -50,6 +51,7 @@ extern "C"
 	{
         memset (va, 0, sizeof(jack_varargs_t));
         va->server_name = (char*)jack_default_server_name();
+	va->session_id = -1;
     }
 
     static inline void jack_varargs_parse (jack_options_t options, va_list ap, jack_varargs_t *va) 
@@ -66,6 +68,8 @@ extern "C"
             va->load_name = va_arg(ap, char *);
         if ((options & JackLoadInit))
             va->load_init = va_arg(ap, char *);
+        if ((options & JackSessionID))
+            va->session_id = atoi( va_arg(ap, char *) );
     }
 
 #ifdef __cplusplus

example-clients/session_notify.c

@@ -87,7 +87,8 @@ JSList *uuid_map = NULL;
 void add_uuid_mapping( const char *uuid ) {
 	char *clientname = jack_get_client_name_by_uuid( client, uuid );
 	if( !clientname ) {
-		printf( "error... cant find client for uuid" );
+		printf( "error... cant find client for uuid %s", uuid );
+
 		return;
 	}
 

posix/JackSocketClientChannel.cpp

@@ -151,9 +151,9 @@ void JackSocketClientChannel::ClientCheck(const char* name, char* name_res, int
     strcpy(name_res, res.fName);
 }
 
-void JackSocketClientChannel::ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+void JackSocketClientChannel::ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
-    JackClientOpenRequest req(name, pid);
+    JackClientOpenRequest req(name, pid, uuid);
     JackClientOpenResult res;
     ServerSyncCall(&req, &res, result);
     *shared_engine = res.fSharedEngine;
@@ -278,6 +278,29 @@ void JackSocketClientChannel::SessionReply(int refnum, int* result)
     ServerSyncCall(&req, &res, result);
 }
 
+void JackSocketClientChannel::GetUUIDForClientName( int refnum, const char *client_name, char *uuid_res, int *result )
+{
+    JackGetUUIDRequest req(client_name);
+    JackUUIDResult  res;
+    ServerSyncCall(&req, &res, result);
+    strncpy( uuid_res, res.fUUID, 32 );
+}
+
+void JackSocketClientChannel::GetClientNameForUUID( int refnum, const char *uuid, char *name_res, int *result )
+{
+    JackGetClientNameRequest req(uuid);
+    JackClientNameResult  res;
+    ServerSyncCall(&req, &res, result);
+    strncpy( name_res, res.fName, JACK_CLIENT_NAME_SIZE );
+}
+
+void JackSocketClientChannel::ReserveClientName( int refnum, const char *client_name, const char *uuid, int *result )
+{
+    JackReserveNameRequest req(refnum, client_name, uuid);
+    JackResult  res;
+    ServerSyncCall(&req, &res, result);
+}
+
 void JackSocketClientChannel::ReleaseTimebase(int refnum, int* result)
 {
     JackReleaseTimebaseRequest req(refnum);
@@ -309,9 +332,9 @@ void JackSocketClientChannel::InternalClientHandle(int refnum, const char* clien
     *status = res.fStatus;
 }
 
-void JackSocketClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result)
+void JackSocketClientChannel::InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result, int uuid)
 {
-    JackInternalClientLoadRequest req(refnum, client_name, so_name, objet_data, options);
+    JackInternalClientLoadRequest req(refnum, client_name, so_name, objet_data, options, uuid);
     JackInternalClientLoadResult res;
     ServerSyncCall(&req, &res, result);
     *int_ref = res.fIntRefNum;

posix/JackSocketClientChannel.h

@@ -61,8 +61,8 @@ class JackSocketClientChannel : public detail::JackClientChannelInterface, publi
         int ServerCheck(const char* server_name);
 
         void ClientCheck(const char* name, char* name_res, int protocol, int options, int* status, int* result);
-        void ClientOpen(const char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
-        void ClientOpen(const char* name, int* ref, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
+        void ClientOpen(const char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+        void ClientOpen(const char* name, int* ref, int uuid, JackEngineControl** shared_engine, JackGraphManager** shared_manager, JackClientInterface* client, int* result)
         {}
         void ClientClose(int refnum, int* result);
 
@@ -88,15 +88,20 @@ class JackSocketClientChannel : public detail::JackClientChannelInterface, publi
 
         void GetInternalClientName(int refnum, int int_ref, char* name_res, int* result);
         void InternalClientHandle(int refnum, const char* client_name, int* status, int* int_ref, int* result);
-        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result);
+        void InternalClientLoad(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int* status, int* int_ref, int* result, int uuid);
         void InternalClientUnload(int refnum, int int_ref, int* status, int* result);
 
+	// Session Stuff
+	void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char* path, jack_session_command_t** result);
+	void SessionReply(int refnum, int* result);
+	void GetUUIDForClientName( int refnum, const char *client_name, char *uuid_res, int *result );
+	void GetClientNameForUUID( int refnum, const char *uuid, char *name_res, int *result );
+	void ReserveClientName( int refnum, const char *client_name, const char *uuid, int *result );
+
         // JackRunnableInterface interface
         bool Init();
         bool Execute();
 
-	void SessionNotify(int refnum, const char* target, jack_session_event_type_t type, const char* path, jack_session_command_t** result);
-	void SessionReply(int refnum, int* result);
 
 	bool IsChannelThread() { return fThread.IsThread(); }
 };

posix/JackSocketServerChannel.cpp

@@ -102,11 +102,11 @@ void JackSocketServerChannel::ClientCreate()
     }
 }
 
-void JackSocketServerChannel::ClientAdd(int fd, char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
+void JackSocketServerChannel::ClientAdd(int fd, char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
     jack_log("JackSocketServerChannel::ClientAdd");
     int refnum = -1;
-    *result = fServer->GetEngine()->ClientExternalOpen(name, pid, &refnum, shared_engine, shared_client, shared_graph);
+    *result = fServer->GetEngine()->ClientExternalOpen(name, pid, uuid, &refnum, shared_engine, shared_client, shared_graph);
     if (*result == 0) {
         fSocketTable[fd].first = refnum;
         fRebuild = true;
@@ -181,7 +181,7 @@ bool JackSocketServerChannel::HandleRequest(int fd)
             JackClientOpenRequest req;
             JackClientOpenResult res;
             if (req.Read(socket) == 0)
-                ClientAdd(fd, req.fName, req.fPID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
+                ClientAdd(fd, req.fName, req.fPID, req.fUUID, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
             if (res.Write(socket) < 0)
                 jack_error("JackRequest::ClientOpen write error name = %s", req.fName);
             break;
@@ -369,7 +369,7 @@ bool JackSocketServerChannel::HandleRequest(int fd)
             JackInternalClientLoadRequest req;
             JackInternalClientLoadResult res;
             if (req.Read(socket) == 0)
-                res.fResult = fServer->InternalClientLoad(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, &res.fStatus);
+                res.fResult = fServer->InternalClientLoad(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, &res.fStatus, req.fUUID);
             if (res.Write(socket) < 0)
                 jack_error("JackRequest::InternalClientLoad write error name = %s", req.fName);
             break;
@@ -421,6 +421,44 @@ bool JackSocketServerChannel::HandleRequest(int fd)
             break;
         }
 
+        case JackRequest::kGetClientByUUID: {
+            jack_log("JackRequest::GetClientNameForUUID");
+            JackGetClientNameRequest req;
+            JackClientNameResult res;
+            if (req.Read(socket) == 0) {
+		fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName, &res.fResult);
+            }
+            if (res.Write(socket) < 0)
+                jack_error("JackRequest::GetClientNameForUUID write error");
+            break;
+        }
+
+        case JackRequest::kGetUUIDByClient: {
+            jack_log("JackRequest::GetUUIDForClientName");
+            JackGetUUIDRequest req;
+            JackUUIDResult res;
+            if (req.Read(socket) == 0) {
+		fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID, &res.fResult);
+		res.fResult = 0;
+            }
+            if (res.Write(socket) < 0)
+                jack_error("JackRequest::GetUUIDForClientName write error");
+            break;
+        }
+
+        case JackRequest::kReserveClientName: {
+            jack_log("JackRequest::ReserveClientName");
+            JackReserveNameRequest req;
+            JackResult res;
+            if (req.Read(socket) == 0) {
+		fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID, &res.fResult);
+		res.fResult = 0;
+            }
+            if (res.Write(socket) < 0)
+                jack_error("JackRequest::ReserveClientName write error");
+            break;
+        }
+
         default:
             jack_error("Unknown request %ld", header.fType);
             break;

posix/JackSocketServerChannel.h

@@ -50,7 +50,7 @@ class JackSocketServerChannel : public JackRunnableInterface
         void BuildPoolTable();
 
         void ClientCreate();
-        void ClientAdd(int fd, char* name, int pid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
+        void ClientAdd(int fd, char* name, int pid, int uuid, int* shared_engine, int* shared_client, int* shared_graph, int* result);
         void ClientRemove(int fd, int refnum);
         void ClientKill(int fd);