diff --git a/common/JackGenericClientChannel.cpp b/common/JackGenericClientChannel.cpp
index 96401d29..b54f7aab 100644
--- a/common/JackGenericClientChannel.cpp
+++ b/common/JackGenericClientChannel.cpp
@@ -60,13 +60,13 @@ void JackGenericClientChannel::ServerSyncCall(JackRequest* req, JackResult* res,
     }
     
     if (req->Write(fRequest) < 0) {
-        jack_error("Could not write request type = %ld", req->fType);
+        jack_error("Could not write request type = %ld", req->getType());
         *result = -1;
         return;
     }
 
     if (res->Read(fRequest) < 0) {
-        jack_error("Could not read result type = %ld", req->fType);
+        jack_error("Could not read result type = %ld", req->getType());
         *result = -1;
         return;
     }
@@ -90,7 +90,7 @@ void JackGenericClientChannel::ServerAsyncCall(JackRequest* req, JackResult* res
     }
     
     if (req->Write(fRequest) < 0) {
-        jack_error("Could not write request type = %ld", req->fType);
+        jack_error("Could not write request type = %ld", req->getType());
         *result = -1;
     } else {
         *result = 0;
diff --git a/common/JackRequest.h b/common/JackRequest.h
index dd28b3d0..197a6daa 100644
--- a/common/JackRequest.h
+++ b/common/JackRequest.h
@@ -93,32 +93,16 @@ struct JackRequest
         kPropertyChangeNotify = 40
     };
 
-    RequestType fType;
-    int fSize;
-
-    JackRequest(RequestType type): fType(type), fSize(0)
-    {}
-
-    virtual ~JackRequest()
-    {}
-
     static int ReadType(detail::JackChannelTransactionInterface* trans, RequestType& type)
     {
         type = (RequestType)0;
-        CheckRes(trans->Read(&type, sizeof(fType)));
+        CheckRes(trans->Read(&type, sizeof(RequestType)));
         return 0;
     }
 
-    virtual int Write(detail::JackChannelTransactionInterface* trans) { return -1; }
-
-    virtual int Write(detail::JackChannelTransactionInterface* trans, int size)
-    {
-        fSize = size;
-        CheckRes(trans->Write(&fType, sizeof(RequestType)));
-        return trans->Write(&fSize, sizeof(int));
-    }
-
-    virtual int Size() { return 0; }
+    virtual int Read(detail::JackChannelTransactionInterface* trans) = 0;
+    virtual int Write(detail::JackChannelTransactionInterface* trans) = 0;
+    virtual RequestType getType() = 0;
 
 };
 
@@ -215,7 +199,8 @@ struct JackResult
 \brief CheckClient request.
 */
 
-struct JackClientCheckRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackClientCheckRequestData
 {
 
     char fName[JACK_CLIENT_NAME_SIZE+1];
@@ -224,36 +209,20 @@ struct JackClientCheckRequest : public JackRequest
     int fOpen;
     jack_uuid_t fUUID;
 
-    JackClientCheckRequest(const char* name="", int protocol=0, int options=0, int uuid=JACK_UUID_EMPTY_INITIALIZER, int open = false)
-        : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fOpen(open), fUUID(uuid)
+    JackClientCheckRequestData(const char* name="", int protocol=0, int options=0, jack_uuid_t uuid=JACK_UUID_EMPTY_INITIALIZER, int open = false)
+        : fProtocol(protocol), fOptions(options), fOpen(open), fUUID(uuid)
     {
         memset(fName, 0, sizeof(fName));
         snprintf(fName, sizeof(fName), "%s", name);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fName, sizeof(fName)));
-        CheckRes(trans->Read(&fProtocol, sizeof(int)));
-        CheckRes(trans->Read(&fOptions, sizeof(int)));
-        CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
-        return trans->Read(&fOpen, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fName, sizeof(fName)));
-        CheckRes(trans->Write(&fProtocol, sizeof(int)));
-        CheckRes(trans->Write(&fOptions, sizeof(int)));
-        CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
-        return trans->Write(&fOpen, sizeof(int));
+        return JackRequest::RequestType::kClientCheck;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(fName) + 3 * sizeof(int) + sizeof(jack_uuid_t); }
-
-};
+typedef JackRequestTemplate<JackClientCheckRequestData> JackClientCheckRequest;
 
 /*!
 \brief CheckClient result.
@@ -298,14 +267,15 @@ struct JackClientCheckResult : public JackResult
 \brief NewClient request.
 */
 
-struct JackClientOpenRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackClientOpenRequestData
 {
 
     int fPID;
     jack_uuid_t fUUID;
     char fName[JACK_CLIENT_NAME_SIZE+1];
 
-    JackClientOpenRequest(const char* name="", int pid=0, jack_uuid_t uuid=JACK_UUID_EMPTY_INITIALIZER): JackRequest(JackRequest::kClientOpen)
+    JackClientOpenRequestData(const char* name="", int pid=0, jack_uuid_t uuid=JACK_UUID_EMPTY_INITIALIZER)
     {
         memset(fName, 0, sizeof(fName));
         snprintf(fName, sizeof(fName), "%s", name);
@@ -313,25 +283,13 @@ struct JackClientOpenRequest : public JackRequest
         fUUID = uuid;
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fPID, sizeof(int)));
-        CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
-        return trans->Read(&fName, sizeof(fName));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fPID, sizeof(int)));
-        CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
-        return trans->Write(&fName, sizeof(fName));
+        return JackRequest::RequestType::kClientOpen;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(jack_uuid_t) + sizeof(fName); }
-
-};
+typedef JackRequestTemplate<JackClientOpenRequestData> JackClientOpenRequest;
 
 /*!
 \brief NewClient result.
@@ -375,92 +333,73 @@ struct JackClientOpenResult : public JackResult
 \brief CloseClient request.
 */
 
