More robust server/client protocol.

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

ChangeLog

@@ -36,9 +36,13 @@ John Emmas
   Jackdmp changes log
 ---------------------------
 
+2012-01-13 Stephane Letz  <letz@grame.fr>
+
+	* More robust server/client protocol.
+
 2012-01-11 Stephane Letz  <letz@grame.fr>
 
-	* Factorize code the server/client request.
+	* Factorize code the server/client request in JackRequestDecoder class.
 
 2012-01-06 Stephane Letz  <letz@grame.fr>
 

common/JackEngine.cpp

@@ -157,7 +157,7 @@ bool JackEngine::Process(jack_time_t cur_cycle_begin, jack_time_t prev_cycle_end
 
     // Cycle  begin
     fEngineControl->CycleBegin(fClientTable, fGraphManager, cur_cycle_begin, prev_cycle_end);
-
+  
     // Graph
     if (fGraphManager->IsFinishedGraph()) {
         ProcessNext(cur_cycle_begin);
@@ -1000,7 +1000,7 @@ void JackEngine::SessionNotify(int refnum, const char *target, jack_session_even
     }
 }
 
-void JackEngine::SessionReply(int refnum)
+int JackEngine::SessionReply(int refnum)
 {
     JackClientInterface* client = fClientTable[refnum];
     char uuid_buf[JACK_UUID_SIZE];
@@ -1019,72 +1019,73 @@ void JackEngine::SessionReply(int refnum)
         }
         fSessionResult = NULL;
     }
+    
+    return 0;
 }
 
-void JackEngine::GetUUIDForClientName(const char *client_name, char *uuid_res, int *result)
+int JackEngine::GetUUIDForClientName(const char *client_name, char *uuid_res)
 {
     for (int i = 0; i < CLIENT_NUM; i++) {
         JackClientInterface* client = fClientTable[i];
 
         if (client && (strcmp(client_name, client->GetClientControl()->fName) == 0)) {
             snprintf(uuid_res, JACK_UUID_SIZE, "%d", client->GetClientControl()->fSessionID);
-            *result = 0;
-            return;
+            return 0;
         }
     }
     // Did not find name.
-    *result = -1;
+    return -1;
 }
 
-void JackEngine::GetClientNameForUUID(const char *uuid, char *name_res, int *result)
+int JackEngine::GetClientNameForUUID(const char *uuid, char *name_res)
 {
     for (int i = 0; i < CLIENT_NUM; i++) {
         JackClientInterface* client = fClientTable[i];
 
-        if (!client)
+        if (!client) {
             continue;
+        }
 
         char uuid_buf[JACK_UUID_SIZE];
         snprintf(uuid_buf, JACK_UUID_SIZE, "%d", client->GetClientControl()->fSessionID);
 
         if (strcmp(uuid,uuid_buf) == 0) {
             strncpy(name_res, client->GetClientControl()->fName, JACK_CLIENT_NAME_SIZE);
-            *result = 0;
-            return;
+            return 0;
         }
     }
     // Did not find uuid.
-    *result = -1;
+    return -1;
 }
 
-void JackEngine::ReserveClientName(const char *name, const char *uuid, int *result)
+int JackEngine::ReserveClientName(const char *name, const char *uuid)
 {
     jack_log("JackEngine::ReserveClientName ( name = %s, uuid = %s )", name, uuid);
 
     if (ClientCheckName(name)) {
-        *result = -1;
         jack_log("name already taken");
-        return;
+        return -1;
     }
 
     EnsureUUID(atoi(uuid));
     fReservationMap[atoi(uuid)] = name;
-    *result = 0;
+    return 0;
 }
 
-void JackEngine::ClientHasSessionCallback(const char *name, int *result)
+int JackEngine::ClientHasSessionCallback(const char *name)
 {
     JackClientInterface* client = NULL;
     for (int i = 0; i < CLIENT_NUM; i++) {
         client = fClientTable[i];
-        if (client && (strcmp(client->GetClientControl()->fName, name) == 0))
+        if (client && (strcmp(client->GetClientControl()->fName, name) == 0)) {
             break;
+        }
     }
 
     if (client) {
-        *result = client->GetClientControl()->fCallback[kSessionCallback];
+        return client->GetClientControl()->fCallback[kSessionCallback];
      } else {
-        *result = -1;
+        return -1;
     }
 }
 

common/JackEngine.h

@@ -148,12 +148,12 @@ class SERVER_EXPORT JackEngine : public JackLockAble
 
         // Session management
         void SessionNotify(int refnum, const char *target, jack_session_event_type_t type, const char *path, detail::JackChannelTransactionInterface *socket, JackSessionNotifyResult** result);
-        void SessionReply(int refnum);
+        int SessionReply(int refnum);
 
-        void GetUUIDForClientName(const char *client_name, char *uuid_res, int *result);
-        void GetClientNameForUUID(const char *uuid, char *name_res, int *result);
-        void ReserveClientName(const char *name, const char *uuid, int *result);
-        void ClientHasSessionCallback(const char *name, int *result);
+        int GetUUIDForClientName(const char *client_name, char *uuid_res);
+        int GetClientNameForUUID(const char *uuid, char *name_res);
+        int ReserveClientName(const char *name, const char *uuid);
+        int ClientHasSessionCallback(const char *name);
 };
 
 

common/JackInternalClientChannel.h

@@ -142,8 +142,7 @@ class JackInternalClientChannel : public detail::JackClientChannelInterface
         {
             JackSessionNotifyResult* res;
             fEngine->SessionNotify(refnum, target, type, path, NULL, &res);
-            if (res == NULL)
-            {
+            if (res == NULL) {
                 *result = NULL;
                 return;
             }
@@ -154,28 +153,27 @@ class JackInternalClientChannel : public detail::JackClientChannelInterface
 
         void SessionReply(int refnum, int* result)
         {
-            fEngine->SessionReply(refnum);
-            *result = 0;
+            *result = fEngine->SessionReply(refnum);
         }
 
         void GetUUIDForClientName(int refnum, const char* client_name, char* uuid_res, int* result)
         {
-            fEngine->GetUUIDForClientName(client_name, uuid_res, result);
+            *result = fEngine->GetUUIDForClientName(client_name, uuid_res);
         }
 
         void GetClientNameForUUID(int refnum, const char* uuid, char* name_res, int* result)
         {
-            fEngine->GetClientNameForUUID(uuid, name_res, result);
+            *result = fEngine->GetClientNameForUUID(uuid, name_res);
         }
 
         void ReserveClientName(int refnum, const char* client_name, const char *uuid, int* result)
         {
-            fEngine->ReserveClientName(client_name, uuid, result);
+            *result = fEngine->ReserveClientName(client_name, uuid);
         }
 
         void ClientHasSessionCallback(const char* client_name, int* result)
         {
-            fEngine->ClientHasSessionCallback(client_name, result);
+            *result = fEngine->ClientHasSessionCallback(client_name);
         }
 
 

common/JackLockedEngine.h

@@ -333,42 +333,42 @@ class SERVER_EXPORT JackLockedEngine
             CATCH_EXCEPTION
         }
 
-        void SessionReply(int refnum)
+        int SessionReply(int refnum)
         {
             TRY_CALL
             JackLock lock(&fEngine);
-            fEngine.SessionReply(refnum);
-            CATCH_EXCEPTION
+            return fEngine.SessionReply(refnum);
+            CATCH_EXCEPTION_RETURN
         }
 
-        void GetUUIDForClientName(const char *client_name, char *uuid_res, int *result)
+        int GetUUIDForClientName(const char *client_name, char *uuid_res)
         {
             TRY_CALL
             JackLock lock(&fEngine);
-            fEngine.GetUUIDForClientName(client_name, uuid_res, result);
-            CATCH_EXCEPTION
+            return fEngine.GetUUIDForClientName(client_name, uuid_res);
+            CATCH_EXCEPTION_RETURN
         }
-        void GetClientNameForUUID(const char *uuid, char *name_res, int *result)
+        int GetClientNameForUUID(const char *uuid, char *name_res)
         {
             TRY_CALL
             JackLock lock(&fEngine);
-            fEngine.GetClientNameForUUID(uuid, name_res, result);
-            CATCH_EXCEPTION
+            return fEngine.GetClientNameForUUID(uuid, name_res);
+            CATCH_EXCEPTION_RETURN
         }
-        void ReserveClientName(const char *name, const char *uuid, int *result)
+        int ReserveClientName(const char *name, const char *uuid)
         {
             TRY_CALL
             JackLock lock(&fEngine);
-            fEngine.ReserveClientName(name, uuid, result);
-            CATCH_EXCEPTION
+            return fEngine.ReserveClientName(name, uuid);
+            CATCH_EXCEPTION_RETURN
         }
 
-        void ClientHasSessionCallback(const char *name, int *result)
+        int ClientHasSessionCallback(const char *name)
         {
             TRY_CALL
             JackLock lock(&fEngine);
-            fEngine.ClientHasSessionCallback(name, result);
-            CATCH_EXCEPTION
+            return fEngine.ClientHasSessionCallback(name);
+            CATCH_EXCEPTION_RETURN
         }
 };
 

