New server/client data transfer model (2)

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

common/JackLibClient.cpp

@@ -114,6 +114,7 @@ int JackLibClient::Open(const char* name)
     }
 
     JackLog("JackLibClient::Open name = %s refnum = %ld\n", name, fClientControl->fRefNum);
+	
     return 0;
 
 error:

common/JackLibGlobals.h

@@ -76,7 +76,7 @@ struct JackLibGlobals
             JackGlobals::InitClient();
             InitTime();
             fGlobals = new JackLibGlobals();
-        }
+	   }
     }
 
     static void Destroy()

common/JackRequest.h

@@ -72,21 +72,25 @@ public:
     JackRequest(RequestType type): fType(type)
     {}
 
-  	~JackRequest()
+  	virtual ~JackRequest()
     {}
 
- 	int Read(JackChannelTransaction* trans)
+ 	virtual int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(this, sizeof(JackRequest));
+        //return trans->Read(this, sizeof(JackRequest));
+		return trans->Read(&fType, sizeof(RequestType));
     }
 
- 	int Write(JackChannelTransaction* trans)
+ 	virtual int Write(JackChannelTransaction* trans)
     {
-        return -1;
+        //return -1;
+		return trans->Write(&fType, sizeof(RequestType));
     }
 
 };
 
+#define CheckRes(res) {if (res < 0) return res;}
+
 /*!
 \brief Result from the server.
 */
@@ -105,12 +109,14 @@ struct JackResult
 
     virtual int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(this, sizeof(JackResult));
+        //return trans->Read(this, sizeof(JackResult));
+		return trans->Read(&fResult, sizeof(int));
     }
 
     virtual int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackResult));
+        //return trans->Write(this, sizeof(JackResult));
+		return trans->Write(&fResult, sizeof(int));
     }
 };
 
@@ -118,27 +124,29 @@ struct JackResult
 \brief NewClient request.
 */
 
-struct JackClientNewRequest 
+struct JackClientNewRequest : public JackRequest
 {
 
-	JackRequest fHeader;	
     char fName[JACK_CLIENT_NAME_SIZE + 1];
 
     JackClientNewRequest()
     {}
-    JackClientNewRequest(const char* name): fHeader(JackRequest::kClientNew)
+    JackClientNewRequest(const char* name): JackRequest(JackRequest::kClientNew)
     {
         snprintf(fName, sizeof(fName), "%s", name);
     }
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fName, sizeof(JackClientNewRequest) - sizeof(JackRequest));
+        //return trans->Read(&fName, sizeof(JackClientNewRequest) - sizeof(JackRequest));
+		return trans->Read(&fName, JACK_CLIENT_NAME_SIZE + 1);
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackClientNewRequest));
+        //return trans->Write(this, sizeof(JackClientNewRequest));
+		CheckRes(JackRequest::Write(trans));
+		return trans->Write(&fName, JACK_CLIENT_NAME_SIZE + 1);
     }
 };
 
@@ -146,10 +154,10 @@ struct JackClientNewRequest
 \brief NewClient result.
 */
 
-struct JackClientNewResult 
+struct JackClientNewResult : public JackResult
 {
 
-	JackResult fHeader;
+	//JackResult fHeader;
     int fSharedEngine;
     int fSharedClient;
     int fSharedGraph;
@@ -159,18 +167,28 @@ struct JackClientNewResult
 		:fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1), fProtocolVersion(0)
     {}
     JackClientNewResult(int32_t status, int index1, int index2, int index3)
-         : fHeader(status), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)
+         : JackResult(status), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3), fProtocolVersion(0)
     {}
 
-    //virtual int Read(JackChannelTransaction* trans)
-	int Read(JackChannelTransaction* trans)
+   int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(this, sizeof(JackClientNewResult));
+        //return trans->Read(this, sizeof(JackClientNewResult));
+		CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
+		CheckRes(trans->Read(&fSharedClient, sizeof(int)));
+		CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
+		CheckRes(trans->Read(&fProtocolVersion, sizeof(uint32_t)));
+		return 0;
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackClientNewResult));
+        //return trans->Write(this, sizeof(JackClientNewResult));
+		CheckRes(JackResult::Write(trans));
+		CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
+		CheckRes(trans->Write(&fSharedClient, sizeof(int)));
+		CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
+		CheckRes(trans->Write(&fProtocolVersion, sizeof(uint32_t)));
+		return 0;
     }
 };
 