-struct JackClientCloseRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackClientCloseRequestData
 {
 
     int fRefNum;
 
-    JackClientCloseRequest(int refnum=0): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
+    JackClientCloseRequestData(int refnum=0): fRefNum(refnum)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        return trans->Read(&fRefNum, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        return trans->Write(&fRefNum, sizeof(int));
+        return JackRequest::RequestType::kClientClose;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int); }
-};
+typedef JackRequestTemplate<JackClientCloseRequestData> JackClientCloseRequest;
 
 /*!
 \brief Activate request.
 */
 
-struct JackActivateRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackActivateRequestData
 {
 
     int fRefNum;
     int fIsRealTime;
 
-    JackActivateRequest(int refnum=0, int is_real_time=0)
-        : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
+    JackActivateRequestData(int refnum=0, int is_real_time=0)
+        : fRefNum(refnum), fIsRealTime(is_real_time)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        return trans->Read(&fIsRealTime, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        return trans->Write(&fIsRealTime, sizeof(int));
+        return JackRequest::RequestType::kActivateClient;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return 2 * sizeof(int); }
-};
+typedef JackRequestTemplate<JackActivateRequestData> JackActivateRequest;
 
 /*!
 \brief Deactivate request.
 */
 
-struct JackDeactivateRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackDeactivateRequestData
 {
 
     int fRefNum;
 
-    JackDeactivateRequest(int refnum=0): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
+    JackDeactivateRequestData(int refnum=0) : fRefNum(refnum)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        return trans->Read(&fRefNum, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        return trans->Write(&fRefNum, sizeof(int));
+        return JackRequest::RequestType::kDeactivateClient;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int); }
-};
+typedef JackRequestTemplate<JackDeactivateRequestData> JackDeactivateRequest;
 
 /*!
 \brief PortRegister request.
 */
 
-struct JackPortRegisterRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackPortRegisterRequestData
 {
 
     int fRefNum;
@@ -469,8 +408,8 @@ struct JackPortRegisterRequest : public JackRequest
     unsigned int fFlags;
     unsigned int fBufferSize;
 
-    JackPortRegisterRequest(int refnum=0, const char* name="", const char* port_type="", unsigned int flags=0, unsigned int buffer_size=0)
-            : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
+    JackPortRegisterRequestData(int refnum=0, const char* name="", const char* port_type="", unsigned int flags=0, unsigned int buffer_size=0)
+            : fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
     {
         memset(fName, 0, sizeof(fName));
         memset(fPortType, 0, sizeof(fPortType));
@@ -478,31 +417,14 @@ struct JackPortRegisterRequest : public JackRequest
         strncpy(fPortType, port_type, sizeof(fPortType)-1);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        CheckRes(trans->Read(&fName, sizeof(fName)));
-        CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
-        CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
-        CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
-        return 0;
-    }
 
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        CheckRes(trans->Write(&fName, sizeof(fName)));
-        CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
-        CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
-        CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
-        return 0;
+        return JackRequest::RequestType::kRegisterPort;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(fName) + sizeof(fPortType) + 2 * sizeof(unsigned int); }
-
-};
+typedef JackRequestTemplate<JackPortRegisterRequestData> JackPortRegisterRequest;
 
 /*!
 \brief PortRegister result.
@@ -534,48 +456,39 @@ struct JackPortRegisterResult : public JackResult
 \brief PortUnregister request.
 */
 
-struct JackPortUnRegisterRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackPortUnRegisterRequestData
 {
 
     int fRefNum;
     jack_port_id_t fPortIndex;
 
-    JackPortUnRegisterRequest(int refnum=0, jack_port_id_t index=0)
-        : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
+    JackPortUnRegisterRequestData(int refnum=0, jack_port_id_t index=0)
+        : fRefNum(refnum), fPortIndex(index)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
-        return 0;
+        return JackRequest::RequestType::kUnRegisterPort;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(jack_port_id_t); }
-};
+typedef JackRequestTemplate<JackPortUnRegisterRequestData> JackPortUnRegisterRequest;
 
 /*!
 \brief PortConnectName request.
 */
 