common/JackRequest.h

@@ -22,6 +22,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 #define __JackRequest__
 
 #include "JackConstants.h"
+#include "JackError.h"
 #include "JackPlatformPlug.h"
 #include "JackChannel.h"
 #include "JackTime.h"
@@ -34,7 +35,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 namespace Jack
 {
 
-#define CheckRes(exp) { if ((exp) < 0) return -1; }
+#define CheckRes(exp) { if ((exp) < 0) { jack_error("CheckRes error"); return -1; } }
+#define CheckSize() { CheckRes(trans->Read(&fSize, sizeof(int))); if (fSize != Size()) { jack_error("CheckSize error size = %d Size() = %d", fSize, Size()); return -1; } }
 
 /*!
 \brief Session API constants.
@@ -91,11 +93,12 @@ struct JackRequest
     };
 
     RequestType fType;
+    int fSize;
 
-    JackRequest(): fType((RequestType)0)
+    JackRequest(): fType((RequestType)0), fSize(0)
     {}
 
-    JackRequest(RequestType type): fType(type)
+    JackRequest(RequestType type): fType(type), fSize(0)
     {}
 
     virtual ~JackRequest()
@@ -106,10 +109,16 @@ struct JackRequest
         return trans->Read(&fType, sizeof(RequestType));
     }
 
-    virtual int Write(detail::JackChannelTransactionInterface* trans)
+    virtual int Write(detail::JackChannelTransactionInterface* trans) { return -1; }
+    
+    virtual int Write(detail::JackChannelTransactionInterface* trans, int size)
     {
-        return trans->Write(&fType, sizeof(RequestType));
+        fSize = size;
+        CheckRes(trans->Write(&fType, sizeof(RequestType)));
+        return trans->Write(&fSize, sizeof(int));
     }
+    
+    virtual int Size() { return 0; }
 
 };
 
@@ -164,6 +173,7 @@ struct JackClientCheckRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fName, sizeof(fName)));
         CheckRes(trans->Read(&fProtocol, sizeof(int)));
         CheckRes(trans->Read(&fOptions, sizeof(int)));
@@ -173,13 +183,15 @@ struct JackClientCheckRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        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(int)));
         return trans->Write(&fOpen, sizeof(int));
     }
+    
+    int Size() { return sizeof(fName) + 4 * sizeof(int); }
 
 };
 
@@ -241,6 +253,7 @@ struct JackClientOpenRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fPID, sizeof(int)));
         CheckRes(trans->Read(&fUUID, sizeof(int)));
         return trans->Read(&fName, sizeof(fName));
@@ -248,12 +261,14 @@ struct JackClientOpenRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fPID, sizeof(int)));
         CheckRes(trans->Write(&fUUID, sizeof(int)));
         return trans->Write(&fName, sizeof(fName));
     }
 
+    int Size() { return 2 * sizeof(int) + sizeof(fName); }
+    
 };
 
 /*!
@@ -310,15 +325,17 @@ struct JackClientCloseRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         return trans->Read(&fRefNum, sizeof(int));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         return trans->Write(&fRefNum, sizeof(int));
     }
 
+    int Size() { return sizeof(int); }
 };
 
 /*!
@@ -339,17 +356,19 @@ struct JackActivateRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         return trans->Read(&fIsRealTime, sizeof(int));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         return trans->Write(&fIsRealTime, sizeof(int));
     }
 
+    int Size() { return 2 * sizeof(int); }
 };
 
 /*!
@@ -368,15 +387,17 @@ struct JackDeactivateRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         return trans->Read(&fRefNum, sizeof(int));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         return trans->Write(&fRefNum, sizeof(int));
     }
 
+    int Size() { return sizeof(int); }
 };
 
 /*!
@@ -403,6 +424,7 @@ struct JackPortRegisterRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         CheckRes(trans->Read(&fName, sizeof(fName)));
         CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
@@ -413,7 +435,7 @@ struct JackPortRegisterRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         CheckRes(trans->Write(&fName, sizeof(fName)));
         CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
@@ -421,6 +443,8 @@ struct JackPortRegisterRequest : public JackRequest
         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
         return 0;
     }
+    
+    int Size() { return sizeof(int) + sizeof(fName) + sizeof(fPortType) + 2 * sizeof(unsigned int); }
 
 };
 
@@ -468,6 +492,7 @@ struct JackPortUnRegisterRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
         return 0;
@@ -475,12 +500,13 @@ struct JackPortUnRegisterRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
         return 0;
     }
 
+    int Size() { return sizeof(int) + sizeof(jack_port_id_t); }
 };
 
 /*!
@@ -505,21 +531,23 @@ struct JackPortConnectNameRequest : public JackRequest
 
     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)
     {
-        CheckRes(JackRequest::Write(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); }
 
 };
 
@@ -545,6 +573,7 @@ struct JackPortDisconnectNameRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
         CheckRes(trans->Read(&fDst, sizeof(fDst)));
@@ -553,13 +582,15 @@ struct JackPortDisconnectNameRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(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); }
+    
 };
 
 /*!
@@ -581,6 +612,7 @@ struct JackPortConnectRequest : public JackRequest
 
     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)));
@@ -589,13 +621,14 @@ struct JackPortConnectRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(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); }
 };
 
 /*!
@@ -617,6 +650,7 @@ struct JackPortDisconnectRequest : public JackRequest
 
     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)));
@@ -625,13 +659,14 @@ struct JackPortDisconnectRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(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); }
 };
 
 /*!
@@ -655,6 +690,7 @@ struct JackPortRenameRequest : public JackRequest
 
     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)));
@@ -663,13 +699,14 @@ struct JackPortRenameRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        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;
-
     }
+    
+    int Size() { return sizeof(int) + sizeof(jack_port_id_t) + sizeof(fName); }
 
 };
 
@@ -690,15 +727,17 @@ struct JackSetBufferSizeRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
     }
 
+    int Size() { return sizeof(jack_nframes_t); }
 };
 
 /*!
@@ -718,14 +757,17 @@ struct JackSetFreeWheelRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         return trans->Read(&fOnOff, sizeof(int));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         return trans->Write(&fOnOff, sizeof(int));
     }
+    
+    int Size() { return sizeof(int); }
 
 };
 
@@ -742,15 +784,17 @@ struct JackComputeTotalLatenciesRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         return 0;
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         return 0;
     }
 
+    int Size() { return 0; }
 };
 
 /*!
@@ -770,14 +814,17 @@ struct JackReleaseTimebaseRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         return trans->Read(&fRefNum, sizeof(int));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         return trans->Write(&fRefNum, sizeof(int));
     }
+    
+    int Size() { return sizeof(int); }
 
 };
 
@@ -799,17 +846,19 @@ struct JackSetTimebaseCallbackRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         return trans->Read(&fConditionnal, sizeof(int));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         return trans->Write(&fConditionnal, sizeof(int));
     }
 
+    int Size() { return sizeof(int) + sizeof(int); }
 };
 
 /*!
@@ -830,17 +879,19 @@ struct JackGetInternalClientNameRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         return trans->Read(&fIntRefNum, sizeof(int));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         return trans->Write(&fIntRefNum, sizeof(int));
     }
 
+    int Size() { return sizeof(int) + sizeof(int); }
 };
 
 /*!
@@ -874,6 +925,7 @@ struct JackGetInternalClientNameResult : public JackResult
         return 0;
     }
 
+    int Size() { return sizeof(fName); }
 };
 
 /*!
@@ -896,17 +948,19 @@ struct JackInternalClientHandleRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         return trans->Read(&fName, sizeof(fName));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         return trans->Write(&fName, sizeof(fName));
     }
 
+    int Size() { return sizeof(int) + sizeof(fName); }
 };
 
 /*!
@@ -941,6 +995,7 @@ struct JackInternalClientHandleResult : public JackResult
         return 0;
     }
 
+    int Size() { return sizeof(int) + sizeof(int); }
 };
 
 /*!
@@ -974,6 +1029,7 @@ 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)));
@@ -984,7 +1040,7 @@ struct JackInternalClientLoadRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         CheckRes(trans->Write(&fName, sizeof(fName)));
         CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
@@ -993,6 +1049,7 @@ struct JackInternalClientLoadRequest : public JackRequest
         return trans->Write(&fOptions, sizeof(int));
     }
 
+    int Size() { return sizeof(int) + sizeof(fName) + sizeof(fDllName) + sizeof(fLoadInitName) + 2 * sizeof(int); }
 };
 
 /*!
@@ -1027,6 +1084,7 @@ struct JackInternalClientLoadResult : public JackResult
         return 0;
     }
 
+    int Size() { return sizeof(int) + sizeof(int); }
 };
 
 /*!
@@ -1047,16 +1105,19 @@ struct JackInternalClientUnloadRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         return trans->Read(&fIntRefNum, sizeof(int));
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         return trans->Write(&fIntRefNum, sizeof(int));
     }
+    
+    int Size() { return sizeof(int) + sizeof(int); }
 };
 
 /*!
@@ -1088,6 +1149,7 @@ struct JackInternalClientUnloadResult : public JackResult
         return 0;
     }
 
+    int Size() { return sizeof(int); }
 };
 
 /*!
@@ -1109,6 +1171,7 @@ struct JackClientNotificationRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         CheckRes(trans->Read(&fNotify, sizeof(int)));
         CheckRes(trans->Read(&fValue, sizeof(int)));
@@ -1117,12 +1180,14 @@ struct JackClientNotificationRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        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;
     }
+    
+    int Size() { return 3 * sizeof(int); }
 
 };
 
@@ -1260,6 +1325,7 @@ 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)));
@@ -1269,7 +1335,7 @@ struct JackSessionNotifyRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
         CheckRes(trans->Write(&fPath, sizeof(fPath)));
         CheckRes(trans->Write(&fDst, sizeof(fDst)));
@@ -1277,6 +1343,7 @@ struct JackSessionNotifyRequest : public JackRequest
         return 0;
     }
 
+    int Size() { return sizeof(fRefNum) + sizeof(fPath) + sizeof(fDst) + sizeof(fEventType); }
 };
 
 struct JackSessionReplyRequest : public JackRequest
@@ -1292,17 +1359,20 @@ struct JackSessionReplyRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
+        CheckSize();
+        CheckRes(trans->Read(&fRefNum, sizeof(int)));
         return 0;
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
-        CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
+        CheckRes(JackRequest::Write(trans, Size()));
+        CheckRes(trans->Write(&fRefNum, sizeof(int)));
         return 0;
     }
 
+    int Size() { return sizeof(int); }
+    
 };
 
 struct JackClientNameResult : public JackResult
@@ -1330,7 +1400,7 @@ struct JackClientNameResult : public JackResult
         CheckRes(trans->Write(&fName, sizeof(fName)));
         return 0;
     }
-
+   
 };
 
 struct JackUUIDResult : public JackResult
@@ -1376,17 +1446,20 @@ struct JackGetUUIDRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fName, sizeof(fName)));
         return 0;
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fName, sizeof(fName)));
         return 0;
     }
 
+    int Size() { return sizeof(fName); }
+    
 };
 
 struct JackGetClientNameRequest : public JackRequest
@@ -1403,18 +1476,21 @@ struct JackGetClientNameRequest : public JackRequest
     }
 
     int Read(detail::JackChannelTransactionInterface* trans)
-    {
+    {   
+        CheckSize();
         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
         return 0;
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
         return 0;
     }
 
+    int Size() { return sizeof(fUUID); }
+    
 };
 
 struct JackReserveNameRequest : public JackRequest
@@ -1435,6 +1511,7 @@ struct JackReserveNameRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
         CheckRes(trans->Read(&fName, sizeof(fName)));
         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
@@ -1443,13 +1520,15 @@ struct JackReserveNameRequest : public JackRequest
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        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;
     }
 
+    int Size() { return sizeof(fUUID) + sizeof(fName) + sizeof(fRefNum); }
+    
 };
 
 struct JackClientHasSessionCallbackRequest : public JackRequest
@@ -1467,17 +1546,20 @@ struct JackClientHasSessionCallbackRequest : public JackRequest
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fName, sizeof(fName)));
         return 0;
     }
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
-        CheckRes(JackRequest::Write(trans));
+        CheckRes(JackRequest::Write(trans, Size()));
         CheckRes(trans->Write(&fName, sizeof(fName)));
         return 0;
     }
 
+    int Size() { return sizeof(fName); }
+    
 };
 
 /*!
@@ -1486,6 +1568,7 @@ struct JackClientHasSessionCallbackRequest : public JackRequest
 
 struct JackClientNotification
 {
+    int fSize; 
     char fName[JACK_CLIENT_NAME_SIZE + 1];
     int fRefNum;
     int fNotify;
@@ -1501,10 +1584,12 @@ struct JackClientNotification
     {
         snprintf(fName, sizeof(fName), "%s", name);
         snprintf(fMessage, sizeof(fMessage), "%s", message);
+        fSize = Size();
     }
 
     int Read(detail::JackChannelTransactionInterface* trans)
     {
+        CheckSize();
         CheckRes(trans->Read(&fName, sizeof(fName)));
         CheckRes(trans->Read(&fRefNum, sizeof(int)));
         CheckRes(trans->Read(&fNotify, sizeof(int)));
@@ -1517,6 +1602,7 @@ struct JackClientNotification
 
     int Write(detail::JackChannelTransactionInterface* trans)
     {
+        CheckRes(trans->Write(&fSize, sizeof(int)));
         CheckRes(trans->Write(&fName, sizeof(fName)));
         CheckRes(trans->Write(&fRefNum, sizeof(int)));
         CheckRes(trans->Write(&fNotify, sizeof(int)));
@@ -1526,6 +1612,8 @@ struct JackClientNotification
         CheckRes(trans->Write(&fMessage, sizeof(fMessage)));
         return 0;
     }
+    
+    int Size() { return sizeof(int) + sizeof(fName) + 5 * sizeof(int) + sizeof(fMessage); }
 
 };
 

common/JackRequestDecoder.cpp

@@ -30,6 +30,11 @@ using namespace std;
 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 CheckWrite(error, socket)       { if (res.Write(socket) < 0) { jack_error("%s write error", error); } }
+
 JackRequestDecoder::JackRequestDecoder(JackServer* server, JackClientHandlerInterface* handler)
     :fServer(server), fHandler(handler)
 {}
@@ -37,7 +42,7 @@ JackRequestDecoder::JackRequestDecoder(JackServer* server, JackClientHandlerInte
 JackRequestDecoder::~JackRequestDecoder()
 {}
 
-void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* socket, int type_aux)
+int  JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface* socket, int type_aux)
 {
     JackRequest::RequestType type = (JackRequest::RequestType)type_aux;
     
@@ -48,15 +53,14 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ClientCheck");
             JackClientCheckRequest req;
             JackClientCheckResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->ClientCheck(req.fName, req.fUUID, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ClientCheck write error name = %s", req.fName);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->ClientCheck(req.fName, req.fUUID, res.fName, req.fProtocol, req.fOptions, &res.fStatus);
+            CheckWriteName("JackRequest::ClientCheck", socket);
             // Atomic ClientCheck followed by ClientOpen on same socket
             if (req.fOpen) {
                 JackRequest header;
                 header.Read(socket);
-                HandleRequest(socket, header.fType);
+                return HandleRequest(socket, header.fType);
             }
             break;
         }
@@ -65,10 +69,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ClientOpen");
             JackClientOpenRequest req;
             JackClientOpenResult res;
-            if (req.Read(socket) == 0)
-                fHandler->ClientAdd(socket, &req, &res);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ClientOpen write error name = %s", req.fName);
+            CheckRead(req, socket);
+            fHandler->ClientAdd(socket, &req, &res);
+            CheckWriteName("JackRequest::ClientOpen", socket);
             break;
         }
 
@@ -76,10 +79,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ClientClose");
             JackClientCloseRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ClientClose write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->ClientExternalClose(req.fRefNum);
+            CheckWriteRefNum("JackRequest::ClientClose", socket);
             fHandler->ClientRemove(socket, req.fRefNum);
             break;
         }
@@ -88,10 +90,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             JackActivateRequest req;
             JackResult res;
             jack_log("JackRequest::ActivateClient");
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum, req.fIsRealTime);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ActivateClient write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->ClientActivate(req.fRefNum, req.fIsRealTime);
+            CheckWriteRefNum("JackRequest::ActivateClient", socket);
             break;
         }
 
@@ -99,10 +100,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::DeactivateClient");
             JackDeactivateRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::DeactivateClient write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->ClientDeactivate(req.fRefNum);
+            CheckWriteRefNum("JackRequest::DeactivateClient", socket);
             break;
         }
 
@@ -110,10 +110,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::RegisterPort");
             JackPortRegisterRequest req;
             JackPortRegisterResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fPortType, req.fFlags, req.fBufferSize, &res.fPortIndex);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::RegisterPort write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->PortRegister(req.fRefNum, req.fName, req.fPortType, req.fFlags, req.fBufferSize, &res.fPortIndex);
+            CheckWriteRefNum("JackRequest::RegisterPort", socket);
             break;
         }
 
@@ -121,10 +120,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::UnRegisterPort");
             JackPortUnRegisterRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::UnRegisterPort write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->PortUnRegister(req.fRefNum, req.fPortIndex);
+            CheckWriteRefNum("JackRequest::UnRegisterPort", socket);
             break;
         }
 
@@ -132,10 +130,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ConnectNamePorts");
             JackPortConnectNameRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ConnectNamePorts write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
+            CheckWriteRefNum("JackRequest::ConnectNamePorts", socket);
             break;
         }
 
@@ -143,10 +140,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::DisconnectNamePorts");
             JackPortDisconnectNameRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::DisconnectNamePorts write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
+            CheckWriteRefNum("JackRequest::DisconnectNamePorts", socket);
             break;
         }
 
@@ -154,10 +150,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ConnectPorts");
             JackPortConnectRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ConnectPorts write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->PortConnect(req.fRefNum, req.fSrc, req.fDst);
+            CheckWriteRefNum("JackRequest::ConnectPorts", socket);
             break;
         }
 
@@ -165,10 +160,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::DisconnectPorts");
             JackPortDisconnectRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::DisconnectPorts write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->PortDisconnect(req.fRefNum, req.fSrc, req.fDst);
+            CheckWriteRefNum("JackRequest::DisconnectPorts", socket);
             break;
         }
 
@@ -176,10 +170,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::PortRename");
             JackPortRenameRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::PortRename write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->PortRename(req.fRefNum, req.fPort, req.fName);
+            CheckWriteRefNum("JackRequest::PortRename", socket);
             break;
         }
 
@@ -187,10 +180,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::SetBufferSize");
             JackSetBufferSizeRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->SetBufferSize(req.fBufferSize);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::SetBufferSize write error");
+            CheckRead(req, socket);
+            res.fResult = fServer->SetBufferSize(req.fBufferSize);
+            CheckWrite("JackRequest::SetBufferSize", socket);
             break;
         }
 
@@ -198,10 +190,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::SetFreeWheel");
             JackSetFreeWheelRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->SetFreewheel(req.fOnOff);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::SetFreeWheel write error");
+            CheckRead(req, socket);
+            res.fResult = fServer->SetFreewheel(req.fOnOff);
+            CheckWrite("JackRequest::SetFreeWheel", socket);
             break;
         }
 
@@ -209,10 +200,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ComputeTotalLatencies");
             JackComputeTotalLatenciesRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->ComputeTotalLatencies();
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ComputeTotalLatencies write error");
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->ComputeTotalLatencies();
+            CheckWrite("JackRequest::ComputeTotalLatencies", socket);
             break;
         }
 
@@ -220,10 +210,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ReleaseTimebase");
             JackReleaseTimebaseRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->ReleaseTimebase(req.fRefNum);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ReleaseTimebase write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->ReleaseTimebase(req.fRefNum);
+            CheckWriteRefNum("JackRequest::ReleaseTimebase", socket);
             break;
         }
 
@@ -231,10 +220,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::SetTimebaseCallback");
             JackSetTimebaseCallbackRequest req;
             JackResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::SetTimebaseCallback write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->SetTimebaseCallback(req.fRefNum, req.fConditionnal);
+            CheckWriteRefNum("JackRequest::SetTimebaseCallback", socket);
             break;
         }
 
@@ -242,10 +230,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::GetInternalClientName");
             JackGetInternalClientNameRequest req;
             JackGetInternalClientNameResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->GetInternalClientName(req.fIntRefNum, res.fName);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::GetInternalClientName write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->GetInternalClientName(req.fIntRefNum, res.fName);
+            CheckWriteRefNum("JackRequest::GetInternalClientName", socket);
             break;
         }
 
@@ -253,10 +240,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::InternalClientHandle");
             JackInternalClientHandleRequest req;
             JackInternalClientHandleResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->InternalClientHandle(req.fName, &res.fStatus, &res.fIntRefNum);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::InternalClientHandle write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->InternalClientHandle(req.fName, &res.fStatus, &res.fIntRefNum);
+            CheckWriteRefNum("JackRequest::InternalClientHandle", socket);
             break;
         }
 
@@ -264,10 +250,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::InternalClientLoad");
             JackInternalClientLoadRequest req;
             JackInternalClientLoadResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->InternalClientLoad1(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, req.fUUID, &res.fStatus);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::InternalClientLoad write error name = %s", req.fName);
+            CheckRead(req, socket);
+            res.fResult = fServer->InternalClientLoad1(req.fName, req.fDllName, req.fLoadInitName, req.fOptions, &res.fIntRefNum, req.fUUID, &res.fStatus);
+            CheckWriteName("JackRequest::InternalClientLoad", socket);
             break;
         }
 
@@ -275,23 +260,21 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::InternalClientUnload");
             JackInternalClientUnloadRequest req;
             JackInternalClientUnloadResult res;
-            if (req.Read(socket) == 0)
-                res.fResult = fServer->GetEngine()->InternalClientUnload(req.fIntRefNum, &res.fStatus);
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::InternalClientUnload write error ref = %d", req.fRefNum);
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->InternalClientUnload(req.fIntRefNum, &res.fStatus);
+            CheckWriteRefNum("JackRequest::InternalClientUnload", socket);
             break;
         }
 
         case JackRequest::kNotification: {
             jack_log("JackRequest::Notification");
             JackClientNotificationRequest req;
-            if (req.Read(socket) == 0) {
-                if (req.fNotify == kQUIT) {
-                    jack_log("JackRequest::Notification kQUIT");
-                    throw JackQuitException();
-                } else {
-                    fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
-                }
+            CheckRead(req, socket);
+            if (req.fNotify == kQUIT) {
+                jack_log("JackRequest::Notification kQUIT");
+                throw JackQuitException();
+            } else {
+                fServer->Notify(req.fRefNum, req.fNotify, req.fValue);
             }
             break;
         }
@@ -299,9 +282,8 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
         case JackRequest::kSessionNotify: {
             jack_log("JackRequest::SessionNotify");
             JackSessionNotifyRequest req;
-            if (req.Read(socket) == 0) {
-                fServer->GetEngine()->SessionNotify(req.fRefNum, req.fDst, req.fEventType, req.fPath, socket, NULL);
-            }
+            CheckRead(req, socket);
+            fServer->GetEngine()->SessionNotify(req.fRefNum, req.fDst, req.fEventType, req.fPath, socket, NULL);
             break;
         }
 
@@ -309,12 +291,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::SessionReply");
             JackSessionReplyRequest req;
             JackResult res;
-            if (req.Read(socket) == 0) {
-                fServer->GetEngine()->SessionReply(req.fRefNum);
-                res.fResult = 0;
-            }
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::SessionReply write error");
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->SessionReply(req.fRefNum);
+            CheckWrite("JackRequest::SessionReply", socket);
             break;
         }
 
@@ -322,11 +301,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::GetClientByUUID");
             JackGetClientNameRequest req;
             JackClientNameResult res;
-            if (req.Read(socket) == 0) {
-                fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName, &res.fResult);
-            }
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::GetClientByUUID write error");
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->GetClientNameForUUID(req.fUUID, res.fName);
+            CheckWrite("JackRequest::GetClientByUUID", socket);
             break;
         }
 
@@ -334,11 +311,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::GetUUIDByClient");
             JackGetUUIDRequest req;
             JackUUIDResult res;
-            if (req.Read(socket) == 0) {
-                fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID, &res.fResult);
-            }
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::GetUUIDByClient write error");
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->GetUUIDForClientName(req.fName, res.fUUID);
+            CheckWrite("JackRequest::GetUUIDByClient", socket);
             break;
         }
 
@@ -346,11 +321,9 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ReserveClientName");
             JackReserveNameRequest req;
             JackResult res;
-            if (req.Read(socket) == 0) {
-                fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID, &res.fResult);
-            }
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ReserveClientName write error");
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->ReserveClientName(req.fName, req.fUUID);
+            CheckWrite("JackRequest::ReserveClientName", socket);
             break;
         }
 
@@ -358,18 +331,18 @@ void JackRequestDecoder::HandleRequest(detail::JackChannelTransactionInterface*
             jack_log("JackRequest::ClientHasSessionCallback");
             JackClientHasSessionCallbackRequest req;
             JackResult res;
-            if (req.Read(socket) == 0) {
-                fServer->GetEngine()->ClientHasSessionCallback(req.fName, &res.fResult);
-            }
-            if (res.Write(socket) < 0)
-                jack_error("JackRequest::ClientHasSessionCallback write error");
+            CheckRead(req, socket);
+            res.fResult = fServer->GetEngine()->ClientHasSessionCallback(req.fName);
+            CheckWrite("JackRequest::ClientHasSessionCallback", socket);
             break;
         }
 
         default:
             jack_error("Unknown request %ld", type);
-            break;
+            return -1;
     }
+    
+    return 0;
 }
 
 } // end of namespace

common/JackRequestDecoder.h

@@ -52,7 +52,7 @@ class JackRequestDecoder
         JackRequestDecoder(JackServer* server, JackClientHandlerInterface* handler);
         virtual ~JackRequestDecoder();
 
-        void HandleRequest(detail::JackChannelTransactionInterface* socket, int type);
+        int HandleRequest(detail::JackChannelTransactionInterface* socket, int type);
 };
 
 } // end of namespace

macosx/coreaudio/JackCoreAudioDriver.cpp

@@ -287,7 +287,7 @@ OSStatus JackCoreAudioDriver::Render(void* inRefCon,
     // Setup threaded based log function et get RT thread parameters once...
     if (set_threaded_log_function()) {
 
-        jack_log("set_threaded_log_function");
+        jack_log("JackCoreAudioDriver::Render : set_threaded_log_function");
         JackMachThread::GetParams(pthread_self(), &driver->fEngineControl->fPeriod, &driver->fEngineControl->fComputation, &driver->fEngineControl->fConstraint);
 
         if (driver->fComputationGrain > 0) {
@@ -302,8 +302,8 @@ OSStatus JackCoreAudioDriver::Render(void* inRefCon,
     driver->CycleTakeBeginTime();
 
     if (driver->Process() < 0) {
-        jack_error("Process error, stopping driver.");
-        driver->NotifyFailure(JackBackendError, "Process error, stopping driver.");    // Message length limited to JACK_MESSAGE_SIZE
+        jack_error("Process error, stopping driver");
+        driver->NotifyFailure(JackBackendError, "Process error, stopping driver");    // Message length limited to JACK_MESSAGE_SIZE
         driver->Stop();
         kill(JackTools::GetPID(), SIGINT);
         return kAudioHardwareUnsupportedOperationError;
@@ -359,7 +359,7 @@ OSStatus JackCoreAudioDriver::SRNotificationCallback(AudioDeviceID inDevice,
                 jack_error("Cannot get current sample rate");
                 printError(err);
             } else {
-                jack_log("SRNotificationCallback : checked sample rate = %f", tmp_sample_rate);
+                jack_log("JackCoreAudioDriver::SRNotificationCallback : checked sample rate = %f", tmp_sample_rate);
             }
             driver->fState = true;
             break;
@@ -389,7 +389,7 @@ OSStatus JackCoreAudioDriver::BSNotificationCallback(AudioDeviceID inDevice,
                 jack_error("Cannot get current buffer size");
                 printError(err);
             } else {
-                jack_log("BSNotificationCallback : checked buffer size = %d", tmp_buffer_size);
+                jack_log("JackCoreAudioDriver::BSNotificationCallback : checked buffer size = %d", tmp_buffer_size);
             }
             driver->fState = true;
             break;
@@ -469,7 +469,7 @@ OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,
 
         case kAudioDevicePropertyStreamConfiguration: {
             jack_error("Cannot handle kAudioDevicePropertyStreamConfiguration : server will quit...");
-            driver->NotifyFailure(JackBackendError, "Another application has changed the device configuration.");   // Message length limited to JACK_MESSAGE_SIZE
+            driver->NotifyFailure(JackBackendError, "Another application has changed the device configuration");   // Message length limited to JACK_MESSAGE_SIZE
             driver->CloseAUHAL();
             kill(JackTools::GetPID(), SIGINT);
             return kAudioHardwareUnsupportedOperationError;
@@ -492,7 +492,7 @@ OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,
                // Digidesign hardware, so "special" code : change the SR again here
                if (strncmp(device_name, digidesign_name, 10) == 0) {
 
-                    jack_log("Digidesign HW = %s", device_name);
+                    jack_log("JackCoreAudioDriver::DeviceNotificationCallback Digidesign HW = %s", device_name);
 
                     // Set sample rate again...
                     sample_rate = driver->fEngineControl->fSampleRate;
@@ -501,7 +501,7 @@ OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,
                         jack_error("Cannot set sample rate = %f", sample_rate);
                         printError(err);
                     } else {
-                        jack_log("Set sample rate = %f", sample_rate);
+                        jack_log("JackCoreAudioDriver::DeviceNotificationCallback : set sample rate = %f", sample_rate);
                     }
 
                     // Check new sample rate again...
@@ -511,12 +511,12 @@ OSStatus JackCoreAudioDriver::DeviceNotificationCallback(AudioDeviceID inDevice,
                         jack_error("Cannot get current sample rate");
                         printError(err);
                     } else {
-                        jack_log("Checked sample rate = %f", sample_rate);
+                        jack_log("JackCoreAudioDriver::DeviceNotificationCallback : checked sample rate = %f", sample_rate);
                     }
                     return noErr;
 
                 } else {
-                    driver->NotifyFailure(JackBackendError, "Another application has changed the sample rate.");    // Message length limited to JACK_MESSAGE_SIZE
+                    driver->NotifyFailure(JackBackendError, "Another application has changed the sample rate");    // Message length limited to JACK_MESSAGE_SIZE
                     driver->CloseAUHAL();
                     kill(JackTools::GetPID(), SIGINT);
                     return kAudioHardwareUnsupportedOperationError;
@@ -539,7 +539,7 @@ OSStatus JackCoreAudioDriver::GetDeviceIDFromUID(const char* UID, AudioDeviceID*
     } else {
         OSStatus res = AudioHardwareGetProperty(kAudioHardwarePropertyDeviceForUID, &size, &value);
         CFRelease(inIUD);
-        jack_log("GetDeviceIDFromUID %s %ld", UID, *id);
+        jack_log("JackCoreAudioDriver::GetDeviceIDFromUID %s %ld", UID, *id);
         return (*id == kAudioDeviceUnknown) ? kAudioHardwareBadDeviceError : res;
     }
 }
@@ -559,7 +559,7 @@ OSStatus JackCoreAudioDriver::GetDefaultDevice(AudioDeviceID* id)
         return res;
     }
 
-    jack_log("GetDefaultDevice: input = %ld output = %ld", inDefault, outDefault);
+    jack_log("JackCoreAudioDriver::GetDefaultDevice : input = %ld output = %ld", inDefault, outDefault);
 
     // Get the device only if default input and output are the same
     if (inDefault != outDefault) {
@@ -588,7 +588,7 @@ OSStatus JackCoreAudioDriver::GetDefaultInputDevice(AudioDeviceID* id)
         jack_error("Error: default input device is 0, please select a correct one !!");
         return -1;
     }
-    jack_log("GetDefaultInputDevice: input = %ld ", inDefault);
+    jack_log("JackCoreAudioDriver::GetDefaultInputDevice : input = %ld ", inDefault);
     *id = inDefault;
     return noErr;
 }
@@ -607,7 +607,7 @@ OSStatus JackCoreAudioDriver::GetDefaultOutputDevice(AudioDeviceID* id)
         jack_error("Error: default output device is 0, please select a correct one !!");
         return -1;
     }
-    jack_log("GetDefaultOutputDevice: output = %ld", outDefault);
+    jack_log("JackCoreAudioDriver::GetDefaultOutputDevice : output = %ld", outDefault);
     *id = outDefault;
     return noErr;
 }
@@ -741,11 +741,11 @@ OSStatus JackCoreAudioDriver::CreateAggregateDevice(AudioDeviceID captureDeviceI
     vector<AudioDeviceID> captureDeviceIDArray;
 
     if (err != noErr) {
-        jack_log("Input device does not have subdevices");
+        jack_log("JackCoreAudioDriver::CreateAggregateDevice : input device does not have subdevices");
         captureDeviceIDArray.push_back(captureDeviceID);
     } else {
         int num_devices = outSize / sizeof(AudioObjectID);
-        jack_log("Input device has %d subdevices", num_devices);
+        jack_log("JackCoreAudioDriver::CreateAggregateDevice :Input device has %d subdevices", num_devices);
         for (int i = 0; i < num_devices; i++) {
             captureDeviceIDArray.push_back(sub_device[i]);
         }
@@ -755,11 +755,11 @@ OSStatus JackCoreAudioDriver::CreateAggregateDevice(AudioDeviceID captureDeviceI
     vector<AudioDeviceID> playbackDeviceIDArray;
 
     if (err != noErr) {
-        jack_log("Output device does not have subdevices");
+        jack_log("JackCoreAudioDriver::CreateAggregateDevice : output device does not have subdevices");
         playbackDeviceIDArray.push_back(playbackDeviceID);
     } else {
         int num_devices = outSize / sizeof(AudioObjectID);
-        jack_log("Output device has %d subdevices", num_devices);
+        jack_log("JackCoreAudioDriver::CreateAggregateDevice : output device has %d subdevices", num_devices);
         for (int i = 0; i < num_devices; i++) {
             playbackDeviceIDArray.push_back(sub_device[i]);
         }
@@ -1107,7 +1107,7 @@ OSStatus JackCoreAudioDriver::CreateAggregateDeviceAux(vector<AudioDeviceID> cap
         CFRelease(playbackDeviceUID[i]);
     }
 
-    jack_log("New aggregate device %ld", *outAggregateDevice);
+    jack_log("JackCoreAudioDriver::CreateAggregateDeviceAux : new aggregate device %ld", *outAggregateDevice);
     return noErr;
 
 error:
@@ -1126,13 +1126,13 @@ int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,
 
     // Duplex
     if (strcmp(capture_driver_uid, "") != 0 && strcmp(playback_driver_uid, "") != 0) {
-        jack_log("JackCoreAudioDriver::Open duplex");
+        jack_log("JackCoreAudioDriver::SetupDevices : duplex");
 
         // Same device for capture and playback...
         if (strcmp(capture_driver_uid, playback_driver_uid) == 0)  {
 
             if (GetDeviceIDFromUID(playback_driver_uid, &fDeviceID) != noErr) {
-                jack_log("Will take default in/out");
+                jack_log("JackCoreAudioDriver::SetupDevices : will take default in/out");
                 if (GetDefaultDevice(&fDeviceID) != noErr) {
                     jack_error("Cannot open default device");
                     return -1;
@@ -1149,7 +1149,7 @@ int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,
             AudioDeviceID captureID, playbackID;
 
             if (GetDeviceIDFromUID(capture_driver_uid, &captureID) != noErr) {
-                jack_log("Will take default input");
+                jack_log("JackCoreAudioDriver::SetupDevices : will take default input");
                 if (GetDefaultInputDevice(&captureID) != noErr) {
                     jack_error("Cannot open default input device");
                     return -1;
@@ -1157,7 +1157,7 @@ int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,
             }
 
             if (GetDeviceIDFromUID(playback_driver_uid, &playbackID) != noErr) {
-                jack_log("Will take default output");
+                jack_log("JackCoreAudioDriver::SetupDevices : will take default output");
                 if (GetDefaultOutputDevice(&playbackID) != noErr) {
                     jack_error("Cannot open default output device");
                     return -1;
@@ -1174,9 +1174,9 @@ int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,
 
     // Capture only
     } else if (strcmp(capture_driver_uid, "") != 0) {
-        jack_log("JackCoreAudioDriver::Open capture only");
+        jack_log("JackCoreAudioDriver::SetupDevices : capture only");
         if (GetDeviceIDFromUID(capture_driver_uid, &fDeviceID) != noErr) {
-            jack_log("Will take default input");
+            jack_log("JackCoreAudioDriver::SetupDevices : will take default input");
             if (GetDefaultInputDevice(&fDeviceID) != noErr) {
                 jack_error("Cannot open default input device");
                 return -1;
@@ -1189,9 +1189,9 @@ int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,
 
     // Playback only
     } else if (strcmp(playback_driver_uid, "") != 0) {
-        jack_log("JackCoreAudioDriver::Open playback only");
+        jack_log("JackCoreAudioDriver::SetupDevices : playback only");
         if (GetDeviceIDFromUID(playback_driver_uid, &fDeviceID) != noErr) {
-            jack_log("Will take default output");
+            jack_log("JackCoreAudioDriver::SetupDevices : will take default output");
             if (GetDefaultOutputDevice(&fDeviceID) != noErr) {
                 jack_error("Cannot open default output device");
                 return -1;
@@ -1204,7 +1204,7 @@ int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,
 
     // Use default driver in duplex mode
     } else {
-        jack_log("JackCoreAudioDriver::Open default driver");
+        jack_log("JackCoreAudioDriver::SetupDevices : default driver");
         if (GetDefaultDevice(&fDeviceID) != noErr) {
             jack_error("Cannot open default device in duplex mode, so aggregate default input and default output");
 
@@ -1212,7 +1212,7 @@ int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,
             AudioDeviceID captureID, playbackID;
 
             if (GetDeviceIDFromUID(capture_driver_uid, &captureID) != noErr) {
-                jack_log("Will take default input");
+                jack_log("JackCoreAudioDriver::SetupDevices : will take default input");
                 if (GetDefaultInputDevice(&captureID) != noErr) {
                     jack_error("Cannot open default input device");
                     return -1;
@@ -1220,7 +1220,7 @@ int JackCoreAudioDriver::SetupDevices(const char* capture_driver_uid,
             }
 
             if (GetDeviceIDFromUID(playback_driver_uid, &playbackID) != noErr) {
-                jack_log("Will take default output");
+                jack_log("JackCoreAudioDriver::SetupDevices : will take default output");
                 if (GetDefaultOutputDevice(&playbackID) != noErr) {
                     jack_error("Cannot open default output device");
                     return -1;
@@ -1255,11 +1255,11 @@ int JackCoreAudioDriver::SetupChannels(bool capturing, bool playing, int& inchan
     if (capturing) {
         err = GetTotalChannels(fDeviceID, in_nChannels, true);
         if (err != noErr) {
-            jack_error("Cannot get input channel number");
+            jack_error("JackCoreAudioDriver::SetupChannels : cannot get input channel number");
             printError(err);
             return -1;
         } else {
-            jack_log("Max input channels : %d", in_nChannels);
+            jack_log("JackCoreAudioDriver::SetupChannels : max input channels : %d", in_nChannels);
         }
     }
 
@@ -1270,7 +1270,7 @@ int JackCoreAudioDriver::SetupChannels(bool capturing, bool playing, int& inchan
             printError(err);
             return -1;
         } else {
-            jack_log("Max output channels : %d", out_nChannels);
+            jack_log("JackCoreAudioDriver::SetupChannels : max output channels : %d", out_nChannels);
         }
     }
 
@@ -1289,12 +1289,12 @@ int JackCoreAudioDriver::SetupChannels(bool capturing, bool playing, int& inchan
     }
 
     if (inchannels == -1) {
-        jack_log("Setup max in channels = %d", in_nChannels);
+        jack_log("JackCoreAudioDriver::SetupChannels : setup max in channels = %d", in_nChannels);
         inchannels = in_nChannels;
     }
 
     if (outchannels == -1) {
-        jack_log("Setup max out channels = %d", out_nChannels);
+        jack_log("JackCoreAudioDriver::SetupChannels : setup max out channels = %d", out_nChannels);
         outchannels = out_nChannels;
     }
 
@@ -1314,7 +1314,7 @@ int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)
         printError(err);
         return -1;
     } else {
-        jack_log("Current buffer size = %ld", tmp_buffer_size);
+        jack_log("JackCoreAudioDriver::SetupBufferSize : current buffer size = %ld", tmp_buffer_size);
     }
 
     // If needed, set new buffer size
@@ -1335,14 +1335,14 @@ int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)
 
         err = AudioDeviceSetProperty(fDeviceID, NULL, 0, kAudioDeviceSectionGlobal, kAudioDevicePropertyBufferFrameSize, outSize, &tmp_buffer_size);
         if (err != noErr) {
-            jack_error("Cannot set buffer size = %ld", tmp_buffer_size);
+            jack_error("JackCoreAudioDriver::SetupBufferSize : cannot set buffer size = %ld", tmp_buffer_size);
             printError(err);
             goto error;
         }
 
         while (!fState && count++ < WAIT_NOTIFICATION_COUNTER) {
             usleep(100000);
-            jack_log("Wait count = %d", count);
+            jack_log("JackCoreAudioDriver::SetupBufferSize : wait count = %d", count);
         }
 
         if (count >= WAIT_NOTIFICATION_COUNTER) {
@@ -1357,7 +1357,7 @@ int JackCoreAudioDriver::SetupBufferSize(jack_nframes_t buffer_size)
             jack_error("Cannot get current buffer size");
             printError(err);
         } else {
-            jack_log("Checked buffer size = %ld", tmp_buffer_size);
+            jack_log("JackCoreAudioDriver::SetupBufferSize : checked buffer size = %ld", tmp_buffer_size);
         }
 
         // Remove BS change notification
@@ -1393,7 +1393,7 @@ int JackCoreAudioDriver::SetupSampleRateAux(AudioDeviceID inDevice, jack_nframes
         printError(err);
         return -1;
     } else {
-        jack_log("Current sample rate = %f", tmp_sample_rate);
+        jack_log("JackCoreAudioDriver::SetupSampleRateAux : current sample rate = %f", tmp_sample_rate);
     }
 
     // If needed, set new sample rate
@@ -1421,7 +1421,7 @@ int JackCoreAudioDriver::SetupSampleRateAux(AudioDeviceID inDevice, jack_nframes
 
         while (!fState && count++ < WAIT_NOTIFICATION_COUNTER) {
             usleep(100000);
-            jack_log("Wait count = %d", count);
+            jack_log("JackCoreAudioDriver::SetupSampleRateAux : wait count = %d", count);
         }
 
         if (count >= WAIT_NOTIFICATION_COUNTER) {
@@ -1436,7 +1436,7 @@ int JackCoreAudioDriver::SetupSampleRateAux(AudioDeviceID inDevice, jack_nframes
             jack_error("Cannot get current sample rate");
             printError(err);
         } else {
-            jack_log("Checked sample rate = %f", tmp_sample_rate);
+            jack_log("JackCoreAudioDriver::SetupSampleRateAux : checked sample rate = %f", tmp_sample_rate);
         }
 
         // Remove SR change notification
@@ -1469,7 +1469,7 @@ int JackCoreAudioDriver::OpenAUHAL(bool capturing,
     AudioDeviceID currAudioDeviceID;
     UInt32 size;
 
-    jack_log("OpenAUHAL capturing = %d playing = %d inchannels = %d outchannels = %d in_nChannels = %d out_nChannels = %d chan_in_list = %d chan_out_list = %d",
+    jack_log("JackCoreAudioDriver::OpenAUHAL : capturing = %d playing = %d inchannels = %d outchannels = %d in_nChannels = %d out_nChannels = %d chan_in_list = %d chan_out_list = %d",
         capturing, playing, inchannels, outchannels, in_nChannels, out_nChannels, chan_in_list.size(), chan_out_list.size());
 
     if (inchannels == 0 && outchannels == 0) {
@@ -1498,10 +1498,10 @@ int JackCoreAudioDriver::OpenAUHAL(bool capturing,
     // Start I/O
     if (capturing && inchannels > 0) {
         enableIO = 1;
-        jack_log("Setup AUHAL input on");
+        jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL input on");
     } else {
         enableIO = 0;
-        jack_log("Setup AUHAL input off");
+        jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL input off");
     }
 
     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &enableIO, sizeof(enableIO));
@@ -1513,10 +1513,10 @@ int JackCoreAudioDriver::OpenAUHAL(bool capturing,
 
     if (playing && outchannels > 0) {
         enableIO = 1;
-        jack_log("Setup AUHAL output on");
+        jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL output on");
     } else {
         enableIO = 0;
-        jack_log("Setup AUHAL output off");
+        jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL output off");
     }
 
     err1 = AudioUnitSetProperty(fAUHAL, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output, 0, &enableIO, sizeof(enableIO));
@@ -1533,7 +1533,7 @@ int JackCoreAudioDriver::OpenAUHAL(bool capturing,
         printError(err1);
         goto error;
     } else {
-        jack_log("AudioUnitGetPropertyCurrentDevice = %d", currAudioDeviceID);
+        jack_log("JackCoreAudioDriver::OpenAUHAL : AudioUnitGetPropertyCurrentDevice = %d", currAudioDeviceID);
     }
 
     // Setup up choosen device, in both input and output cases
@@ -1643,7 +1643,7 @@ int JackCoreAudioDriver::OpenAUHAL(bool capturing,
         }
         PrintStreamDesc(&srcFormat);
 
-        jack_log("Setup AUHAL input stream converter SR = %ld", sample_rate);
+        jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL input stream converter SR = %ld", sample_rate);
         srcFormat.mSampleRate = sample_rate;
         srcFormat.mFormatID = kAudioFormatLinearPCM;
         srcFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
@@ -1673,7 +1673,7 @@ int JackCoreAudioDriver::OpenAUHAL(bool capturing,
         }
         PrintStreamDesc(&dstFormat);
 
-        jack_log("Setup AUHAL output stream converter SR = %ld", sample_rate);
+        jack_log("JackCoreAudioDriver::OpenAUHAL : setup AUHAL output stream converter SR = %ld", sample_rate);
         dstFormat.mSampleRate = sample_rate;
         dstFormat.mFormatID = kAudioFormatLinearPCM;
         dstFormat.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kLinearPCMFormatFlagIsNonInterleaved;
@@ -2043,18 +2043,18 @@ int JackCoreAudioDriver::Attach()
     char name[REAL_JACK_PORT_NAME_SIZE];
     char alias[REAL_JACK_PORT_NAME_SIZE];
 
-    jack_log("JackCoreAudioDriver::Attach fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
+    jack_log("JackCoreAudioDriver::Attach : fBufferSize %ld fSampleRate %ld", fEngineControl->fBufferSize, fEngineControl->fSampleRate);
 
     for (int i = 0; i < fCaptureChannels; i++) {
 
         err = AudioDeviceGetPropertyInfo(fDeviceID, i + 1, true, kAudioDevicePropertyChannelName, &size, &isWritable);
         if (err != noErr) {
-            jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");
+            jack_log("JackCoreAudioDriver::Attach : AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");
         }
         if (err == noErr && size > 0) {
             err = AudioDeviceGetProperty(fDeviceID, i + 1, true, kAudioDevicePropertyChannelName, &size, channel_name);
             if (err != noErr) {
-                jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error");
+                jack_log("JackCoreAudioDriver::Attach : AudioDeviceGetProperty kAudioDevicePropertyChannelName error");
             }
             snprintf(alias, sizeof(alias), "%s:%s:out_%s%u", fAliasName, fCaptureDriverName, channel_name, i + 1);
         } else {
@@ -2077,12 +2077,12 @@ int JackCoreAudioDriver::Attach()
 
         err = AudioDeviceGetPropertyInfo(fDeviceID, i + 1, false, kAudioDevicePropertyChannelName, &size, &isWritable);
         if (err != noErr) {
-            jack_log("AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");
+            jack_log("JackCoreAudioDriver::Attach : AudioDeviceGetPropertyInfo kAudioDevicePropertyChannelName error");
         }
         if (err == noErr && size > 0) {
             err = AudioDeviceGetProperty(fDeviceID, i + 1, false, kAudioDevicePropertyChannelName, &size, channel_name);
             if (err != noErr) {
-                jack_log("AudioDeviceGetProperty kAudioDevicePropertyChannelName error");
+                jack_log("JackCoreAudioDriver::Attach : AudioDeviceGetProperty kAudioDevicePropertyChannelName error");
             }
             snprintf(alias, sizeof(alias), "%s:%s:in_%s%u", fAliasName, fPlaybackDriverName, channel_name, i + 1);
         } else {
@@ -2102,7 +2102,7 @@ int JackCoreAudioDriver::Attach()
 
         // Monitor ports
         if (fWithMonitorPorts) {
-            jack_log("Create monitor port");
+            jack_log("JackCoreAudioDriver::Attach : create monitor port");
             snprintf(name, sizeof(name), "%s:monitor_%u", fClientControl.fName, i + 1);
             if (fEngine->PortRegister(fClientControl.fRefNum, name, JACK_DEFAULT_AUDIO_TYPE, MonitorDriverFlags, fEngineControl->fBufferSize, &port_index) < 0) {
                 jack_error("Cannot register monitor port for %s", name);
@@ -2137,7 +2137,7 @@ int JackCoreAudioDriver::Start()
 
             while (!fState && count++ < WAIT_COUNTER) {
                 usleep(100000);
-                jack_log("JackCoreAudioDriver::Start wait count = %d", count);
+                jack_log("JackCoreAudioDriver::Start : wait count = %d", count);
             }
 
             if (count < WAIT_COUNTER) {
@@ -2215,11 +2215,11 @@ bool JackCoreAudioDriver::TakeHog()
     err = AudioDeviceGetProperty(fDeviceID, 0, kAudioDeviceSectionGlobal, kAudioAggregateDevicePropertyActiveSubDeviceList, &outSize, sub_device);
 
     if (err != noErr) {
-        jack_log("Device does not have subdevices");
+        jack_log("JackCoreAudioDriver::TakeHog : device does not have subdevices");
         return TakeHogAux(fDeviceID, true);
     } else {
         int num_devices = outSize / sizeof(AudioObjectID);
-        jack_log("Device does has %d subdevices", num_devices);
+        jack_log("JackCoreAudioDriver::TakeHog : device does has %d subdevices", num_devices);
         for (int i = 0; i < num_devices; i++) {
             if (!TakeHogAux(sub_device[i], true)) {
                 return false;

posix/JackPosixThread.cpp

@@ -42,7 +42,7 @@ void* JackPosixThread::ThreadHandler(void* arg)
     }
 
     // Signal creation thread when started with StartSync
-    jack_log("ThreadHandler: start");
+    jack_log("JackPosixThread::ThreadHandler : start");
     obj->fStatus = kIniting;
 
     // Call Init method
@@ -59,7 +59,7 @@ void* JackPosixThread::ThreadHandler(void* arg)
         res = runnable->Execute();
     }
 
-    jack_log("ThreadHandler: exit");
+    jack_log("JackPosixThread::ThreadHandler : exit");
     pthread_exit(0);
     return 0; // never reached
 }
@@ -112,7 +112,7 @@ int JackPosixThread::StartImp(jack_native_thread_t* thread, int priority, int re
 
     if (realtime) {
 
-        jack_log("Create RT thread");
+        jack_log("JackPosixThread::StartImp : create RT thread");
 
         if ((res = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED))) {
             jack_error("Cannot request explicit scheduling for RT thread res = %d", res);
@@ -133,7 +133,7 @@ int JackPosixThread::StartImp(jack_native_thread_t* thread, int priority, int re
         }
 
     } else {
-        jack_log("Create non RT thread");
+        jack_log("JackPosixThread::StartImp : create non RT thread");
     }
 
     if ((res = pthread_attr_setstacksize(&attributes, THREAD_STACK))) {

posix/JackSocketServerChannel.cpp

@@ -141,7 +141,7 @@ void JackSocketServerChannel::ClientAdd(detail::JackChannelTransactionInterface*
     #ifdef __APPLE__
         int on = 1;
         if (setsockopt(fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&on, sizeof(on)) < 0) {
-            jack_log("setsockopt SO_NOSIGPIPE fd = %ld err = %s", fd, strerror(errno));
+            jack_log("JackSocketServerChannel::ClientAdd :  setsockopt SO_NOSIGPIPE fd = %ld err = %s", fd, strerror(errno));
         }
     #endif
     } else {
@@ -202,7 +202,7 @@ void JackSocketServerChannel::BuildPoolTable()
         int i;
 
         for (i = 1, it = fSocketTable.begin(); it != fSocketTable.end(); it++, i++) {
-            jack_log("fSocketTable i = %ld fd = %ld", i, it->first);
+            jack_log("JackSocketServerChannel::BuildPoolTable fSocketTable i = %ld fd = %ld", i, it->first);
             fPollTable[i].fd = it->first;
             fPollTable[i].events = POLLIN | POLLPRI | POLLERR | POLLHUP | POLLNVAL;
         }
@@ -224,44 +224,46 @@ bool JackSocketServerChannel::Execute()
 
         // Global poll
         if ((poll(fPollTable, fSocketTable.size() + 1, 10000) < 0) && (errno != EINTR)) {
-            jack_error("Engine poll failed err = %s request thread quits...", strerror(errno));
+            jack_error("JackSocketServerChannel::Execute : engine poll failed err = %s request thread quits...", strerror(errno));
             return false;
         } else {
 
             // Poll all clients
             for (unsigned int i = 1; i < fSocketTable.size() + 1; i++) {
                 int fd = fPollTable[i].fd;
-                jack_log("fPollTable i = %ld fd = %ld", i, fd);
+                jack_log("JackSocketServerChannel::Execute : fPollTable i = %ld fd = %ld", i, fd);
                 if (fPollTable[i].revents & ~POLLIN) {
-                    jack_log("Poll client error err = %s", strerror(errno));
+                    jack_log("JackSocketServerChannel::Execute : poll client error err = %s", strerror(errno));
                     ClientKill(fd);
                 } else if (fPollTable[i].revents & POLLIN) {
-                    // Read header
                     JackClientSocket* socket = fSocketTable[fd].second;
+                    // Decode header
                     JackRequest header;
                     if (header.Read(socket) < 0) {
-                        jack_log("HandleRequest: cannot read header");
+                        jack_log("JackSocketServerChannel::Execute : cannot decode header");
                         ClientKill(fd);
-                        return false;
-                    } else {
-                        fDecoder->HandleRequest(socket, header.fType);
+                    // Decode request
+                    } else if (fDecoder->HandleRequest(socket, header.fType) < 0) {
+                        jack_log("JackSocketServerChannel::Execute : cannot decode request");
                     }
                 }
             }
 
             // Check the server request socket */
-            if (fPollTable[0].revents & POLLERR)
+            if (fPollTable[0].revents & POLLERR) {
                 jack_error("Error on server request socket err = %s", strerror(errno));
+            }
 
-            if (fPollTable[0].revents & POLLIN)
+            if (fPollTable[0].revents & POLLIN) {
                 ClientCreate();
+            }
         }
 
         BuildPoolTable();
         return true;
 
     } catch (JackQuitException& e) {
-        jack_log("JackSocketServerChannel::Execute JackQuitException");
+        jack_log("JackSocketServerChannel::Execute : JackQuitException");
         return false;
     }
 }