@@ -178,25 +196,28 @@ struct JackClientNewResult
 \brief CloseClient request.
 */
 
-struct JackClientCloseRequest
+struct JackClientCloseRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fRefNum;
 
     JackClientCloseRequest()
     {}
-    JackClientCloseRequest(int refnum): fHeader(JackRequest::kClientClose), fRefNum(refnum)
+    JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackClientCloseRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackClientCloseRequest) - sizeof(JackRequest));
+		return trans->Read(&fRefNum, sizeof(int));
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackClientCloseRequest));
+        //return trans->Write(this, sizeof(JackClientCloseRequest));
+		CheckRes(JackRequest::Write(trans));
+		return trans->Write(&fRefNum, sizeof(int));
     }
 };
 
@@ -204,25 +225,28 @@ struct JackClientCloseRequest
 \brief Activate request.
 */
 
-struct JackActivateRequest
+struct JackActivateRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fRefNum;
 
     JackActivateRequest()
     {}
-    JackActivateRequest(int refnum): fHeader(JackRequest::kActivateClient), fRefNum(refnum)
+    JackActivateRequest(int refnum): JackRequest(JackRequest::kActivateClient), fRefNum(refnum)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackActivateRequest) - sizeof(JackRequest));
+		// return trans->Read(&fRefNum, sizeof(JackActivateRequest) - sizeof(JackRequest));
+		return trans->Read(&fRefNum, sizeof(int));
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackActivateRequest));
+        //return trans->Write(this, sizeof(JackActivateRequest));
+		CheckRes(JackRequest::Write(trans));
+		return trans->Write(&fRefNum, sizeof(int));
     }
 
 };
@@ -231,25 +255,28 @@ struct JackActivateRequest
 \brief Deactivate request.
 */
 
-struct JackDeactivateRequest
+struct JackDeactivateRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fRefNum;
 
     JackDeactivateRequest()
     {}
-    JackDeactivateRequest(int refnum): fHeader(JackRequest::kDeactivateClient), fRefNum(refnum)
+    JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackDeactivateRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackDeactivateRequest) - sizeof(JackRequest));
+		return trans->Read(&fRefNum, sizeof(int));
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackDeactivateRequest));
+        //return trans->Write(this, sizeof(JackDeactivateRequest));
+		CheckRes(JackRequest::Write(trans));
+		return trans->Write(&fRefNum, sizeof(int));
     }
 
 };
@@ -258,10 +285,10 @@ struct JackDeactivateRequest
 \brief PortRegister request.
 */
 
-struct JackPortRegisterRequest
+struct JackPortRegisterRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fRefNum;
     char fName[JACK_PORT_NAME_SIZE + 1];
     char fPortType[JACK_PORT_TYPE_SIZE + 1];
@@ -271,7 +298,7 @@ struct JackPortRegisterRequest
     JackPortRegisterRequest()
     {}
     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
-            : fHeader(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
+            : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
     {
         strcpy(fName, name);
         strcpy(fPortType, port_type);
@@ -279,12 +306,25 @@ struct JackPortRegisterRequest
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackPortRegisterRequest) - sizeof(JackRequest)) ;
+        //return trans->Read(&fRefNum, sizeof(JackPortRegisterRequest) - sizeof(JackRequest));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		CheckRes(trans->Read(&fName, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		CheckRes(trans->Read(&fPortType, sizeof(JACK_PORT_TYPE_SIZE + 1)));
+		CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
+		CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
+		return 0;
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackPortRegisterRequest));
+        //return trans->Write(this, sizeof(JackPortRegisterRequest));
+		CheckRes(JackRequest::Write(trans));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		CheckRes(trans->Write(&fName, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		CheckRes(trans->Write(&fPortType, sizeof(JACK_PORT_TYPE_SIZE + 1)));
+		CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
+		CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
+		return 0;
     }
 };
 
@@ -292,10 +332,10 @@ struct JackPortRegisterRequest
 \brief PortRegister result.
 */
 
-struct JackPortRegisterResult
+struct JackPortRegisterResult : public JackResult
 {
 
-	JackResult fHeader;
+	//JackResult fHeader;
     jack_port_id_t fPortIndex;
 
     JackPortRegisterResult(): fPortIndex(NO_PORT)
@@ -303,12 +343,15 @@ struct JackPortRegisterResult
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(this, sizeof(JackPortRegisterResult));
+        //return trans->Read(this, sizeof(JackPortRegisterResult));
+		return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackPortRegisterResult));
+        //return trans->Write(this, sizeof(JackPortRegisterResult));
+		CheckRes(JackResult::Write(trans));
+		return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
     }
 };
 