-struct JackPortConnectNameRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackPortConnectNameRequestData
 {
 
     int fRefNum;
     char fSrc[REAL_JACK_PORT_NAME_SIZE+1];    // port full name
     char fDst[REAL_JACK_PORT_NAME_SIZE+1];    // port full name
 
-    JackPortConnectNameRequest(int refnum=0, const char* src_name="", const char* dst_name="")
-        : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
+    JackPortConnectNameRequestData(int refnum=0, const char* src_name="", const char* dst_name="")
+        : fRefNum(refnum)
     {
         memset(fSrc, 0, sizeof(fSrc));
         memset(fDst, 0, sizeof(fDst));
@@ -583,41 +496,28 @@ struct JackPortConnectNameRequest : public JackRequest
         strncpy(fDst, dst_name, sizeof(fDst)-1);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
-        CheckRes(trans->Read(&fDst, sizeof(fDst)));
-        return 0;
+        return JackRequest::RequestType::kConnectNamePorts;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Write(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
-        CheckRes(trans->Write(&fDst, sizeof(fDst)));
-        return 0;
-    }
-
-    int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
-
-};
+typedef JackRequestTemplate<JackPortConnectNameRequestData> JackPortConnectNameRequest;
 
 /*!
 \brief PortDisconnectName request.
 */
 
-struct JackPortDisconnectNameRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackPortDisconnectNameRequestData
 {
 
     int fRefNum;
     char fSrc[REAL_JACK_PORT_NAME_SIZE+1];    // port full name
     char fDst[REAL_JACK_PORT_NAME_SIZE+1];    // port full name
 
-    JackPortDisconnectNameRequest(int refnum=0, const char* src_name="", const char* dst_name="")
-        : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
+    JackPortDisconnectNameRequestData(int refnum=0, const char* src_name="", const char* dst_name="")
+        : fRefNum(refnum)
     {
         memset(fSrc, 0, sizeof(fSrc));
         memset(fDst, 0, sizeof(fDst));
@@ -625,313 +525,215 @@ struct JackPortDisconnectNameRequest : public JackRequest
         strncpy(fDst, dst_name, sizeof(fDst)-1);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
-        CheckRes(trans->Read(&fDst, sizeof(fDst)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
-        CheckRes(trans->Write(&fDst, sizeof(fDst)));
-        return 0;
+        return JackRequest::RequestType::kDisconnectNamePorts;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(fSrc) + sizeof(fDst); }
-
-};
+typedef JackRequestTemplate<JackPortDisconnectNameRequestData> JackPortDisconnectNameRequest;
 
 /*!
 \brief PortConnect request.
 */
 
-struct JackPortConnectRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackPortConnectRequestData
 {
 
     int fRefNum;
     jack_port_id_t fSrc;
     jack_port_id_t fDst;
 
-    JackPortConnectRequest(int refnum=0, jack_port_id_t src=0, jack_port_id_t dst=0)
-        : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
+    JackPortConnectRequestData(int refnum=0, jack_port_id_t src=0, jack_port_id_t dst=0)
+        : fRefNum(refnum), fSrc(src), fDst(dst)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        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(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        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;
+        return JackRequest::RequestType::kConnectPorts;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
-};
+typedef JackRequestTemplate<JackPortConnectRequestData> JackPortConnectRequest;
 
 /*!
 \brief PortDisconnect request.
 */
 
-struct JackPortDisconnectRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackPortDisconnectRequestData
 {
 
     int fRefNum;
     jack_port_id_t fSrc;
     jack_port_id_t fDst;
 
-    JackPortDisconnectRequest(int refnum=0, jack_port_id_t src=0, jack_port_id_t dst=0)
-        : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
+    JackPortDisconnectRequestData(int refnum=0, jack_port_id_t src=0, jack_port_id_t dst=0)
+        : fRefNum(refnum), fSrc(src), fDst(dst)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckSize();
-        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;
+        return JackRequest::RequestType::kDisconnectPorts;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Write(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckRes(JackRequest::Write(trans, Size()));
-        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;
-    }
-
-    int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(jack_port_id_t); }
-};
+typedef JackRequestTemplate<JackPortDisconnectRequestData> JackPortDisconnectRequest;
 
 /*!
 \brief PortRename request.
 */
 
-struct JackPortRenameRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackPortRenameRequestData
 {
 
     int fRefNum;
     jack_port_id_t fPort;
     char fName[JACK_PORT_NAME_SIZE + 1];   // port short name
 
-    JackPortRenameRequest(int refnum=0, jack_port_id_t port=0, const char* name="")
-        : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
+    JackPortRenameRequestData(int refnum=0, jack_port_id_t port=0, const char* name="")
+        : fRefNum(refnum), fPort(port)
     {
         memset(fName, 0, sizeof(fName));
         strncpy(fName, name, sizeof(fName)-1);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
-        CheckRes(trans->Read(&fName, sizeof(fName)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
-        CheckRes(trans->Write(&fName, sizeof(fName)));
-        return 0;
+        return JackRequest::RequestType::kPortRename;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(fName); }
-
-};
+typedef JackRequestTemplate<JackPortRenameRequestData> JackPortRenameRequest;
 
 /*!
 \brief SetBufferSize request.
 */
 
-struct JackSetBufferSizeRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackSetBufferSizeRequestData
 {
 
     jack_nframes_t fBufferSize;
 
-    JackSetBufferSizeRequest(jack_nframes_t buffer_size=0)
-        : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
+    JackSetBufferSizeRequestData(jack_nframes_t buffer_size=0)
+        : fBufferSize(buffer_size)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
+        return JackRequest::RequestType::kSetBufferSize;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(jack_nframes_t); }
-};
+typedef JackRequestTemplate<JackSetBufferSizeRequestData> JackSetBufferSizeRequest;
 
 /*!
 \brief SetFreeWheel request.
 */
 
-struct JackSetFreeWheelRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackSetFreeWheelRequestData
 {
 
     int fOnOff;
 
-    JackSetFreeWheelRequest(int onoff=0)
-        : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
+    JackSetFreeWheelRequestData(int onoff=0)
+        : fOnOff(onoff)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        return trans->Read(&fOnOff, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        return trans->Write(&fOnOff, sizeof(int));
+        return JackRequest::RequestType::kSetFreeWheel;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int); }
-
-};
+typedef JackRequestTemplate<JackSetFreeWheelRequestData> JackSetFreeWheelRequest;
 
 /*!
 \brief ComputeTotalLatencies request.
 */
 
-struct JackComputeTotalLatenciesRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackComputeTotalLatenciesRequestData
 {
-
-    JackComputeTotalLatenciesRequest()
-        : JackRequest(JackRequest::kComputeTotalLatencies)
-    {}
-
-    int Read(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckSize();
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckRes(JackRequest::Write(trans, Size()));
-        return 0;
+        return JackRequest::RequestType::kComputeTotalLatencies;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return 0; }
-};
+typedef JackRequestTemplate<JackComputeTotalLatenciesRequestData> JackComputeTotalLatenciesRequest;
 
 /*!
 \brief ReleaseTimebase request.
 */
 
-struct JackReleaseTimebaseRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackReleaseTimebaseRequestData
 {
 
     int fRefNum;
 
-    JackReleaseTimebaseRequest(int refnum=0)
-        : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
+    JackReleaseTimebaseRequestData(int refnum=0)
+        : fRefNum(refnum)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        return trans->Read(&fRefNum, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        return trans->Write(&fRefNum, sizeof(int));
+        return JackRequest::RequestType::kReleaseTimebase;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int); }
-
-};
+typedef JackRequestTemplate<JackReleaseTimebaseRequestData> JackReleaseTimebaseRequest;
 
 /*!
 \brief SetTimebaseCallback request.
 */
 
-struct JackSetTimebaseCallbackRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackSetTimebaseCallbackRequestData
 {
 
     int fRefNum;
     int fConditionnal;
 
-    JackSetTimebaseCallbackRequest(int refnum=0, int conditional=0)
-        : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
+    JackSetTimebaseCallbackRequestData(int refnum=0, int conditional=0)
+        : fRefNum(refnum), fConditionnal(conditional)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        return trans->Read(&fConditionnal, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        return trans->Write(&fConditionnal, sizeof(int));
+        return JackRequest::RequestType::kSetTimebaseCallback;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(int); }
-};
+typedef JackRequestTemplate<JackSetTimebaseCallbackRequestData> JackSetTimebaseCallbackRequest;
 
 /*!
 \brief GetInternalClientName request.
 */
 
-struct JackGetInternalClientNameRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackGetInternalClientNameRequestData
 {
 
     int fRefNum;
     int fIntRefNum;
 
-    JackGetInternalClientNameRequest(int refnum=0, int int_ref=0)
-            : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
+    JackGetInternalClientNameRequestData(int refnum=0, int int_ref=0)
+            : fRefNum(refnum), fIntRefNum(int_ref)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        return trans->Read(&fIntRefNum, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        return trans->Write(&fIntRefNum, sizeof(int));
+        return JackRequest::RequestType::kGetInternalClientName;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(int); }
-};
+typedef JackRequestTemplate<JackGetInternalClientNameRequestData> JackGetInternalClientNameRequest;
 
 /*!
 \brief GetInternalClient result.
@@ -974,35 +776,27 @@ struct JackGetInternalClientNameResult : public JackResult
 \brief InternalClientHandle request.
 */
 
-struct JackInternalClientHandleRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackInternalClientHandleRequestData
 {
 
     int fRefNum;
     char fName[JACK_CLIENT_NAME_SIZE+1];
 
-    JackInternalClientHandleRequest(int refnum=0, const char* client_name="")
-            : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
+    JackInternalClientHandleRequestData(int refnum=0, const char* client_name="")
+            : fRefNum(refnum)
     {
         memset(fName, 0, sizeof(fName));
         snprintf(fName, sizeof(fName), "%s", client_name);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        return trans->Read(&fName, sizeof(fName));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        return trans->Write(&fName, sizeof(fName));
+        return JackRequest::RequestType::kInternalClientHandle;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(fName); }
-};
+typedef JackRequestTemplate<JackInternalClientHandleRequestData> JackInternalClientHandleRequest;
 
 /*!
 \brief InternalClientHandle result.
@@ -1043,7 +837,8 @@ struct JackInternalClientHandleResult : public JackResult
 \brief InternalClientLoad request.
 */
 
-struct JackInternalClientLoadRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackInternalClientLoadRequestData
 {
 
 #ifndef MAX_PATH
@@ -1057,8 +852,8 @@ struct JackInternalClientLoadRequest : public JackRequest
     int fOptions;
     jack_uuid_t fUUID;
 
-    JackInternalClientLoadRequest(int refnum=0, const char* client_name="", const char* so_name="", const char* objet_data="", int options=0, jack_uuid_t uuid=JACK_UUID_EMPTY_INITIALIZER)
-            : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
+    JackInternalClientLoadRequestData(int refnum=0, const char* client_name="", const char* so_name="", const char* objet_data="", int options=0, jack_uuid_t uuid=JACK_UUID_EMPTY_INITIALIZER)
+            : fRefNum(refnum), fOptions(options), fUUID(uuid)
     {
         memset(fName, 0, sizeof(fName));
         memset(fDllName, 0, sizeof(fDllName));
@@ -1072,30 +867,13 @@ struct JackInternalClientLoadRequest : public JackRequest
         }
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        CheckRes(trans->Read(&fName, sizeof(fName)));
-        CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
-        CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
-        CheckRes(trans->Read(&fUUID, sizeof(jack_uuid_t)));
-        return trans->Read(&fOptions, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        CheckRes(trans->Write(&fName, sizeof(fName)));
-        CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
-        CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
-        CheckRes(trans->Write(&fUUID, sizeof(jack_uuid_t)));
-        return trans->Write(&fOptions, sizeof(int));
+        return JackRequest::RequestType::kInternalClientLoad;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(fName) + sizeof(fDllName) + sizeof(fLoadInitName) + sizeof(int) + sizeof(jack_uuid_t); }
-};
+typedef JackRequestTemplate<JackInternalClientLoadRequestData> JackInternalClientLoadRequest;
 
 /*!
 \brief InternalClientLoad result.
@@ -1136,32 +914,24 @@ struct JackInternalClientLoadResult : public JackResult
 \brief InternalClientUnload request.
 */
 
-struct JackInternalClientUnloadRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackInternalClientUnloadRequestData
 {
 
     int fRefNum;
     int fIntRefNum;
 
-    JackInternalClientUnloadRequest(int refnum=0, int int_ref=0)
-            : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
+    JackInternalClientUnloadRequestData(int refnum=0, int int_ref=0)
+            : fRefNum(refnum), fIntRefNum(int_ref)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        return trans->Read(&fIntRefNum, sizeof(int));
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        return trans->Write(&fIntRefNum, sizeof(int));
+        return JackRequest::RequestType::kInternalClientUnload;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int) + sizeof(int); }
-};
+typedef JackRequestTemplate<JackInternalClientUnloadRequestData> JackInternalClientUnloadRequest;
 
 /*!
 \brief InternalClientLoad result.
@@ -1199,38 +969,26 @@ struct JackInternalClientUnloadResult : public JackResult
 \brief ClientNotification request.
 */
 