windows/JackWinNamedPipeServerChannel.cpp

@@ -85,34 +85,36 @@ void JackClientPipeThread::Close()                                      // Close
 
 bool JackClientPipeThread::Execute()
 {
-    try{
+    try {
+    
         jack_log("JackClientPipeThread::Execute");
-
         JackRequest header;
         int res = header.Read(fPipe);
         bool ret = true;
 
         // Lock the global mutex
         if (WaitForSingleObject(fMutex, INFINITE) == WAIT_FAILED) {
-            jack_error("JackClientPipeThread::HandleRequest: mutex wait error");
+            jack_error("JackClientPipeThread::Execute : mutex wait error");
         }
 
+        // Decode header
         if (res < 0) {
-            jack_log("HandleRequest: cannot read header");
+            jack_log("JackClientPipeThread::Execute : cannot decode header");
             ClientKill();
             ret = false;
+        // Decode request
+        } else if {fDecoder->HandleRequest(fPipe, header.fType) < 0) {
+            jack_log("JackClientPipeThread::Execute : cannot decode request");
         }
 
-        fDecoder->HandleRequest(fPipe, header.fType);
-
         // Unlock the global mutex
         if (!ReleaseMutex(fMutex)) {
-            jack_error("JackClientPipeThread::HandleRequest: mutex release error");
+            jack_error("JackClientPipeThread::Execute : mutex release error");
         }
         return ret;
 
     } catch (JackQuitException& e) {
-        jack_log("JackClientPipeThread::Execute JackQuitException");
+        jack_log("JackClientPipeThread::Execute : JackQuitException");
         return false;
     }
 }

windows/JackWinThread.cpp

@@ -32,7 +32,7 @@ DWORD WINAPI JackWinThread::ThreadHandler(void* arg)
     JackRunnableInterface* runnable = obj->fRunnable;
 
     // Signal creation thread when started with StartSync
-    jack_log("ThreadHandler: start");
+    jack_log("JackWinThread::ThreadHandler : start");
     obj->fStatus = kIniting;
 
     // Call Init method
@@ -50,7 +50,7 @@ DWORD WINAPI JackWinThread::ThreadHandler(void* arg)
     }
 
     SetEvent(obj->fEvent);
-    jack_log("ThreadHandler: exit");
+    jack_log("JackWinThread::ThreadHandler : exit");
     return 0;
 }
 
@@ -109,14 +109,14 @@ int JackWinThread::StartImp(jack_native_thread_t* thread, int priority, int real
 
     if (realtime) {
 
-        jack_log("Create RT thread");
+        jack_log("JackWinThread::StartImp : create RT thread");
         if (!SetThreadPriority(*thread, THREAD_PRIORITY_TIME_CRITICAL)) {
             jack_error("Cannot set priority class = %d", GetLastError());
             return -1;
         }
 
     } else {
-        jack_log("Create non RT thread");
+        jack_log("JackWinThread::StartImp : create non RT thread");
     }
 
     return 0;