@@ -316,26 +359,33 @@ struct JackPortRegisterResult
 \brief PortUnregister request.
 */
 
-struct JackPortUnRegisterRequest
+struct JackPortUnRegisterRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fRefNum;
     int fPortIndex;
 
     JackPortUnRegisterRequest()
     {}
-    JackPortUnRegisterRequest(int refnum, int index): fHeader(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
+    JackPortUnRegisterRequest(int refnum, int index): JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackPortUnRegisterRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackPortUnRegisterRequest) - sizeof(JackRequest));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		CheckRes(trans->Read(&fPortIndex, sizeof(int)));
+		return 0;
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackPortUnRegisterRequest));
+        //return trans->Write(this, sizeof(JackPortUnRegisterRequest));
+		CheckRes(JackRequest::Write(trans));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		CheckRes(trans->Write(&fPortIndex, sizeof(int)));
+		return 0;
     }
 };
 
@@ -343,17 +393,17 @@ struct JackPortUnRegisterRequest
 \brief PortConnectName request.
 */
 
-struct JackPortConnectNameRequest
+struct JackPortConnectNameRequest : public JackRequest
 {
 	
-	JackRequest fHeader;
+	//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): fHeader(JackRequest::kConnectNamePorts), fRefNum(refnum)
+    JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
     {
         strcpy(fSrc, src_name);
         strcpy(fDst, dst_name);
@@ -361,12 +411,22 @@ struct JackPortConnectNameRequest
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackPortConnectNameRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackPortConnectNameRequest) - sizeof(JackRequest));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		CheckRes(trans->Read(&fSrc, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		CheckRes(trans->Read(&fDst, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		return 0;
+
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackPortConnectNameRequest));
+        //return trans->Write(this, sizeof(JackPortConnectNameRequest));
+		CheckRes(JackRequest::Write(trans));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		CheckRes(trans->Write(&fSrc, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		CheckRes(trans->Write(&fDst, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		return 0;
     }
 };
 
@@ -374,17 +434,17 @@ struct JackPortConnectNameRequest
 \brief PortDisconnectName request.
 */
 
-struct JackPortDisconnectNameRequest
+struct JackPortDisconnectNameRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//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): fHeader(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
+    JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name): JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
     {
         strcpy(fSrc, src_name);
         strcpy(fDst, dst_name);
@@ -392,12 +452,21 @@ struct JackPortDisconnectNameRequest
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackPortDisconnectNameRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackPortDisconnectNameRequest) - sizeof(JackRequest));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		CheckRes(trans->Read(&fSrc, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		CheckRes(trans->Read(&fDst, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		return 0;
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackPortDisconnectNameRequest));
+        //return trans->Write(this, sizeof(JackPortDisconnectNameRequest));
+		CheckRes(JackRequest::Write(trans));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		CheckRes(trans->Write(&fSrc, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		CheckRes(trans->Write(&fDst, sizeof(JACK_PORT_NAME_SIZE + 1)));
+		return 0;
     }
 };
 
@@ -405,27 +474,36 @@ struct JackPortDisconnectNameRequest
 \brief PortConnect request.
 */
 
-struct JackPortConnectRequest
+struct JackPortConnectRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//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): fHeader(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
+    JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackPortConnectRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackPortConnectRequest) - sizeof(JackRequest));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
+		CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
+		return 0;
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackPortConnectRequest));
+        //return trans->Write(this, sizeof(JackPortConnectRequest));
+		CheckRes(JackRequest::Write(trans));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
+		CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
+		return 0;
     }
 };
 
@@ -434,27 +512,37 @@ struct JackPortConnectRequest
 \brief PortDisconnect request.
 */
 
-struct JackPortDisconnectRequest
+struct JackPortDisconnectRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//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): fHeader(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
+    JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst): JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackPortDisconnectRequest) - sizeof(JackRequest));
+		//return trans->Read(&fRefNum, sizeof(JackPortConnectRequest) - sizeof(JackRequest));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
+		CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
+		return 0;
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackPortDisconnectRequest));
+        //return trans->Write(this, sizeof(JackPortConnectRequest));
+		CheckRes(JackRequest::Write(trans));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
+		CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
+		return 0;
+
     }
 };
 