-struct JackClientNotificationRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackClientNotificationRequestData
 {
 
     int fRefNum;
     int fNotify;
     int fValue;
 
-    JackClientNotificationRequest(int refnum=0, int notify=0, int value=0)
-            : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
+    JackClientNotificationRequestData(int refnum=0, int notify=0, int value=0)
+            : fRefNum(refnum), fNotify(notify), fValue(value)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        CheckRes(trans->Read(&fNotify, sizeof(int)));
-        CheckRes(trans->Read(&fValue, sizeof(int)));
-        return 0;
-    }
 
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        CheckRes(trans->Write(&fNotify, sizeof(int)));
-        CheckRes(trans->Write(&fValue, sizeof(int)));
-        return 0;
+        return JackRequest::RequestType::kNotification;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return 3 * sizeof(int); }
-
-};
+typedef JackRequestTemplate<JackClientNotificationRequestData> JackClientNotificationRequest;
 
 struct JackSessionCommand
 {
@@ -1350,15 +1108,16 @@ struct JackSessionNotifyResult : public JackResult
 \brief SessionNotify request.
 */
 
-struct JackSessionNotifyRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackSessionNotifyRequestData
 {
     char fPath[JACK_MESSAGE_SIZE+1];
     char fDst[JACK_CLIENT_NAME_SIZE+1];
     jack_session_event_type_t fEventType;
     int fRefNum;
 
-    JackSessionNotifyRequest(int refnum=0, const char* path="", jack_session_event_type_t type=JackSessionSave, const char* dst=NULL)
-            : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
+    JackSessionNotifyRequestData(int refnum=0, const char* path="", jack_session_event_type_t type=JackSessionSave, const char* dst=NULL)
+            : fEventType(type), fRefNum(refnum)
     {
         memset(fPath, 0, sizeof(fPath));
         memset(fDst, 0, sizeof(fDst));
@@ -1368,54 +1127,30 @@ struct JackSessionNotifyRequest : public JackRequest
         }
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
-        CheckRes(trans->Read(&fPath, sizeof(fPath)));
-        CheckRes(trans->Read(&fDst, sizeof(fDst)));
-        CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
-        CheckRes(trans->Write(&fPath, sizeof(fPath)));
-        CheckRes(trans->Write(&fDst, sizeof(fDst)));
-        CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
-        return 0;
+        return JackRequest::RequestType::kSessionNotify;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(fRefNum) + sizeof(fPath) + sizeof(fDst) + sizeof(fEventType); }
-};
+typedef JackRequestTemplate<JackSessionNotifyRequestData> JackSessionNotifyRequest;
 
