New server/client data transfer model

git-svn-id: http://subversion.jackaudio.org/jack/jack2/trunk/jackmp@1329 0c269be4-1314-0410-8aa9-9f06e86f4224

ChangeLog

@@ -6,6 +6,10 @@
 
 	*  Add call to the init callback (set up using the jack_set_thread_init_callback API) in Real-Time and Notification threads. Define a new 'kActivateClient' notification. 
 
+2007-01-02 Stephane Letz  <letz@grame.fr>
+
+	* Internal cleanup.
+
 2006-12-23 Stephane Letz  <letz@grame.fr>
 
 	* shared_ports renamed to shared_graph.

common/JackConstants.h

@@ -24,7 +24,6 @@
 #define FORK_SERVER 1
 
 #define BUFFER_SIZE_MAX 8192
-#define SAMPLE_RATE 44100
 
 #define JACK_PORT_NAME_SIZE 256
 #define JACK_PORT_TYPE_SIZE 32
@@ -49,16 +48,14 @@
 #ifdef WIN32
 	#define jack_server_dir "server"
 	#define jack_client_dir "client"
+#elif __APPLE__
+	#define jack_server_dir "/tmp"
+	#define jack_client_dir "/tmp"
 #else
 	#define jack_server_dir "/dev/shm"
 	#define jack_client_dir "/dev/shm"
 #endif
 
-/*
-#define jack_server_dir "/mnt/ramfs"
-#define jack_client_dir "/mnt/ramfs"
-*/
-
 #define jack_server_entry "jackdmp_entry"
 #define jack_client_entry "jack_client"
 

common/JackRequest.h

@@ -72,15 +72,15 @@ public:
     JackRequest(RequestType type): fType(type)
     {}
 
-    virtual ~JackRequest()
+  	~JackRequest()
     {}
 
-    virtual int Read(JackChannelTransaction* trans)
+ 	int Read(JackChannelTransaction* trans)
     {
         return trans->Read(this, sizeof(JackRequest));
     }
 
-    virtual int Write(JackChannelTransaction* trans)
+ 	int Write(JackChannelTransaction* trans)
     {
         return -1;
     }
@@ -118,14 +118,15 @@ struct JackResult
 \brief NewClient request.
 */
 
-struct JackClientNewRequest : public JackRequest
+struct JackClientNewRequest 
 {
 
+	JackRequest fHeader;	
     char fName[JACK_CLIENT_NAME_SIZE + 1];
 
     JackClientNewRequest()
     {}
-    JackClientNewRequest(const char* name): JackRequest(kClientNew)
+    JackClientNewRequest(const char* name): fHeader(JackRequest::kClientNew)
     {
         snprintf(fName, sizeof(fName), "%s", name);
     }
@@ -145,9 +146,10 @@ struct JackClientNewRequest : public JackRequest
 \brief NewClient result.
 */
 
-struct JackClientNewResult : public JackResult
+struct JackClientNewResult 
 {
 
+	JackResult fHeader;
     int fSharedEngine;
     int fSharedClient;
     int fSharedGraph;
@@ -157,10 +159,11 @@ struct JackClientNewResult : public JackResult
 		:fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1), fProtocolVersion(0)
     {}
     JackClientNewResult(int32_t status, int index1, int index2, int index3)
-         : JackResult(status), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)
+         : fHeader(status), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)
     {}
 
-    virtual int Read(JackChannelTransaction* trans)
+    //virtual int Read(JackChannelTransaction* trans)
+	int Read(JackChannelTransaction* trans)
     {
         return trans->Read(this, sizeof(JackClientNewResult));
     }
@@ -175,14 +178,15 @@ struct JackClientNewResult : public JackResult
 \brief CloseClient request.
 */
 
-struct JackClientCloseRequest : public JackRequest
+struct JackClientCloseRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
 
     JackClientCloseRequest()
     {}
-    JackClientCloseRequest(int refnum): JackRequest(kClientClose), fRefNum(refnum)
+    JackClientCloseRequest(int refnum): fHeader(JackRequest::kClientClose), fRefNum(refnum)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -200,14 +204,15 @@ struct JackClientCloseRequest : public JackRequest
 \brief Activate request.
 */
 
-struct JackActivateRequest : public JackRequest
+struct JackActivateRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
 
     JackActivateRequest()
     {}
-    JackActivateRequest(int refnum): JackRequest(kActivateClient), fRefNum(refnum)
+    JackActivateRequest(int refnum): fHeader(JackRequest::kActivateClient), fRefNum(refnum)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -226,14 +231,15 @@ struct JackActivateRequest : public JackRequest
 \brief Deactivate request.
 */
 