@@ -462,25 +550,28 @@ struct JackPortDisconnectRequest
 \brief SetBufferSize request.
 */
 
-struct JackSetBufferSizeRequest
+struct JackSetBufferSizeRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     jack_nframes_t fBufferSize;
 
     JackSetBufferSizeRequest()
     {}
-    JackSetBufferSizeRequest(jack_nframes_t buffer_size): fHeader(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
+    JackSetBufferSizeRequest(jack_nframes_t buffer_size): JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fBufferSize, sizeof(JackSetBufferSizeRequest) - sizeof(JackRequest));
+        //return trans->Read(&fBufferSize, sizeof(JackSetBufferSizeRequest) - sizeof(JackRequest));
+		return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackSetBufferSizeRequest));
+        //return trans->Write(this, sizeof(JackSetBufferSizeRequest));
+		CheckRes(JackRequest::Write(trans));
+		return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
     }
 };
 
@@ -488,25 +579,28 @@ struct JackSetBufferSizeRequest
 \brief SetFreeWheel request.
 */
 
-struct JackSetFreeWheelRequest
+struct JackSetFreeWheelRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fOnOff;
 
     JackSetFreeWheelRequest()
     {}
-    JackSetFreeWheelRequest(int onoff): fHeader(JackRequest::kSetFreeWheel), fOnOff(onoff)
+    JackSetFreeWheelRequest(int onoff): JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fOnOff, sizeof(JackSetFreeWheelRequest) - sizeof(JackRequest));
+        //return trans->Read(&fOnOff, sizeof(JackSetFreeWheelRequest) - sizeof(JackRequest));
+		return trans->Read(&fOnOff, sizeof(int));
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackSetFreeWheelRequest));
+        //return trans->Write(this, sizeof(JackSetFreeWheelRequest));
+		CheckRes(JackRequest::Write(trans));
+		return trans->Write(&fOnOff, sizeof(int));
     }
 };
 
@@ -514,53 +608,60 @@ struct JackSetFreeWheelRequest
 \brief ReleaseTimebase request.
 */
 
-struct JackReleaseTimebaseRequest
+struct JackReleaseTimebaseRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fRefNum;
 
     JackReleaseTimebaseRequest()
     {}
-    JackReleaseTimebaseRequest(int refnum): fHeader(JackRequest::kReleaseTimebase), fRefNum(refnum)
+    JackReleaseTimebaseRequest(int refnum): JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackReleaseTimebaseRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackReleaseTimebaseRequest) - sizeof(JackRequest));
+		return trans->Read(&fRefNum, sizeof(int));
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackReleaseTimebaseRequest));
+        //return trans->Write(this, sizeof(JackReleaseTimebaseRequest));
+		CheckRes(JackRequest::Write(trans));
+		return trans->Write(&fRefNum, sizeof(int));
     }
-
 };
 
 /*!
 \brief SetTimebaseCallback request.
 */
 
-struct JackSetTimebaseCallbackRequest
+struct JackSetTimebaseCallbackRequest : public JackRequest
 {
 
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fRefNum;
     int fConditionnal;
 
     JackSetTimebaseCallbackRequest()
     {}
-    JackSetTimebaseCallbackRequest(int refnum, int conditional): fHeader(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
+    JackSetTimebaseCallbackRequest(int refnum, int conditional): JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackSetTimebaseCallbackRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackSetTimebaseCallbackRequest) - sizeof(JackRequest));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		return trans->Read(&fConditionnal, sizeof(int));
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackSetTimebaseCallbackRequest));
+        //return trans->Write(this, sizeof(JackSetTimebaseCallbackRequest));
+		CheckRes(JackRequest::Write(trans));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		return trans->Write(&fConditionnal, sizeof(int));
     }
 };
 
@@ -568,10 +669,10 @@ struct JackSetTimebaseCallbackRequest
 \brief ClientNotification request.
 */
 