-struct JackSessionReplyRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackSessionReplyRequestData
 {
     int fRefNum;
 
-    JackSessionReplyRequest(int refnum=0)
-            : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
+    JackSessionReplyRequestData(int refnum=0)
+            : fRefNum(refnum)
     {}
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fRefNum, sizeof(int)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fRefNum, sizeof(int)));
-        return 0;
+        return JackRequest::RequestType::kSessionReply;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(int); }
-
-};
+typedef JackRequestTemplate<JackSessionReplyRequestData> JackSessionReplyRequest;
 
 struct JackClientNameResult : public JackResult
 {
@@ -1479,144 +1214,98 @@ struct JackUUIDResult : public JackResult
 
 };
 
-struct JackGetUUIDRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackGetUUIDRequestData
 {
     char fName[JACK_CLIENT_NAME_SIZE+1];
 
-    JackGetUUIDRequest(const char* client_name="")
-            : JackRequest(JackRequest::kGetUUIDByClient)
+    JackGetUUIDRequestData(const char* client_name="")
     {
         memset(fName, 0, sizeof(fName));
         strncpy(fName, client_name, sizeof(fName)-1);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fName, sizeof(fName)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fName, sizeof(fName)));
-        return 0;
+        return JackRequest::RequestType::kGetUUIDByClient;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(fName); }
-
-};
+typedef JackRequestTemplate<JackGetUUIDRequestData> JackGetUUIDRequest;
 
-struct JackGetClientNameRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackGetClientNameRequestData
 {
     char fUUID[JACK_UUID_STRING_SIZE];
 
-    JackGetClientNameRequest(const char* uuid="")
-            : JackRequest(JackRequest::kGetClientByUUID)
+    JackGetClientNameRequestData(const char* uuid="")
     {
         memset(fUUID, 0, sizeof(fUUID));
         strncpy(fUUID, uuid, sizeof(fUUID)-1);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
-        return 0;
+        return JackRequest::RequestType::kGetClientByUUID;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(fUUID); }
-
-};
+typedef JackRequestTemplate<JackGetClientNameRequestData> JackGetClientNameRequest;
 