-struct JackDeactivateRequest : public JackRequest
+struct JackDeactivateRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
 
     JackDeactivateRequest()
     {}
-    JackDeactivateRequest(int refnum): JackRequest(kDeactivateClient), fRefNum(refnum)
+    JackDeactivateRequest(int refnum): fHeader(JackRequest::kDeactivateClient), fRefNum(refnum)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -252,9 +258,10 @@ struct JackDeactivateRequest : public JackRequest
 \brief PortRegister request.
 */
 
-struct JackPortRegisterRequest : public JackRequest
+struct JackPortRegisterRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
     char fName[JACK_PORT_NAME_SIZE + 1];
     char fPortType[JACK_PORT_TYPE_SIZE + 1];
@@ -264,7 +271,7 @@ struct JackPortRegisterRequest : public JackRequest
     JackPortRegisterRequest()
     {}
     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
-            : JackRequest(kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
+            : fHeader(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
     {
         strcpy(fName, name);
         strcpy(fPortType, port_type);
@@ -285,15 +292,16 @@ struct JackPortRegisterRequest : public JackRequest
 \brief PortRegister result.
 */
 
-struct JackPortRegisterResult : public JackResult
+struct JackPortRegisterResult
 {
 
+	JackResult fHeader;
     jack_port_id_t fPortIndex;
 
     JackPortRegisterResult(): fPortIndex(NO_PORT)
     {}
 
-    virtual int Read(JackChannelTransaction* trans)
+    int Read(JackChannelTransaction* trans)
     {
         return trans->Read(this, sizeof(JackPortRegisterResult));
     }
@@ -308,15 +316,16 @@ struct JackPortRegisterResult : public JackResult
 \brief PortUnregister request.
 */
 
-struct JackPortUnRegisterRequest : public JackRequest
+struct JackPortUnRegisterRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
     int fPortIndex;
 
     JackPortUnRegisterRequest()
     {}
-    JackPortUnRegisterRequest(int refnum, int index): JackRequest(kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
+    JackPortUnRegisterRequest(int refnum, int index): fHeader(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -334,16 +343,17 @@ struct JackPortUnRegisterRequest : public JackRequest
 \brief PortConnectName request.
 */
 
-struct JackPortConnectNameRequest : public JackRequest
+struct JackPortConnectNameRequest
 {
-
+	
+	JackRequest fHeader;
     int fRefNum;
     char fSrc[JACK_PORT_NAME_SIZE + 1];
     char fDst[JACK_PORT_NAME_SIZE + 1];
 
     JackPortConnectNameRequest()
     {}
-    JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(kConnectNamePorts), fRefNum(refnum)
+    JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name): fHeader(JackRequest::kConnectNamePorts), fRefNum(refnum)
     {
         strcpy(fSrc, src_name);
         strcpy(fDst, dst_name);
@@ -364,16 +374,17 @@ struct JackPortConnectNameRequest : public JackRequest
 \brief PortDisconnectName request.
 */
 
-struct JackPortDisconnectNameRequest : public JackRequest
+struct JackPortDisconnectNameRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
     char fSrc[JACK_PORT_NAME_SIZE + 1];
     char fDst[JACK_PORT_NAME_SIZE + 1];
 
     JackPortDisconnectNameRequest()
     {}
-    JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(kDisconnectNamePorts), fRefNum(refnum)
+    JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name): fHeader(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
     {
         strcpy(fSrc, src_name);
         strcpy(fDst, dst_name);
@@ -394,16 +405,17 @@ struct JackPortDisconnectNameRequest : public JackRequest
 \brief PortConnect request.
 */
 
-struct JackPortConnectRequest : public JackRequest
+struct JackPortConnectRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
     jack_port_id_t fSrc;
     jack_port_id_t fDst;
 
     JackPortConnectRequest()
     {}
-    JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
+    JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): fHeader(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -422,16 +434,17 @@ struct JackPortConnectRequest : public JackRequest
 \brief PortDisconnect request.
 */
 
-struct JackPortDisconnectRequest : public JackRequest
+struct JackPortDisconnectRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
     jack_port_id_t fSrc;
     jack_port_id_t fDst;
 
     JackPortDisconnectRequest()
     {}
-    JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
+    JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): fHeader(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -449,14 +462,15 @@ struct JackPortDisconnectRequest : public JackRequest
 \brief SetBufferSize request.
 */
 
-struct JackSetBufferSizeRequest : public JackRequest
+struct JackSetBufferSizeRequest
 {
 
+	JackRequest fHeader;
     jack_nframes_t fBufferSize;
 
     JackSetBufferSizeRequest()
     {}
-    JackSetBufferSizeRequest(jack_nframes_t buffer_size): JackRequest(kSetBufferSize), fBufferSize(buffer_size)
+    JackSetBufferSizeRequest(jack_nframes_t buffer_size): fHeader(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -474,14 +488,15 @@ struct JackSetBufferSizeRequest : public JackRequest
 \brief SetFreeWheel request.
 */
 
-struct JackSetFreeWheelRequest : public JackRequest
+struct JackSetFreeWheelRequest
 {
 
+	JackRequest fHeader;
     int fOnOff;
 
     JackSetFreeWheelRequest()
     {}
-    JackSetFreeWheelRequest(int onoff): JackRequest(kSetFreeWheel), fOnOff(onoff)
+    JackSetFreeWheelRequest(int onoff): fHeader(JackRequest::kSetFreeWheel), fOnOff(onoff)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -499,14 +514,15 @@ struct JackSetFreeWheelRequest : public JackRequest
 \brief ReleaseTimebase request.
 */
 
-struct JackReleaseTimebaseRequest : public JackRequest
+struct JackReleaseTimebaseRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
 
     JackReleaseTimebaseRequest()
     {}
-    JackReleaseTimebaseRequest(int refnum): JackRequest(kReleaseTimebase), fRefNum(refnum)
+    JackReleaseTimebaseRequest(int refnum): fHeader(JackRequest::kReleaseTimebase), fRefNum(refnum)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -525,15 +541,16 @@ struct JackReleaseTimebaseRequest : public JackRequest
 \brief SetTimebaseCallback request.
 */
 
-struct JackSetTimebaseCallbackRequest : public JackRequest
+struct JackSetTimebaseCallbackRequest
 {
 
+	JackRequest fHeader;
     int fRefNum;
     int fConditionnal;
 
     JackSetTimebaseCallbackRequest()
     {}
-    JackSetTimebaseCallbackRequest(int refnum, int conditional): JackRequest(kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
+    JackSetTimebaseCallbackRequest(int refnum, int conditional): fHeader(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
     {}
 
     int Read(JackChannelTransaction* trans)
@@ -551,9 +568,10 @@ struct JackSetTimebaseCallbackRequest : public JackRequest
 \brief ClientNotification request.
 */
 
-struct JackClientNotificationRequest : public JackRequest
+struct JackClientNotificationRequest
 {
-
+	
+	JackRequest fHeader;
     int fRefNum;
     int fNotify;
     int fValue;
@@ -561,7 +579,7 @@ struct JackClientNotificationRequest : public JackRequest
     JackClientNotificationRequest()
     {}
     JackClientNotificationRequest(int refnum, int notify, int value)
-            : JackRequest(kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
+            : fHeader(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
     {}
 
     int Read(JackChannelTransaction* trans)

common/JackSocketClientChannel.cpp

@@ -86,6 +86,7 @@ void JackSocketClientChannel::Stop()
     fThread->Kill();
 }
 
+/*
 void JackSocketClientChannel::ServerSyncCall(JackRequest* req, JackResult* res, int* result)
 {
     if (req->Write(&fRequestSocket) < 0) {
@@ -112,12 +113,27 @@ void JackSocketClientChannel::ServerAsyncCall(JackRequest* req, JackResult* res,
         *result = 0;
     }
 }
+*/
 
 void JackSocketClientChannel::ClientNew(const char* name, int* shared_engine, int* shared_client, int* shared_graph, int* result)
 {
     JackClientNewRequest req(name);
     JackClientNewResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fHeader.fResult;
     *shared_engine = res.fSharedEngine;
     *shared_client = res.fSharedClient;
     *shared_graph = res.fSharedGraph;
@@ -127,28 +143,73 @@ void JackSocketClientChannel::ClientClose(int refnum, int* result)
 {
     JackClientCloseRequest req(refnum);
     JackResult res;
-    ServerAsyncCall(&req, &res, result);
+    //ServerAsyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+    } else {
+        *result = 0;
+    }
 }
 
 void JackSocketClientChannel::ClientActivate(int refnum, int* result)
 {
     JackActivateRequest req(refnum);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::ClientDeactivate(int refnum, int* result)
 {
     JackDeactivateRequest req(refnum);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+	*result = res.fResult;
 }
 
 void JackSocketClientChannel::PortRegister(int refnum, const char* name, unsigned int flags, unsigned int buffer_size, jack_port_id_t* port_index, int* result)
 {
     JackPortRegisterRequest req(refnum, name, "audio", flags, buffer_size);
     JackPortRegisterResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fHeader.fResult;
     *port_index = res.fPortIndex;
 }
 
@@ -156,63 +217,180 @@ void JackSocketClientChannel::PortUnRegister(int refnum, jack_port_id_t port_ind
 {
     JackPortUnRegisterRequest req(refnum, port_index);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::PortConnect(int refnum, const char* src, const char* dst, int* result)
 {
     JackPortConnectNameRequest req(refnum, src, dst);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::PortDisconnect(int refnum, const char* src, const char* dst, int* result)
 {
     JackPortDisconnectNameRequest req(refnum, src, dst);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::PortConnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
 {
     JackPortConnectRequest req(refnum, src, dst);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::PortDisconnect(int refnum, jack_port_id_t src, jack_port_id_t dst, int* result)
 {
     JackPortDisconnectRequest req(refnum, src, dst);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* result)
 {
     JackSetBufferSizeRequest req(buffer_size);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::SetFreewheel(int onoff, int* result)
 {
     JackSetFreeWheelRequest req(onoff);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::ReleaseTimebase(int refnum, int* result)
 {
     JackReleaseTimebaseRequest req(refnum);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 void JackSocketClientChannel::SetTimebaseCallback(int refnum, int conditional, int* result)
 {
     JackSetTimebaseCallbackRequest req(refnum, conditional);
     JackResult res;
-    ServerSyncCall(&req, &res, result);
+    //ServerSyncCall(&req, &res, result);
+	if (req.Write(&fRequestSocket) < 0) {
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    if (res.Read(&fRequestSocket) < 0) {
+        jack_error("Could not read result type = %ld", req.fHeader.fType);
+        *result = -1;
+        return ;
+    }
+
+    *result = res.fResult;
 }
 
 bool JackSocketClientChannel::Init()
@@ -235,8 +413,6 @@ bool JackSocketClientChannel::Execute()
     JackClientNotification event;
     JackResult res;
 
-    //fClient->Init(); // To be checked
-
     if (event.Read(fNotificationSocket) < 0) {
         fNotificationSocket->Close();
         jack_error("JackSocketClientChannel read fail");

common/JackSocketClientChannel.h

@@ -43,8 +43,8 @@ class JackSocketClientChannel : public JackClientChannelInterface, public JackRu
         JackThread*	fThread;						// Thread to execute the event loop
         JackClient*	fClient;
 
-        void ServerSyncCall(JackRequest* req, JackResult* res, int* result);
-        void ServerAsyncCall(JackRequest* req, JackResult* res, int* result);
+        //void ServerSyncCall(JackRequest* req, JackResult* res, int* result);
+        //void ServerAsyncCall(JackRequest* req, JackResult* res, int* result);
 
     public:
 

common/JackSocketServerChannel.cpp

@@ -155,7 +155,7 @@ int JackSocketServerChannel::HandleRequest(int fd)
                 JackClientNewRequest req;
                 JackClientNewResult res;
                 if (req.Read(socket) == 0)
-					AddClient(fd, req.fName, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
+					AddClient(fd, req.fName, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fHeader.fResult);
                 res.Write(socket);
                 break;
             }
@@ -196,7 +196,7 @@ int JackSocketServerChannel::HandleRequest(int fd)
                 JackPortRegisterRequest req;
                 JackPortRegisterResult res;
                 if (req.Read(socket) == 0)
-					res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fFlags, req.fBufferSize, &res.fPortIndex);
+					res.fHeader.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fFlags, req.fBufferSize, &res.fPortIndex);
                 res.Write(socket);
                 break;
             }

common/JackSocketServerNotifyChannel.cpp

@@ -50,7 +50,7 @@ void JackSocketServerNotifyChannel::ClientNotify(int refnum, int notify, int val
 {
     JackClientNotificationRequest req(refnum, notify, value);
     if (req.Write(&fRequestSocket) < 0) {
-        jack_error("Could not write request type = %ld", req.fType);
+        jack_error("Could not write request type = %ld", req.fHeader.fType);
     }
 }
 

windows/JackWinNamedPipeClientChannel.cpp

@@ -231,8 +231,6 @@ bool JackWinNamedPipeClientChannel::Execute()
     JackClientNotification event;
     JackResult res;
 
-    //fClient->Init(); // To be checked
-
     if (event.Read(&fNotificationListenPipe) < 0) {
         fNotificationListenPipe.Close();
         jack_error("JackWinNamedPipeClientChannel read fail");