-struct JackClientNotificationRequest
+struct JackClientNotificationRequest : public JackRequest
 {
 	
-	JackRequest fHeader;
+	//JackRequest fHeader;
     int fRefNum;
     int fNotify;
     int fValue;
@@ -579,17 +680,26 @@ struct JackClientNotificationRequest
     JackClientNotificationRequest()
     {}
     JackClientNotificationRequest(int refnum, int notify, int value)
-            : fHeader(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
+            : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
     {}
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(&fRefNum, sizeof(JackClientNotificationRequest) - sizeof(JackRequest));
+        //return trans->Read(&fRefNum, sizeof(JackClientNotificationRequest) - sizeof(JackRequest));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		CheckRes(trans->Read(&fNotify, sizeof(int)));
+		CheckRes(trans->Read(&fValue, sizeof(int)));
+		return 0;
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackClientNotificationRequest));
+        //return trans->Write(this, sizeof(JackClientNotificationRequest));
+		CheckRes(JackRequest::Write(trans));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		CheckRes(trans->Write(&fNotify, sizeof(int)));
+		CheckRes(trans->Write(&fValue, sizeof(int)));
+		return 0;
     }
 
 };
@@ -616,12 +726,24 @@ struct JackClientNotification
 
     int Read(JackChannelTransaction* trans)
     {
-        return trans->Read(this, sizeof(JackClientNotification));
+        //return trans->Read(this, sizeof(JackClientNotification));
+		CheckRes(trans->Read(&fName, sizeof(JACK_CLIENT_NAME_SIZE + 1)));
+		CheckRes(trans->Read(&fRefNum, sizeof(int)));
+		CheckRes(trans->Read(&fNotify, sizeof(int)));
+		CheckRes(trans->Read(&fValue, sizeof(int)));
+		CheckRes(trans->Read(&fValue, sizeof(fSync)));
+		return 0;
     }
 
     int Write(JackChannelTransaction* trans)
     {
-        return trans->Write(this, sizeof(JackClientNotification));
+        //return trans->Write(this, sizeof(JackClientNotification));
+		CheckRes(trans->Write(&fName, sizeof(JACK_CLIENT_NAME_SIZE + 1)));
+		CheckRes(trans->Write(&fRefNum, sizeof(int)));
+		CheckRes(trans->Write(&fNotify, sizeof(int)));
+		CheckRes(trans->Write(&fValue, sizeof(int)));
+		CheckRes(trans->Write(&fValue, sizeof(fSync)));
+		return 0;
     }
 
 };

common/JackShmMem.cpp

@@ -29,6 +29,7 @@ unsigned long JackShmMem::fSegmentNum = 0;
 unsigned long JackShmMem::fSegmentCount = 0;
 
 jack_shm_info_t JackShmMem::gInfo;
+size_t JackLockMem::gSize = 0;
 
 void* JackShmMem::operator new(size_t size)
 {

common/JackShmMem.h

@@ -22,13 +22,75 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 #define __JackShmMem__
 
 #include "shm.h"
-#include <new>  // GCC 4.0
 #include "JackError.h"
-#include <errno.h>
 
+#include <new>  // GCC 4.0
+#include <errno.h> 
+#include <stdlib.h>
+
+#ifdef WIN32
+	#include <windows.h>
+#else
+	#include <sys/types.h>
+	#include <sys/mman.h>
+#endif
+  
 namespace Jack
 {
 
+class JackLockMem
+{
+	private:
+
+		size_t fSize;
+		static size_t gSize;
+	
+	public:
+
+        void* operator new(size_t size)
+		{	
+			gSize = size;
+			return malloc(size);
+		}
+		
+        void operator delete(void* ptr, size_t size)
+		{	
+			free(ptr);
+		}
+
+        JackLockMem():fSize(gSize)
+        {}
+
+        virtual ~JackLockMem()
+        {
+			UnlockMemory();
+		}
+		
+		void LockMemory() 
+		{
+		#ifdef __APPLE __
+			mlock(ptr, size);
+		#elseif linux_
+			mlock(ptr, size);
+		#elseif WIN32
+			VirtualLock(ptr, size);
+		#endif
+		}
+		
+		void UnlockMemory() 
+		{
+		#ifdef __APPLE __
+			munlock(ptr, size);
+		#elseif linux_
+			munlock(ptr, size);
+		#elseif WIN32
+			VirtualUnlock(ptr, size);
+		#endif
+		}
+
+};
+
+
 /*!
 \brief The base class for shared memory management.
  

common/JackSocketClientChannel.cpp

@@ -86,7 +86,6 @@ void JackSocketClientChannel::Stop()
     fThread->Kill();
 }
 
-/*
 void JackSocketClientChannel::ServerSyncCall(JackRequest* req, JackResult* res, int* result)
 {
     if (req->Write(&fRequestSocket) < 0) {
@@ -113,14 +112,14 @@ 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;
@@ -132,8 +131,9 @@ void JackSocketClientChannel::ClientNew(const char* name, int* shared_engine, in
         *result = -1;
         return ;
     }
+	*/
 
-    *result = res.fHeader.fResult;
+    *result = res.fResult;
     *shared_engine = res.fSharedEngine;
     *shared_client = res.fSharedClient;
     *shared_graph = res.fSharedGraph;
@@ -143,20 +143,23 @@ 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;
@@ -168,6 +171,7 @@ void JackSocketClientChannel::ClientActivate(int refnum, int* result)
         *result = -1;
         return ;
     }
+	*/
 
     *result = res.fResult;
 }