-struct JackReserveNameRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackReserveNameRequestData
 {
     int  fRefNum;
     char fName[JACK_CLIENT_NAME_SIZE+1];
     char fUUID[JACK_UUID_STRING_SIZE];
 
-    JackReserveNameRequest(int refnum=0, const char *name="", const char* uuid="")
-            : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
+    JackReserveNameRequestData(int refnum=0, const char *name="", const char* uuid="")
+            : fRefNum(refnum)
     {
         memset(fName, 0, sizeof(fName));
         memset(fUUID, 0, sizeof(fUUID));
         strncpy(fName, name, sizeof(fName)-1);
         strncpy(fUUID, uuid, sizeof(fUUID)-1);
     }
+    
 
-    int Read(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckSize();
-        CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
-        CheckRes(trans->Read(&fName, sizeof(fName)));
-        CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
-        CheckRes(trans->Write(&fName, sizeof(fName)));
-        CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
-        return 0;
+        return JackRequest::RequestType::kReserveClientName;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(fUUID) + sizeof(fName) + sizeof(fRefNum); }
-
-};
+typedef JackRequestTemplate<JackReserveNameRequestData> JackReserveNameRequest;
 
-struct JackClientHasSessionCallbackRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackClientHasSessionCallbackRequestData
 {
     char fName[JACK_CLIENT_NAME_SIZE+1];
 
-    JackClientHasSessionCallbackRequest(const char *name="")
-            : JackRequest(JackRequest::kClientHasSessionCallback)
+    JackClientHasSessionCallbackRequestData(const char *name="")
     {
         memset(fName, 0, sizeof(fName));
         strncpy(fName, name, sizeof(fName)-1);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckSize();
-        CheckRes(trans->Read(&fName, sizeof(fName)));
-        return 0;
+        return JackRequest::RequestType::kClientHasSessionCallback;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Write(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fName, sizeof(fName)));
-        return 0;
-    }
-
-    int Size() { return sizeof(fName); }
-
-};
+typedef JackRequestTemplate<JackClientHasSessionCallbackRequestData> JackClientHasSessionCallbackRequest;
 
 
-struct JackPropertyChangeNotifyRequest : public JackRequest
+PRE_PACKED_STRUCTURE_ALWAYS
+struct JackPropertyChangeNotifyRequestData
 {
     jack_uuid_t fSubject;
     char fKey[MAX_PATH+1];
     jack_property_change_t fChange;
 
-    JackPropertyChangeNotifyRequest() : fChange((jack_property_change_t)0)
-    {
-        jack_uuid_clear(&fSubject);
-        memset(fKey, 0, sizeof(fKey));
-    }
-    JackPropertyChangeNotifyRequest(jack_uuid_t subject, const char* key, jack_property_change_t change)
-        : JackRequest(JackRequest::kPropertyChangeNotify), fChange(change)
+    JackPropertyChangeNotifyRequestData(jack_uuid_t subject=0, const char* key="", jack_property_change_t change=(jack_property_change_t)0)
+        : fChange(change)
     {
         jack_uuid_copy(&fSubject, subject);
         memset(fKey, 0, sizeof(fKey));
@@ -1624,26 +1313,13 @@ struct JackPropertyChangeNotifyRequest : public JackRequest
             strncpy(fKey, key, sizeof(fKey)-1);
     }
 
-    int Read(detail::JackChannelTransactionInterface* trans)
+    static JackRequest::RequestType Type()
     {
-        CheckSize();
-        CheckRes(trans->Read(&fSubject, sizeof(fSubject)));
-        CheckRes(trans->Read(&fKey, sizeof(fKey)));
-        CheckRes(trans->Read(&fChange, sizeof(fChange)));
-        return 0;
-    }
-
-    int Write(detail::JackChannelTransactionInterface* trans)
-    {
-        CheckRes(JackRequest::Write(trans, Size()));
-        CheckRes(trans->Write(&fSubject, sizeof(fSubject)));
-        CheckRes(trans->Write(&fKey, sizeof(fKey)));
-        CheckRes(trans->Write(&fChange, sizeof(fChange)));
-        return 0;
+        return JackRequest::RequestType::kPropertyChangeNotify;
     }
+} POST_PACKED_STRUCTURE_ALWAYS;
 