@@ -176,7 +180,8 @@ 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;
@@ -188,7 +193,7 @@ void JackSocketClientChannel::ClientDeactivate(int refnum, int* result)
         *result = -1;
         return ;
     }
-
+	*/
 	*result = res.fResult;
 }
 
@@ -196,7 +201,8 @@ void JackSocketClientChannel::PortRegister(int refnum, const char* name, unsigne
 {
     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;
@@ -208,8 +214,9 @@ void JackSocketClientChannel::PortRegister(int refnum, const char* name, unsigne
         *result = -1;
         return ;
     }
+	*/
 
-    *result = res.fHeader.fResult;
+    *result = res.fResult;
     *port_index = res.fPortIndex;
 }
 
@@ -217,7 +224,8 @@ 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;
@@ -229,7 +237,7 @@ void JackSocketClientChannel::PortUnRegister(int refnum, jack_port_id_t port_ind
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 
@@ -237,7 +245,8 @@ void JackSocketClientChannel::PortConnect(int refnum, const char* src, const cha
 {
     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;
@@ -249,7 +258,7 @@ void JackSocketClientChannel::PortConnect(int refnum, const char* src, const cha
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 
@@ -257,7 +266,8 @@ void JackSocketClientChannel::PortDisconnect(int refnum, const char* src, const
 {
     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;
@@ -269,7 +279,7 @@ void JackSocketClientChannel::PortDisconnect(int refnum, const char* src, const
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 
@@ -277,7 +287,8 @@ void JackSocketClientChannel::PortConnect(int refnum, jack_port_id_t src, jack_p
 {
     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;
@@ -289,7 +300,7 @@ void JackSocketClientChannel::PortConnect(int refnum, jack_port_id_t src, jack_p
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 
@@ -297,7 +308,8 @@ void JackSocketClientChannel::PortDisconnect(int refnum, jack_port_id_t src, jac
 {
     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;
@@ -309,7 +321,7 @@ void JackSocketClientChannel::PortDisconnect(int refnum, jack_port_id_t src, jac
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 
@@ -317,7 +329,8 @@ void JackSocketClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* res
 {
     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;
@@ -329,7 +342,7 @@ void JackSocketClientChannel::SetBufferSize(jack_nframes_t buffer_size, int* res
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 
@@ -337,7 +350,8 @@ 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;
@@ -349,7 +363,7 @@ void JackSocketClientChannel::SetFreewheel(int onoff, int* result)
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 
@@ -357,7 +371,8 @@ 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;
@@ -369,7 +384,7 @@ void JackSocketClientChannel::ReleaseTimebase(int refnum, int* result)
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 
@@ -377,7 +392,9 @@ void JackSocketClientChannel::SetTimebaseCallback(int refnum, int conditional, i
 {
     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;
@@ -389,7 +406,7 @@ void JackSocketClientChannel::SetTimebaseCallback(int refnum, int conditional, i
         *result = -1;
         return ;
     }
-
+	*/
     *result = res.fResult;
 }
 

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.fHeader.fResult);
+					AddClient(fd, req.fName, &res.fSharedEngine, &res.fSharedClient, &res.fSharedGraph, &res.fResult);
                 res.Write(socket);
                 break;
             }
@@ -196,7 +196,7 @@ int JackSocketServerChannel::HandleRequest(int fd)
                 JackPortRegisterRequest req;
                 JackPortRegisterResult res;
                 if (req.Read(socket) == 0)
-					res.fHeader.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fFlags, req.fBufferSize, &res.fPortIndex);
+					res.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.fHeader.fType);
+        jack_error("Could not write request type = %ld", req.fType);
     }
 }