-    int Size() { return sizeof(fSubject) + sizeof(fKey) + sizeof(fChange); }
-};
+typedef JackRequestTemplate<JackPropertyChangeNotifyRequestData> JackPropertyChangeNotifyRequest;
 
 /*!
 \brief ClientNotification.
diff --git a/common/JackRequestDecoder.cpp b/common/JackRequestDecoder.cpp
index 3c18f964..9911d977 100644
--- a/common/JackRequestDecoder.cpp
+++ b/common/JackRequestDecoder.cpp
@@ -31,8 +31,8 @@ namespace Jack
 {
 
 #define CheckRead(req, socket)          { if (req.Read(socket) <  0) { jack_error("CheckRead error"); return -1; } }
-#define CheckWriteName(error, socket)   { if (res.Write(socket) < 0) { jack_error("%s write error name = %s", error, req.fName); } }
-#define CheckWriteRefNum(error, socket) { if (res.Write(socket) < 0) { jack_error("%s write error ref = %d", error, req.fRefNum); } }
+#define CheckWriteName(error, socket)   { if (res.Write(socket) < 0) { jack_error("%s write error name = %s", error, req.d.fName); } }
+#define CheckWriteRefNum(error, socket) { if (res.Write(socket) < 0) { jack_error("%s write error ref = %d", error, req.d.fRefNum); } }
 #define CheckWrite(error, socket)       { if (res.Write(socket) < 0) { jack_error("%s write error", error); } }
 
 JackRequestDecoder::JackRequestDecoder(JackServer* server, JackClientHandlerInterface* handler)
@@ -54,10 +54,10 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackClientCheckRequest req;
             JackClientCheckResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->ClientCheck(req.fName, req.fUUID, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
+            res.fResult = fServer->GetEngine()->ClientCheck(req.d.fName, req.d.fUUID, res.fName, req.d.fProtocol, req.d.fOptions, &res.fStatus);
             CheckWriteName("JackRequest::ClientCheck", socket);
             // Atomic ClientCheck followed by ClientOpen on same socket
-            if (req.fOpen) {
+            if (req.d.fOpen) {
                 JackRequest::RequestType type;
                 JackRequest::ReadType(socket, type);
                 return HandleRequest(socket, type);
@@ -80,9 +80,9 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackClientCloseRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
+            res.fResult = fServer->GetEngine()->ClientExternalClose(req.d.fRefNum);
             CheckWriteRefNum("JackRequest::ClientClose", socket);
-            fHandler->ClientRemove(socket, req.fRefNum);
+            fHandler->ClientRemove(socket, req.d.fRefNum);
             // Will cause the wrapping thread to stop
             return -1;
         }
@@ -92,7 +92,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackResult res;
             jack_log("JackRequest::ActivateClient");
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum, req.fIsRealTime);
+            res.fResult = fServer->GetEngine()->ClientActivate(req.d.fRefNum, req.d.fIsRealTime);
             CheckWriteRefNum("JackRequest::ActivateClient", socket);
             break;
         }
@@ -102,7 +102,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackDeactivateRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
+            res.fResult = fServer->GetEngine()->ClientDeactivate(req.d.fRefNum);
             CheckWriteRefNum("JackRequest::DeactivateClient", socket);
             break;
         }
@@ -112,7 +112,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackPortRegisterRequest req;
             JackPortRegisterResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fPortType, req.fFlags, req.fBufferSize, &res.fPortIndex);
+            res.fResult = fServer->GetEngine()->PortRegister(req.d.fRefNum, req.d.fName, req.d.fPortType, req.d.fFlags, req.d.fBufferSize, &res.fPortIndex);
             CheckWriteRefNum("JackRequest::RegisterPort", socket);
             break;
         }
@@ -122,7 +122,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackPortUnRegisterRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);
+            res.fResult = fServer->GetEngine()->PortUnRegister(req.d.fRefNum, req.d.fPortIndex);
             CheckWriteRefNum("JackRequest::UnRegisterPort", socket);
             break;
         }
@@ -132,7 +132,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackPortConnectNameRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
+            res.fResult = fServer->GetEngine()->PortConnect(req.d.fRefNum, req.d.fSrc, req.d.fDst);
             CheckWriteRefNum("JackRequest::ConnectNamePorts", socket);
             break;
         }
@@ -142,7 +142,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackPortDisconnectNameRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
+            res.fResult = fServer->GetEngine()->PortDisconnect(req.d.fRefNum, req.d.fSrc, req.d.fDst);
             CheckWriteRefNum("JackRequest::DisconnectNamePorts", socket);
             break;
         }
@@ -152,7 +152,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackPortConnectRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
+            res.fResult = fServer->GetEngine()->PortConnect(req.d.fRefNum, req.d.fSrc, req.d.fDst);
             CheckWriteRefNum("JackRequest::ConnectPorts", socket);
             break;
         }
@@ -162,7 +162,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackPortDisconnectRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
+            res.fResult = fServer->GetEngine()->PortDisconnect(req.d.fRefNum, req.d.fSrc, req.d.fDst);
             CheckWriteRefNum("JackRequest::DisconnectPorts", socket);
             break;
         }
@@ -172,7 +172,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackPortRenameRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
+            res.fResult = fServer->GetEngine()->PortRename(req.d.fRefNum, req.d.fPort, req.d.fName);
             CheckWriteRefNum("JackRequest::PortRename", socket);
             break;
         }
@@ -182,7 +182,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackSetBufferSizeRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->SetBufferSize(req.fBufferSize);
+            res.fResult = fServer->SetBufferSize(req.d.fBufferSize);
             CheckWrite("JackRequest::SetBufferSize", socket);
             break;
         }
@@ -192,7 +192,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackSetFreeWheelRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->SetFreewheel(req.fOnOff);
+            res.fResult = fServer->SetFreewheel(req.d.fOnOff);
             CheckWrite("JackRequest::SetFreeWheel", socket);
             break;
         }
@@ -212,7 +212,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackReleaseTimebaseRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->ReleaseTimebase(req.fRefNum);
+            res.fResult = fServer->ReleaseTimebase(req.d.fRefNum);
             CheckWriteRefNum("JackRequest::ReleaseTimebase", socket);
             break;
         }
@@ -222,7 +222,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackSetTimebaseCallbackRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
+            res.fResult = fServer->SetTimebaseCallback(req.d.fRefNum, req.d.fConditionnal);
             CheckWriteRefNum("JackRequest::SetTimebaseCallback", socket);
             break;
         }
@@ -232,7 +232,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackGetInternalClientNameRequest req;
             JackGetInternalClientNameResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->GetInternalClientName(req.fIntRefNum, res.fName);
+            res.fResult = fServer->GetEngine()->GetInternalClientName(req.d.fIntRefNum, res.fName);
             CheckWriteRefNum("JackRequest::GetInternalClientName", socket);
             break;
         }
@@ -242,7 +242,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackInternalClientHandleRequest req;
             JackInternalClientHandleResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->InternalClientHandle(req.fName, &res.fStatus, &res.fIntRefNum);
+            res.fResult = fServer->GetEngine()->InternalClientHandle(req.d.fName, &res.fStatus, &res.fIntRefNum);
             CheckWriteRefNum("JackRequest::InternalClientHandle", socket);
             break;
         }
@@ -252,7 +252,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackInternalClientLoadRequest req;
             JackInternalClientLoadResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->InternalClientLoad1(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, req.fUUID, &res.fStatus);
+            res.fResult = fServer->InternalClientLoad1(req.d.fName, req.d.fDllName, req.d.fLoadInitName, req.d.fOptions, &res.fIntRefNum, req.d.fUUID, &res.fStatus);
             CheckWriteName("JackRequest::InternalClientLoad", socket);
             break;
         }
@@ -262,7 +262,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackInternalClientUnloadRequest req;
             JackInternalClientUnloadResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->InternalClientUnload(req.fIntRefNum, &res.fStatus);
+            res.fResult = fServer->GetEngine()->InternalClientUnload(req.d.fIntRefNum, &res.fStatus);
             CheckWriteRefNum("JackRequest::InternalClientUnload", socket);
             break;
         }
@@ -271,11 +271,11 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             jack_log("JackRequest::Notification");
             JackClientNotificationRequest req;
             CheckRead(req, socket);
-            if (req.fNotify == kQUIT) {
+            if (req.d.fNotify == kQUIT) {
                 jack_log("JackRequest::Notification kQUIT");
                 throw JackQuitException();
             } else {
-                fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
+                fServer->Notify(req.d.fRefNum, req.d.fNotify, req.d.fValue);
             }
             break;
         }
@@ -284,7 +284,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             jack_log("JackRequest::SessionNotify");
             JackSessionNotifyRequest req;
             CheckRead(req, socket);
-            fServer->GetEngine()->SessionNotify(req.fRefNum, req.fDst, req.fEventType, req.fPath, socket, NULL);
+            fServer->GetEngine()->SessionNotify(req.d.fRefNum, req.d.fDst, req.d.fEventType, req.d.fPath, socket, NULL);
             break;
         }
 
@@ -293,7 +293,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackSessionReplyRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->SessionReply(req.fRefNum);
+            res.fResult = fServer->GetEngine()->SessionReply(req.d.fRefNum);
             CheckWrite("JackRequest::SessionReply", socket);
             break;
         }
@@ -303,7 +303,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackGetClientNameRequest req;
             JackClientNameResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName);
+            res.fResult = fServer->GetEngine()->GetClientNameForUUID(req.d.fUUID, res.fName);
             CheckWrite("JackRequest::GetClientByUUID", socket);
             break;
         }
@@ -313,7 +313,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackGetUUIDRequest req;
             JackUUIDResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID);
+            res.fResult = fServer->GetEngine()->GetUUIDForClientName(req.d.fName, res.fUUID);
             CheckWrite("JackRequest::GetUUIDByClient", socket);
             break;
         }
@@ -323,7 +323,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackReserveNameRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID);
+            res.fResult = fServer->GetEngine()->ReserveClientName(req.d.fName, req.d.fUUID);
             CheckWrite("JackRequest::ReserveClientName", socket);
             break;
         }
@@ -333,7 +333,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             JackClientHasSessionCallbackRequest req;
             JackResult res;
             CheckRead(req, socket);
-            res.fResult = fServer->GetEngine()->ClientHasSessionCallback(req.fName);
+            res.fResult = fServer->GetEngine()->ClientHasSessionCallback(req.d.fName);
             CheckWrite("JackRequest::ClientHasSessionCallback", socket);
             break;
         }
@@ -342,7 +342,7 @@ int JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* s
             jack_log("JackRequest::PropertyChangeNotify");
             JackPropertyChangeNotifyRequest req;
             CheckRead(req, socket);
-            fServer->GetEngine()->PropertyChangeNotify(req.fSubject, req.fKey, req.fChange);
+            fServer->GetEngine()->PropertyChangeNotify(req.d.fSubject, req.d.fKey, req.d.fChange);
             break;
         }
 
diff --git a/common/JackRequestDecoder.h b/common/JackRequestDecoder.h
index f23caede..852ded0b 100644
--- a/common/JackRequestDecoder.h
+++ b/common/JackRequestDecoder.h
@@ -26,7 +26,9 @@ namespace Jack
 {
 
 class JackServer;
-struct JackClientOpenRequest;
+template<class DATA> struct JackRequestTemplate;
+struct JackClientOpenRequestData;
+typedef JackRequestTemplate<JackClientOpenRequestData> JackClientOpenRequest;
 struct JackClientOpenResult;
 
 struct JackClientHandlerInterface {
diff --git a/posix/JackSocketServerChannel.cpp b/posix/JackSocketServerChannel.cpp
index 8aeb27ba..4218f8a8 100644
--- a/posix/JackSocketServerChannel.cpp
+++ b/posix/JackSocketServerChannel.cpp
@@ -128,7 +128,7 @@ int JackSocketServerChannel::GetFd(JackClientSocket* socket_aux)
 void JackSocketServerChannel::ClientAdd(detail::JackChannelTransactionInterface* socket_aux, JackClientOpenRequest* req, JackClientOpenResult *res)
 {
     int refnum = -1;
-    res->fResult = fServer->GetEngine()->ClientExternalOpen(req->fName, req->fPID, req->fUUID, &refnum, &res->fSharedEngine, &res->fSharedClient, &res->fSharedGraph);
+    res->fResult = fServer->GetEngine()->ClientExternalOpen(req->d.fName, req->d.fPID, req->d.fUUID, &refnum, &res->fSharedEngine, &res->fSharedClient, &res->fSharedGraph);
     if (res->fResult == 0) {
         JackClientSocket* socket = dynamic_cast<JackClientSocket*>(socket_aux);
         assert(socket);