Changeset 89962 in vbox

Timestamp:

Jun 30, 2021 7:02:07 AM (4 years ago)

Author:

vboxsync

Message:

Audio/ValKit: Initial implementation / support for NATed VMs by using reversed (server) connections. The ATS client now also makes use of the transport layer and now can also be configured more flexible on a per-transport layer basis. bugref:10008

Location:

trunk/src/VBox

Files:

• Devices/Audio/AudioTestService.cpp (modified) (69 diffs)
• Devices/Audio/AudioTestService.h (modified) (3 diffs)
• Devices/Audio/AudioTestServiceClient.cpp (modified) (17 diffs)
• Devices/Audio/AudioTestServiceClient.h (modified) (1 diff)
• Devices/Audio/AudioTestServiceInternal.h (modified) (1 diff)
• Devices/Audio/AudioTestServiceTcp.cpp (modified) (20 diffs)
• Devices/Audio/DrvHostAudioValidationKit.cpp (modified) (1 diff)
• Devices/Audio/testcase/tstAudioTestService.cpp (modified) (1 diff)
• ValidationKit/utils/audio/vkat.cpp (modified) (8 diffs)
• ValidationKit/utils/audio/vkatCmdGeneric.cpp (modified) (3 diffs)
• ValidationKit/utils/audio/vkatCmdSelfTest.cpp (modified) (3 diffs)
• ValidationKit/utils/audio/vkatCommon.cpp (modified) (6 diffs)
• ValidationKit/utils/audio/vkatInternal.h (modified) (6 diffs)

trunk/src/VBox/Devices/Audio/AudioTestService.cpp

@@ -20 +20 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
-#define LOG_GROUP RTLOGGROUP_DEFAULT
+#define LOG_GROUP LOG_GROUP_DRV_HOST_AUDIO /** @todo Add an own log group for this? */
+
 #include <iprt/alloca.h>
 #include <iprt/asm.h>
@@ -30 +31 @@
 #include <iprt/env.h>
 #include <iprt/err.h>
+#include <iprt/file.h>
 #include <iprt/getopt.h>
 #include <iprt/handle.h>
@@ -47 +49 @@
 #include <iprt/thread.h>
 
+#include <VBox/log.h>
+
 #include "AudioTestService.h"
 #include "AudioTestServiceInternal.h"
@@ -54 +58 @@
 *   Structures and Typedefs                                                                                                      *
 *********************************************************************************************************************************/
+/**
+ * A generic ATS reply, used by the client
+ * to process the incoming packets.
+ */
+typedef struct ATSSRVREPLY
+{
+    char   szOp[ATSPKT_OPCODE_MAX_LEN];
+    void  *pvPayload;
+    size_t cbPayload;
+} ATSSRVREPLY;
+/** Pointer to a generic ATS reply. */
+typedef struct ATSSRVREPLY *PATSSRVREPLY;
 
 
@@ -62 +78 @@
  * Transport layers.
  */
-static const PCATSTRANSPORT g_apTransports[] =
+const PCATSTRANSPORT g_apTransports[] =
 {
     &g_TcpTransport
 };
+/** Number of transport layers in \a g_apTransports. */
+const size_t g_cTransports = RT_ELEMENTS(g_apTransports);
 
 /**
@@ -99 +117 @@
 } ATSCLIENTINST;
 /** Pointer to a ATS client instance. */
-typedef ATSCLIENTINST *PATSCLIENTINST;
+typedef ATSCLIENTINST *PATSSERVERINST;
 
 /**
@@ -130 +148 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The ATS client structure.
  * @param   pPkt                The packet to send.  Must point to a correctly
  *                              aligned buffer.
  */
-static int atsSendPkt(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPkt)
+static int atsSendPkt(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPkt)
 {
     Assert(pPkt->cb >= sizeof(*pPkt));
@@ -142 +160 @@
 
     LogFlowFunc(("cb=%RU32 (%#x), payload=%RU32 (%#x), opcode=%.8s\n",
-            pPkt->cb, pPkt->cb, pPkt->cb - sizeof(ATSPKTHDR), pPkt->cb - sizeof(ATSPKTHDR), pPkt->achOpcode));
-    LogFlowFunc(("%.*Rhxd\n", RT_MIN(pPkt->cb, 256), pPkt));
-    int rc = pThis->pTransport->pfnSendPkt(&pThis->TransportInst, pClient->pTransportClient, pPkt);
+                 pPkt->cb, pPkt->cb, pPkt->cb - sizeof(ATSPKTHDR), pPkt->cb - sizeof(ATSPKTHDR), pPkt->achOpcode));
+    int rc = pThis->pTransport->pfnSendPkt(pThis->pTransportInst, pInst->pTransportClient, pPkt);
     while (RT_UNLIKELY(rc == VERR_INTERRUPTED) && !pThis->fTerminate)
-        rc = pThis->pTransport->pfnSendPkt(&pThis->TransportInst, pClient->pTransportClient, pPkt);
+        rc = pThis->pTransport->pfnSendPkt(pThis->pTransportInst, pInst->pTransportClient, pPkt);
 
     return rc;
@@ -155 +172 @@
  *
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The ATS server instance.
  * @param   pszOpcode           The BABBLE opcode.
  */
-static void atsReplyBabble(PATSSERVER pThis, PATSCLIENTINST pClient, const char *pszOpcode)
+static void atsReplyBabble(PATSSERVER pThis, PATSSERVERINST pInst, const char *pszOpcode)
 {
     ATSPKTHDR Reply;
@@ -165 +182 @@
     memcpy(Reply.achOpcode, pszOpcode, sizeof(Reply.achOpcode));
 
-    pThis->pTransport->pfnBabble(&pThis->TransportInst, pClient->pTransportClient, &Reply, 20*1000);
+    pThis->pTransport->pfnBabble(pThis->pTransportInst, pInst->pTransportClient, &Reply, 20*1000);
 }
 
@@ -176 +193 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   ppPktHdr            Where to return the packet on success.  Free
  *                              with RTMemFree.
  * @param   fAutoRetryOnFailure Whether to retry on error.
  */
-static int atsRecvPkt(PATSSERVER pThis, PATSCLIENTINST pClient, PPATSPKTHDR ppPktHdr, bool fAutoRetryOnFailure)
+static int atsRecvPkt(PATSSERVER pThis, PATSSERVERINST pInst, PPATSPKTHDR ppPktHdr, bool fAutoRetryOnFailure)
 {
     for (;;)
     {
         PATSPKTHDR pPktHdr;
-        int rc = pThis->pTransport->pfnRecvPkt(&pThis->TransportInst, pClient->pTransportClient, &pPktHdr);
+        int rc = pThis->pTransport->pfnRecvPkt(pThis->pTransportInst, pInst->pTransportClient, &pPktHdr);
         if (RT_SUCCESS(rc))
         {
@@ -193 +210 @@
                 && pPktHdr->cb < ATSPKT_MAX_SIZE)
             {
-                Log2(("atsRecvPkt: pPktHdr=%p cb=%#x crc32=%#x opcode=%.8s\n"
-                      "%.*Rhxd\n",
-                      pPktHdr, pPktHdr->cb, pPktHdr->uCrc32, pPktHdr->achOpcode, RT_MIN(pPktHdr->cb, 256), pPktHdr));
+                Log2Func(("pPktHdr=%p cb=%#x crc32=%#x opcode=%.8s\n",
+                          pPktHdr, pPktHdr->cb, pPktHdr->uCrc32, pPktHdr->achOpcode));
                 uint32_t uCrc32Calc = pPktHdr->uCrc32 != 0
                                     ? RTCrc32(&pPktHdr->achOpcode[0], pPktHdr->cb - RT_UOFFSETOF(ATSPKTHDR, achOpcode))
@@ -212 +228 @@
                        )
                     {
-                        Log(("atsRecvPkt: cb=%#x opcode=%.8s\n", pPktHdr->cb, pPktHdr->achOpcode));
+                        Log(("cb=%#x opcode=%.8s\n", pPktHdr->cb, pPktHdr->achOpcode));
                         *ppPktHdr = pPktHdr;
                         return rc;
@@ -221 +237 @@
                 else
                 {
-                    Log(("atsRecvPkt: cb=%#x opcode=%.8s crc32=%#x actual=%#x\n",
+                    Log(("cb=%#x opcode=%.8s crc32=%#x actual=%#x\n",
                          pPktHdr->cb, pPktHdr->achOpcode, pPktHdr->uCrc32, uCrc32Calc));
                     rc = VERR_IO_CRC;
@@ -232 +248 @@
                connection oriented. */
             if (rc == VERR_IO_BAD_LENGTH)
-                atsReplyBabble(pThis, pClient, "BABBLE L");
+                atsReplyBabble(pThis, pInst, "BABBLE L");
             else if (rc == VERR_IO_CRC)
-                atsReplyBabble(pThis, pClient, "BABBLE C");
+                atsReplyBabble(pThis, pInst, "BABBLE C");
             else if (rc == VERR_IO_BAD_COMMAND)
-                atsReplyBabble(pThis, pClient, "BABBLE O");
+                atsReplyBabble(pThis, pInst, "BABBLE O");
             else
-                atsReplyBabble(pThis, pClient, "BABBLE  ");
+                atsReplyBabble(pThis, pInst, "BABBLE  ");
             RTMemFree(pPktHdr);
         }
@@ -248 +264 @@
             )
         {
-            Log(("atsRecvPkt: rc=%Rrc\n", rc));
+            Log(("rc=%Rrc\n", rc));
             return rc;
         }
@@ -259 +275 @@
  * @returns IPRT status code of the send.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pReply              The reply packet.
  * @param   pszOpcode           The status opcode.  Exactly 8 chars long, padd
@@ -265 +281 @@
  * @param   cbExtra             Bytes in addition to the header.
  */
-static int atsReplyInternal(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pReply, const char *pszOpcode, size_t cbExtra)
+static int atsReplyInternal(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pReply, const char *pszOpcode, size_t cbExtra)
 {
     /* copy the opcode, don't be too strict in case of a padding screw up. */
@@ -284 +300 @@
     pReply->uCrc32 = 0;
 
-    return atsSendPkt(pThis, pClient, pReply);
+    return atsSendPkt(pThis, pInst, pReply);
 }
 
@@ -292 +308 @@
  * @returns IPRT status code of the send.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The original packet (for future use).
  * @param   pszOpcode           The status opcode.  Exactly 8 chars long, padd
  *                              with space.
  */
-static int atsReplySimple(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr, const char *pszOpcode)
-{
-    return atsReplyInternal(pThis, pClient, pPktHdr, pszOpcode, 0);
+static int atsReplySimple(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr, const char *pszOpcode)
+{
+    return atsReplyInternal(pThis, pInst, pPktHdr, pszOpcode, 0);
 }
 
@@ -307 +323 @@
  * @returns IPRT status code of the send.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The original packet (for future use).
  */
-static int atsReplyAck(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
-{
-    return atsReplySimple(pThis, pClient, pPktHdr, "ACK     ");
+static int atsReplyAck(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
+{
+    return atsReplySimple(pThis, pInst, pPktHdr, "ACK     ");
 }
 
@@ -320 +336 @@
  * @returns IPRT status code of the send.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The original packet (for future use).
  * @param   pszOpcode           The status opcode.  Exactly 8 chars long, padd
@@ -328 +344 @@
  * @param   va                  Format arguments.
  */
-static int atsReplyFailureV(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr,
+static int atsReplyFailureV(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr,
                             const char *pszOpcode, int rcReq, const char *pszDetailFmt, va_list va)
 {
@@ -346 +362 @@
     uPkt.rc = rcReq;
 
-    return atsReplyInternal(pThis, pClient, &uPkt.Hdr, pszOpcode, sizeof(int) + cchDetail + 1);
+    return atsReplyInternal(pThis, pInst, &uPkt.Hdr, pszOpcode, sizeof(int) + cchDetail + 1);
 }
 
@@ -354 +370 @@
  * @returns IPRT status code of the send.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The original packet (for future use).
  * @param   pszOpcode           The status opcode.  Exactly 8 chars long, padd
@@ -362 +378 @@
  * @param   ...                 Format arguments.
  */
-static int atsReplyFailure(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr,
+static int atsReplyFailure(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr,
                            const char *pszOpcode, int rcReq, const char *pszDetailFmt, ...)
 {
     va_list va;
     va_start(va, pszDetailFmt);
-    int rc = atsReplyFailureV(pThis, pClient, pPktHdr, pszOpcode, rcReq, pszDetailFmt, va);
+    int rc = atsReplyFailureV(pThis, pInst, pPktHdr, pszOpcode, rcReq, pszDetailFmt, va);
     va_end(va);
     return rc;
@@ -377 +393 @@
  * @returns IPRT status code of the send.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The packet to reply to.
  * @param   rcOperation         The status code to report.
@@ -385 +401 @@
  */
 static int atsReplyRC(PATSSERVER pThis,
-                      PATSCLIENTINST pClient, PATSPKTHDR pPktHdr, int rcOperation, const char *pszOperationFmt, ...)
+                      PATSSERVERINST pInst, PATSPKTHDR pPktHdr, int rcOperation, const char *pszOperationFmt, ...)
 {
     if (RT_SUCCESS(rcOperation))
-        return atsReplyAck(pThis, pClient, pPktHdr);
+        return atsReplyAck(pThis, pInst, pPktHdr);
 
     char    szOperation[128];
@@ -396 +412 @@
     va_end(va);
 
-    return atsReplyFailure(pThis, pClient, pPktHdr, "FAILED  ", rcOperation, "%s failed with rc=%Rrc (opcode '%.8s')",
+    return atsReplyFailure(pThis, pInst, pPktHdr, "FAILED  ", rcOperation, "%s failed with rc=%Rrc (opcode '%.8s')",
                            szOperation, rcOperation, pPktHdr->achOpcode);
 }
@@ -405 +421 @@
  * @returns IPRT status code of the send.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The packet to reply to.
  * @param   cb                  The wanted size.
  */
-static int atsReplyBadSize(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr, size_t cb)
-{
-    return atsReplyFailure(pThis, pClient, pPktHdr, "BAD SIZE", VERR_INVALID_PARAMETER, "Expected at %zu bytes, got %u  (opcode '%.8s')",
+static int atsReplyBadSize(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr, size_t cb)
+{
+    return atsReplyFailure(pThis, pInst, pPktHdr, "BAD SIZE", VERR_INVALID_PARAMETER, "Expected at %zu bytes, got %u  (opcode '%.8s')",
                            cb, pPktHdr->cb, pPktHdr->achOpcode);
 }
@@ -420 +436 @@
  * @returns IPRT status code of the send.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The packet to reply to.
  */
-static int atsReplyUnknown(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
-{
-    return atsReplyFailure(pThis, pClient, pPktHdr, "UNKNOWN ", VERR_NOT_FOUND, "Opcode '%.8s' is not known", pPktHdr->achOpcode);
-}
-
-#if 0
-/**
- * Deals with a command which contains an unterminated string.
+static int atsReplyUnknown(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
+{
+    return atsReplyFailure(pThis, pInst, pPktHdr, "UNKNOWN ", VERR_NOT_FOUND, "Opcode '%.8s' is not known", pPktHdr->achOpcode);
+}
+
+/**
+ * Deals with a command sent in an invalid client state.
  *
  * @returns IPRT status code of the send.
- * @param   pClient             The ATS client structure.
+ * @param   pThis               The ATS instance.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The packet containing the unterminated string.
  */
-static int atsReplyBadStrTermination(PATSCLIENT pClient, PATSPKTHDR pPktHdr)
-{
-    return atsReplyFailure(pClient, pPktHdr, "BAD TERM", VERR_INVALID_PARAMETER, "Opcode '%.8s' contains an unterminated string", pPktHdr->achOpcode);
-}
-#endif
-
-/**
- * Deals with a command sent in an invalid client state.
- *
- * @returns IPRT status code of the send.
- * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
- * @param   pPktHdr             The packet containing the unterminated string.
- */
-static int atsReplyInvalidState(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
-{
-    return atsReplyFailure(pThis, pClient, pPktHdr, "INVSTATE", VERR_INVALID_STATE, "Opcode '%.8s' is not supported at client state '%s",
-                           pPktHdr->achOpcode, atsClientStateStringify(pClient->enmState));
+static int atsReplyInvalidState(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
+{
+    return atsReplyFailure(pThis, pInst, pPktHdr, "INVSTATE", VERR_INVALID_STATE, "Opcode '%.8s' is not supported at client state '%s",
+                           pPktHdr->achOpcode, atsClientStateStringify(pInst->enmState));
 }
 
@@ -461 +463 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The bye packet.
  */
-static int atsDoBye(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
+static int atsDoBye(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
 {
     int rc;
     if (pPktHdr->cb == sizeof(ATSPKTHDR))
     {
-        rc = atsReplyAck(pThis, pClient, pPktHdr);
+        rc = atsReplyAck(pThis, pInst, pPktHdr);
     }
     else
-        rc = atsReplyBadSize(pThis, pClient, pPktHdr, sizeof(ATSPKTHDR));
+        rc = atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTHDR));
     return rc;
 }
@@ -481 +483 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The howdy packet.
  */
-static int atsDoHowdy(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
+static int atsDoHowdy(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
 {
     int rc = VINF_SUCCESS;
 
     if (pPktHdr->cb != sizeof(ATSPKTREQHOWDY))
-        return atsReplyBadSize(pThis, pClient, pPktHdr, sizeof(ATSPKTREQHOWDY));
-
-    if (pClient->enmState != ATSCLIENTSTATE_INITIALISING)
-        return atsReplyInvalidState(pThis, pClient, pPktHdr);
+        return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQHOWDY));
+
+    if (pInst->enmState != ATSCLIENTSTATE_INITIALISING)
+        return atsReplyInvalidState(pThis, pInst, pPktHdr);
 
     PATSPKTREQHOWDY pReq = (PATSPKTREQHOWDY)pPktHdr;
 
     if (pReq->uVersion != ATS_PROTOCOL_VS)
-        return atsReplyRC(pThis, pClient, pPktHdr, VERR_VERSION_MISMATCH, "The given version %#x is not supported", pReq->uVersion);
+        return atsReplyRC(pThis, pInst, pPktHdr, VERR_VERSION_MISMATCH, "The given version %#x is not supported", pReq->uVersion);
 
     ATSPKTREPHOWDY Rep;
@@ -504 +506 @@
     Rep.uVersion = ATS_PROTOCOL_VS;
 
-    rc = atsReplyInternal(pThis, pClient, &Rep.Hdr, "ACK     ", sizeof(Rep) - sizeof(ATSPKTHDR));
+    rc = atsReplyInternal(pThis, pInst, &Rep.Hdr, "ACK     ", sizeof(Rep) - sizeof(ATSPKTHDR));
     if (RT_SUCCESS(rc))
     {
-        pThis->pTransport->pfnNotifyHowdy(&pThis->TransportInst, pClient->pTransportClient);
-        pClient->enmState = ATSCLIENTSTATE_READY;
+        pThis->pTransport->pfnNotifyHowdy(pThis->pTransportInst, pInst->pTransportClient);
+        pInst->enmState = ATSCLIENTSTATE_READY;
     }
 
@@ -519 +521 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The test set begin packet.
  */
-static int atsDoTestSetBegin(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
+static int atsDoTestSetBegin(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
 {
     if (pPktHdr->cb != sizeof(ATSPKTREQTSETBEG))
-        return atsReplyBadSize(pThis, pClient, pPktHdr, sizeof(ATSPKTREQTSETBEG));
+        return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTSETBEG));
 
     PATSPKTREQTSETBEG pReq = (PATSPKTREQTSETBEG)pPktHdr;
@@ -535 +537 @@
         rc = pThis->Callbacks.pfnTestSetBegin(pThis->Callbacks.pvUser, pReq->szTag);
         if (RT_FAILURE(rc))
-            return atsReplyRC(pThis, pClient, pPktHdr, rc, "Beginning test set '%s' failed", pReq->szTag);
+            return atsReplyRC(pThis, pInst, pPktHdr, rc, "Beginning test set '%s' failed", pReq->szTag);
     }
 
     if (RT_SUCCESS(rc))
     {
-        rc = atsReplyAck(pThis, pClient, pPktHdr);
+        rc = atsReplyAck(pThis, pInst, pPktHdr);
     }
     else
-        rc = atsReplyRC(pThis, pClient, pPktHdr, rc, "Beginning test set failed");
+        rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Beginning test set failed");
 
     return rc;
@@ -553 +555 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The test set end packet.
  */
-static int atsDoTestSetEnd(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
+static int atsDoTestSetEnd(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
 {
     if (pPktHdr->cb != sizeof(ATSPKTREQTSETEND))
-        return atsReplyBadSize(pThis, pClient, pPktHdr, sizeof(ATSPKTREQTSETEND));
+        return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTSETEND));
 
     PATSPKTREQTSETEND pReq = (PATSPKTREQTSETEND)pPktHdr;
@@ -569 +571 @@
         rc = pThis->Callbacks.pfnTestSetEnd(pThis->Callbacks.pvUser, pReq->szTag);
         if (RT_FAILURE(rc))
-            return atsReplyRC(pThis, pClient, pPktHdr, rc, "Ending test set '%s' failed", pReq->szTag);
+            return atsReplyRC(pThis, pInst, pPktHdr, rc, "Ending test set '%s' failed", pReq->szTag);
     }
     if (RT_SUCCESS(rc))
     {
-        rc = atsReplyAck(pThis, pClient, pPktHdr);
+        rc = atsReplyAck(pThis, pInst, pPktHdr);
     }
     else
-        rc = atsReplyRC(pThis, pClient, pPktHdr, rc, "Ending test set failed");
+        rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Ending test set failed");
 
     return rc;
@@ -588 +590 @@
  *          or whatever atsRecvPkt returns.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The original packet (for future use).
  */
-static int atsWaitForAck(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
+static int atsWaitForAck(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
 {
     RT_NOREF(pPktHdr);
     /** @todo timeout? */
     PATSPKTHDR pReply;
-    int rc = atsRecvPkt(pThis, pClient, &pReply, false /*fAutoRetryOnFailure*/);
+    int rc = atsRecvPkt(pThis, pInst, &pReply, false /*fAutoRetryOnFailure*/);
     if (RT_SUCCESS(rc))
     {
@@ -605 +607 @@
         else
         {
-            atsReplyBabble(pThis, pClient, "BABBLE  ");
+            atsReplyBabble(pThis, pInst, "BABBLE  ");
             rc = VERR_NET_NOT_CONNECTED;
         }
@@ -618 +620 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The test set end packet.
  */
-static int atsDoTestSetSend(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
+static int atsDoTestSetSend(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
 {
     if (pPktHdr->cb != sizeof(ATSPKTREQTSETSND))
-        return atsReplyBadSize(pThis, pClient, pPktHdr, sizeof(ATSPKTREQTSETSND));
+        return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTSETSND));
 
     PATSPKTREQTSETSND pReq = (PATSPKTREQTSETSND)pPktHdr;
@@ -631 +633 @@
 
     if (!pThis->Callbacks.pfnTestSetSendRead)
-        return atsReplyRC(pThis, pClient, pPktHdr, VERR_NOT_SUPPORTED, "Sending test set not implemented");
+        return atsReplyRC(pThis, pInst, pPktHdr, VERR_NOT_SUPPORTED, "Sending test set not implemented");
 
     if (pThis->Callbacks.pfnTestSetSendBegin)
@@ -637 +639 @@
         rc = pThis->Callbacks.pfnTestSetSendBegin(pThis->Callbacks.pvUser, pReq->szTag);
         if (RT_FAILURE(rc))
-            return atsReplyRC(pThis, pClient, pPktHdr, rc, "Beginning sending test set '%s' failed", pReq->szTag);
+            return atsReplyRC(pThis, pInst, pPktHdr, rc, "Beginning sending test set '%s' failed", pReq->szTag);
     }
 
@@ -650 +652 @@
             char        abPadding[ATSPKT_ALIGNMENT];
         }       Pkt;
+#ifdef DEBUG
+        RT_ZERO(Pkt);
+#endif
         size_t  cbRead = 0;
         rc = pThis->Callbacks.pfnTestSetSendRead(pThis->Callbacks.pvUser, pReq->szTag, &Pkt.ab, sizeof(Pkt.ab), &cbRead);
@@ -659 +664 @@
             {
                 Pkt.uCrc32 = RTCrc32Finish(uMyCrc32);
-                rc = atsReplyInternal(pThis, pClient, &Pkt.Hdr, "DATA EOF", sizeof(uint32_t) /* uCrc32 */);
+                rc = atsReplyInternal(pThis, pInst, &Pkt.Hdr, "DATA EOF", sizeof(uint32_t) /* uCrc32 */);
                 if (RT_SUCCESS(rc))
-                    rc = atsWaitForAck(pThis, pClient, &Pkt.Hdr);
+                    rc = atsWaitForAck(pThis, pInst, &Pkt.Hdr);
             }
             else
-                rc = atsReplyRC(pThis, pClient, pPktHdr, rc, "Sending data for test set '%s' failed", pReq->szTag);
+                rc = atsReplyRC(pThis, pInst, pPktHdr, rc, "Sending data for test set '%s' failed", pReq->szTag);
             break;
         }
@@ -671 +676 @@
         Pkt.uCrc32 = RTCrc32Finish(uMyCrc32);
 
+        Log2Func(("cbRead=%zu -> uCrc32=%#x\n", cbRead, Pkt.uCrc32));
+
         Assert(cbRead <= sizeof(Pkt.ab));
 
-        rc = atsReplyInternal(pThis, pClient, &Pkt.Hdr, "DATA    ", sizeof(uint32_t) /* uCrc32 */ + cbRead);
+        rc = atsReplyInternal(pThis, pInst, &Pkt.Hdr, "DATA    ", sizeof(uint32_t) /* uCrc32 */ + cbRead);
         if (RT_FAILURE(rc))
             break;
 
-        rc = atsWaitForAck(pThis, pClient, &Pkt.Hdr);
+        rc = atsWaitForAck(pThis, pInst, &Pkt.Hdr);
         if (RT_FAILURE(rc))
             break;
@@ -686 +693 @@
         int rc2 = pThis->Callbacks.pfnTestSetSendEnd(pThis->Callbacks.pvUser, pReq->szTag);
         if (RT_FAILURE(rc2))
-            return atsReplyRC(pThis, pClient, pPktHdr, rc2, "Ending sending test set '%s' failed", pReq->szTag);
+            return atsReplyRC(pThis, pInst, pPktHdr, rc2, "Ending sending test set '%s' failed", pReq->szTag);
     }
 
@@ -697 +704 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The packet header.
  */
-static int atsDoTonePlay(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
+static int atsDoTonePlay(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
 {
     int rc = VINF_SUCCESS;
 
     if (pPktHdr->cb < sizeof(ATSPKTREQTONEPLAY))
-        return atsReplyBadSize(pThis, pClient, pPktHdr, sizeof(ATSPKTREQTONEPLAY));
-
-    if (pClient->enmState != ATSCLIENTSTATE_READY)
-        return atsReplyInvalidState(pThis, pClient, pPktHdr);
+        return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTONEPLAY));
+
+    if (pInst->enmState != ATSCLIENTSTATE_READY)
+        return atsReplyInvalidState(pThis, pInst, pPktHdr);
 
     if (!pThis->Callbacks.pfnTonePlay)
-        return atsReplyRC(pThis, pClient, pPktHdr, VERR_NOT_SUPPORTED, "Playing tones not supported");
+        return atsReplyRC(pThis, pInst, pPktHdr, VERR_NOT_SUPPORTED, "Playing tones not supported");
 
     PATSPKTREQTONEPLAY pReq = (PATSPKTREQTONEPLAY)pPktHdr;
     rc = pThis->Callbacks.pfnTonePlay(pThis->Callbacks.pvUser, &pReq->ToneParms);
 
-    int rc2 = atsReplyAck(pThis, pClient, pPktHdr);
+    int rc2 = atsReplyAck(pThis, pInst, pPktHdr);
     if (RT_SUCCESS(rc))
         rc = rc2;
@@ -728 +735 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure.
+ * @param   pInst               The opaque ATS instance structure.
  * @param   pPktHdr             The packet header.
  */
-static int atsDoToneRecord(PATSSERVER pThis, PATSCLIENTINST pClient, PATSPKTHDR pPktHdr)
+static int atsDoToneRecord(PATSSERVER pThis, PATSSERVERINST pInst, PATSPKTHDR pPktHdr)
 {
     int rc = VINF_SUCCESS;
 
     if (pPktHdr->cb < sizeof(ATSPKTREQTONEREC))
-        return atsReplyBadSize(pThis, pClient, pPktHdr, sizeof(ATSPKTREQTONEREC));
-
-    if (pClient->enmState != ATSCLIENTSTATE_READY)
-        return atsReplyInvalidState(pThis, pClient, pPktHdr);
+        return atsReplyBadSize(pThis, pInst, pPktHdr, sizeof(ATSPKTREQTONEREC));
+
+    if (pInst->enmState != ATSCLIENTSTATE_READY)
+        return atsReplyInvalidState(pThis, pInst, pPktHdr);
 
     if (!pThis->Callbacks.pfnToneRecord)
-        return atsReplyRC(pThis, pClient, pPktHdr, VERR_NOT_SUPPORTED, "Recording tones not supported");
+        return atsReplyRC(pThis, pInst, pPktHdr, VERR_NOT_SUPPORTED, "Recording tones not supported");
 
     PATSPKTREQTONEREC pReq = (PATSPKTREQTONEREC)pPktHdr;
     rc = pThis->Callbacks.pfnToneRecord(pThis->Callbacks.pvUser, &pReq->ToneParms);
 
-    int rc2 = atsReplyAck(pThis, pClient, pPktHdr);
+    int rc2 = atsReplyAck(pThis, pInst, pPktHdr);
     if (RT_SUCCESS(rc))
         rc = rc2;
@@ -759 +766 @@
  * @returns IPRT status code.
  * @param   pThis               The ATS instance.
- * @param   pClient             The ATS client structure sending the request.
- */
-static int atsClientReqProcess(PATSSERVER pThis, PATSCLIENTINST pClient)
+ * @param   pInst             The ATS client structure sending the request.
+ */
+static int atsClientReqProcess(PATSSERVER pThis, PATSSERVERINST pInst)
 {
     /*
@@ -767 +774 @@
      */
     PATSPKTHDR pPktHdr = NULL;
-    int rc = atsRecvPkt(pThis, pClient, &pPktHdr, true /*fAutoRetryOnFailure*/);
+    int rc = atsRecvPkt(pThis, pInst, &pPktHdr, true /*fAutoRetryOnFailure*/);
     if (RT_FAILURE(rc))
         return rc;
@@ -776 +783 @@
     /* Connection: */
     if (     atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_HOWDY))
-        rc = atsDoHowdy(pThis, pClient, pPktHdr);
+        rc = atsDoHowdy(pThis, pInst, pPktHdr);
     else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_BYE))
-        rc = atsDoBye(pThis, pClient, pPktHdr);
+        rc = atsDoBye(pThis, pInst, pPktHdr);
     /* Test set handling: */
     else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TESTSET_BEGIN))
-        rc = atsDoTestSetBegin(pThis, pClient, pPktHdr);
+        rc = atsDoTestSetBegin(pThis, pInst, pPktHdr);
     else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TESTSET_END))
-        rc = atsDoTestSetEnd(pThis, pClient, pPktHdr);
+        rc = atsDoTestSetEnd(pThis, pInst, pPktHdr);
     else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TESTSET_SEND))
-        rc = atsDoTestSetSend(pThis, pClient, pPktHdr);
+        rc = atsDoTestSetSend(pThis, pInst, pPktHdr);
     /* Audio testing: */
     else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TONE_PLAY))
-        rc = atsDoTonePlay(pThis, pClient, pPktHdr);
+        rc = atsDoTonePlay(pThis, pInst, pPktHdr);
     else if (atsIsSameOpcode(pPktHdr, ATSPKT_OPCODE_TONE_RECORD))
-        rc = atsDoToneRecord(pThis, pClient, pPktHdr);
+        rc = atsDoToneRecord(pThis, pInst, pPktHdr);
     /* Misc: */
     else
-        rc = atsReplyUnknown(pThis, pClient, pPktHdr);
+        rc = atsReplyUnknown(pThis, pInst, pPktHdr);
 
     RTMemFree(pPktHdr);
@@ -804 +811 @@
  *
  * @returns nothing.
- * @param   pClient             The ATS client structure.
- */
-static void atsClientDestroy(PATSCLIENTINST pClient)
-{
-    if (pClient->pszHostname)
-        RTStrFree(pClient->pszHostname);
-    RTMemFree(pClient);
+ * @param   pInst               The opaque ATS instance structure.
+ */
+static void atsClientDestroy(PATSSERVERINST pInst)
+{
+    if (pInst->pszHostname)
+        RTStrFree(pInst->pszHostname);
+    RTMemFree(pInst);
 }
 
@@ -825 +832 @@
     unsigned    cClientsMax = 0;
     unsigned    cClientsCur = 0;
-    PATSCLIENTINST *papClients  = NULL;
+    PATSSERVERINST *papInsts  = NULL;
 
     /* Add the pipe to the poll set. */
@@ -853 +860 @@
                     RTCritSectEnter(&pThis->CritSectClients);
                     /* Walk the list and add all new clients. */
-                    PATSCLIENTINST pIt, pItNext;
+                    PATSSERVERINST pIt, pItNext;
                     RTListForEachSafe(&pThis->LstClientsNew, pIt, pItNext, ATSCLIENTINST, NdLst)
                     {
@@ -861 +868 @@
                         {
                             /* Realloc to accommodate for the new clients. */
-                            PATSCLIENTINST *papClientsNew = (PATSCLIENTINST *)RTMemRealloc(papClients, (cClientsMax + 10) * sizeof(PATSCLIENTINST));
-                            if (RT_LIKELY(papClientsNew))
+                            PATSSERVERINST *papInstsNew = (PATSSERVERINST *)RTMemRealloc(papInsts, (cClientsMax + 10) * sizeof(PATSSERVERINST));
+                            if (RT_LIKELY(papInstsNew))
                             {
                                 cClientsMax += 10;
-                                papClients = papClientsNew;
+                                papInsts = papInstsNew;
                             }
                         }
@@ -873 +880 @@
                             unsigned idxSlt = 0;
                             while (   idxSlt < cClientsMax
-                                   && papClients[idxSlt] != NULL)
+                                   && papInsts[idxSlt] != NULL)
                                 idxSlt++;
 
-                            rc = pThis->pTransport->pfnPollSetAdd(&pThis->TransportInst, pThis->hPollSet, pIt->pTransportClient, idxSlt + 1);
+                            rc = pThis->pTransport->pfnPollSetAdd(pThis->pTransportInst, pThis->hPollSet, pIt->pTransportClient, idxSlt + 1);
                             if (RT_SUCCESS(rc))
                             {
                                 cClientsCur++;
-                                papClients[idxSlt] = pIt;
+                                papInsts[idxSlt] = pIt;
                             }
                             else
                             {
-                                pThis->pTransport->pfnNotifyBye(&pThis->TransportInst, pIt->pTransportClient);
+                                pThis->pTransport->pfnNotifyBye(pThis->pTransportInst, pIt->pTransportClient);
                                 atsClientDestroy(pIt);
                             }
@@ -890 +897 @@
                         else
                         {
-                            pThis->pTransport->pfnNotifyBye(&pThis->TransportInst, pIt->pTransportClient);
+                            pThis->pTransport->pfnNotifyBye(pThis->pTransportInst, pIt->pTransportClient);
                             atsClientDestroy(pIt);
                         }
@@ -899 +906 @@
                 {
                     /* Client sends a request, pick the right client and process it. */
-                    PATSCLIENTINST pClient = papClients[uId - 1];
-                    AssertPtr(pClient);
+                    PATSSERVERINST pInst = papInsts[uId - 1];
+                    AssertPtr(pInst);
                     if (fEvts & RTPOLL_EVT_READ)
-                        rc = atsClientReqProcess(pThis, pClient);
+                        rc = atsClientReqProcess(pThis, pInst);
 
                     if (   (fEvts & RTPOLL_EVT_ERROR)
@@ -908 +915 @@
                     {
                         /* Close connection and remove client from array. */
-                        rc = pThis->pTransport->pfnPollSetRemove(&pThis->TransportInst, pThis->hPollSet, pClient->pTransportClient, uId);
+                        rc = pThis->pTransport->pfnPollSetRemove(pThis->pTransportInst, pThis->hPollSet, pInst->pTransportClient, uId);
                         AssertRC(rc);
 
-                        pThis->pTransport->pfnNotifyBye(&pThis->TransportInst, pClient->pTransportClient);
-                        papClients[uId - 1] = NULL;
+                        pThis->pTransport->pfnNotifyBye(pThis->pTransportInst, pInst->pTransportClient);
+                        papInsts[uId - 1] = NULL;
                         cClientsCur--;
-                        atsClientDestroy(pClient);
+                        atsClientDestroy(pInst);
                     }
                 }
@@ -929 +936 @@
  * @returns VBox status code.
  */
-static DECLCALLBACK(int) atsMainThread(RTTHREAD hThread, void *pvUser)
+static DECLCALLBACK(int) atsConnectThread(RTTHREAD hThread, void *pvUser)
 {
     RT_NOREF(hThread);
@@ -946 +953 @@
          */
         PATSTRANSPORTCLIENT pTransportClient;
-        rc = pThis->pTransport->pfnWaitForConnect(&pThis->TransportInst, &pTransportClient);
+        rc = pThis->pTransport->pfnWaitForConnect(pThis->pTransportInst, &pTransportClient);
         if (RT_FAILURE(rc))
             continue;
@@ -954 +961 @@
          * the request handling thread.
          */
-        PATSCLIENTINST pClient = (PATSCLIENTINST)RTMemAllocZ(sizeof(ATSCLIENTINST));
-        if (RT_LIKELY(pClient))
+        PATSSERVERINST pInst = (PATSSERVERINST)RTMemAllocZ(sizeof(ATSCLIENTINST));
+        if (RT_LIKELY(pInst))
         {
-            pClient->enmState         = ATSCLIENTSTATE_INITIALISING;
-            pClient->pTransportClient = pTransportClient;
-            pClient->pszHostname      = NULL;
+            pInst->enmState         = ATSCLIENTSTATE_INITIALISING;
+            pInst->pTransportClient = pTransportClient;
+            pInst->pszHostname      = NULL;
 
             /* Add client to the new list and inform the worker thread. */
             RTCritSectEnter(&pThis->CritSectClients);
-            RTListAppend(&pThis->LstClientsNew, &pClient->NdLst);
+            RTListAppend(&pThis->LstClientsNew, &pInst->NdLst);
             RTCritSectLeave(&pThis->CritSectClients);
 
@@ -974 +981 @@
         {
             RTMsgError("Creating new client structure failed with out of memory error\n");
-            pThis->pTransport->pfnNotifyBye(&pThis->TransportInst, pTransportClient);
+            pThis->pTransport->pfnNotifyBye(pThis->pTransportInst, pTransportClient);
         }
     }
@@ -982 +989 @@
 
 /**
- * Initializes the global ATS state.
+ * Creates an ATS instance.
  *
  * @returns VBox status code.
- * @param   pThis               The ATS instance.
- * @param   pszBindAddr         Bind address. Empty means any address.
- *                              If set to NULL, "127.0.0.1" will be used.
- * @param   uBindPort           Bind port. If set to 0, ATS_DEFAULT_PORT is being used.
- * @param   pCallbacks          The callbacks table to use.
- *  */
-int AudioTestSvcInit(PATSSERVER pThis,
-                     const char *pszBindAddr, uint32_t uBindPort, PCATSCALLBACKS pCallbacks)
-{
-    memcpy(&pThis->Callbacks, pCallbacks, sizeof(ATSCALLBACKS));
-
-    pThis->fStarted   = false;
-    pThis->fTerminate = false;
-
-    pThis->hPipeR     = NIL_RTPIPE;
-    pThis->hPipeW     = NIL_RTPIPE;
-
-    RTListInit(&pThis->LstClientsNew);
-
+ * @param   pThis               The ATS instance to create.
+ */
+int AudioTestSvcCreate(PATSSERVER pThis)
+{
     /*
      * The default transporter is the first one.
      */
-    pThis->pTransport = g_apTransports[0];
+    pThis->pTransport = g_apTransports[0]; /** @todo Make this dynamic. */
+
+    return pThis->pTransport->pfnCreate(&pThis->pTransportInst);
+}
+
+/**
+ * Initializes an ATS instance.
+ *
+ * @returns VBox status code.
+ * @param   pThis               The ATS instance.
+ * @param   pCallbacks          The callbacks table to use.
+ */
+int AudioTestSvcInit(PATSSERVER pThis, PCATSCALLBACKS pCallbacks)
+{
+    memcpy(&pThis->Callbacks, pCallbacks, sizeof(ATSCALLBACKS));
+
+    pThis->fStarted   = false;
+    pThis->fTerminate = false;
+
+    pThis->hPipeR     = NIL_RTPIPE;
+    pThis->hPipeW     = NIL_RTPIPE;
+
+    RTListInit(&pThis->LstClientsNew);
 
     /*
      * Initialize the transport layer.
      */
-    int rc = pThis->pTransport->pfnInit(&pThis->TransportInst, pszBindAddr ? pszBindAddr : ATS_TCP_HOST_DEFAULT_ADDR_STR,
-                                         uBindPort ? uBindPort : ATS_TCP_HOST_DEFAULT_PORT);
+    int rc = RTCritSectInit(&pThis->CritSectClients);
     if (RT_SUCCESS(rc))
     {
-        rc = RTCritSectInit(&pThis->CritSectClients);
+        rc = RTPollSetCreate(&pThis->hPollSet);
         if (RT_SUCCESS(rc))
         {
-            rc = RTPollSetCreate(&pThis->hPollSet);
+            rc = RTPipeCreate(&pThis->hPipeR, &pThis->hPipeW, 0);
             if (RT_SUCCESS(rc))
             {
-                rc = RTPipeCreate(&pThis->hPipeR, &pThis->hPipeW, 0);
+                /* Spin off the thread serving connections. */
+                rc = RTThreadCreate(&pThis->hThreadServing, atsClientWorker, pThis, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE,
+                                    "AUDTSTSRVC");
                 if (RT_SUCCESS(rc))
-                {
-                    /* Spin off the thread serving connections. */
-                    rc = RTThreadCreate(&pThis->hThreadServing, atsClientWorker, pThis, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE,
-                                        "AUDTSTSRVC");
-                    if (RT_SUCCESS(rc))
-                        return VINF_SUCCESS;
-                    else
-                        RTMsgError("Creating the client worker thread failed with %Rrc\n", rc);
-
-                    RTPipeClose(pThis->hPipeR);
-                    RTPipeClose(pThis->hPipeW);
-                }
+                    return VINF_SUCCESS;
                 else
-                    RTMsgError("Creating communications pipe failed with %Rrc\n", rc);
-
-                RTPollSetDestroy(pThis->hPollSet);
+                    RTMsgError("Creating the client worker thread failed with %Rrc\n", rc);
+
+                RTPipeClose(pThis->hPipeR);
+                RTPipeClose(pThis->hPipeW);
             }
             else
-                RTMsgError("Creating pollset failed with %Rrc\n", rc);
-
-            RTCritSectDelete(&pThis->CritSectClients);
+                RTMsgError("Creating communications pipe failed with %Rrc\n", rc);
+
+            RTPollSetDestroy(pThis->hPollSet);
         }
         else
-            RTMsgError("Creating global critical section failed with %Rrc\n", rc);
+            RTMsgError("Creating pollset failed with %Rrc\n", rc);
+
+        RTCritSectDelete(&pThis->CritSectClients);
     }
     else
-        RTMsgError("Initializing the transport layer failed with %Rrc\n", rc);
-
-    return rc;
+        RTMsgError("Creating global critical section failed with %Rrc\n", rc);
+
+    return rc;
+}
+
+/**
+ * Handles a command line option.
+ *
+ * @returns VBox status code.
+ * @param   pThis               The ATS instance to handle option for.
+ * @param   ch                  Option (short) to handle.
+ * @param   pVal                Option union to store the result in on success.
+ */
+int AudioTestSvcHandleOption(PATSSERVER pThis, int ch, PCRTGETOPTUNION pVal)
+{
+    AssertPtrReturn(pThis->pTransport, VERR_WRONG_ORDER); /* Must be creatd first. */
+    if (!pThis->pTransport->pfnOption)
+        return VERR_GETOPT_UNKNOWN_OPTION;
+    return pThis->pTransport->pfnOption(pThis->pTransportInst, ch, pVal);
 }
 
@@ -1059 +1082 @@
  *
  * @returns VBox status code.
- * @param   pThis               The ATS instance.
+ * @param   pThis               The ATS instance to start.
  */
 int AudioTestSvcStart(PATSSERVER pThis)
 {
-    /* Spin off the main thread. */
-    int rc = RTThreadCreate(&pThis->hThreadMain, atsMainThread, pThis, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE,
+    int rc = pThis->pTransport->pfnStart(pThis->pTransportInst);
+    if (RT_SUCCESS(rc))
+    {
+        /* Spin off the connection thread. */
+        rc = RTThreadCreate(&pThis->hThreadMain, atsConnectThread, pThis, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE,
                             "AUDTSTSRVM");
-    if (RT_SUCCESS(rc))
-    {
-        rc = RTThreadUserWait(pThis->hThreadMain, RT_MS_30SEC);
         if (RT_SUCCESS(rc))
-            pThis->fStarted = true;
+        {
+            rc = RTThreadUserWait(pThis->hThreadMain, RT_MS_30SEC);
+            if (RT_SUCCESS(rc))
+                pThis->fStarted = true;
+        }
     }
 
@@ -1090 +1117 @@
 
     if (pThis->pTransport)
-        pThis->pTransport->pfnTerm(&pThis->TransportInst);
+        pThis->pTransport->pfnTerm(pThis->pTransportInst);
 
     size_t cbWritten;
@@ -1149 +1176 @@
     pThis->pTransport = NULL;
 
-    PATSCLIENTINST pIt, pItNext;
+    PATSSERVERINST pIt, pItNext;
     RTListForEachSafe(&pThis->LstClientsNew, pIt, pItNext, ATSCLIENTINST, NdLst)
     {
@@ -1175 +1202 @@
 int AudioTestSvcDestroy(PATSSERVER pThis)
 {
-    return audioTestSvcDestroyInternal(pThis);
-}
-
+    int rc = audioTestSvcDestroyInternal(pThis);
+    if (RT_SUCCESS(rc))
+    {
+        if (pThis->pTransport)
+        {
+            if (   pThis->pTransport->pfnDestroy
+                && pThis->pTransportInst)
+            {
+                pThis->pTransport->pfnDestroy(pThis->pTransportInst);
+                pThis->pTransportInst = NULL;
+            }
+        }
+    }
+
+    return rc;
+}

trunk/src/VBox/Devices/Audio/AudioTestService.h

@@ -22 +22 @@
 #endif
 
+#include <iprt/tcp.h>
+
 #include "AudioTestServiceInternal.h"
 
+extern const PCATSTRANSPORT g_apTransports[];
+extern const size_t         g_cTransports;
 
-/** Default TCP/IP port the host ATS (Audio Test Service) is running on. */
-#define ATS_TCP_HOST_DEFAULT_PORT        6052
-/** Default TCP/IP address the host ATS (Audio Test Service) is running on. */
-#define ATS_TCP_HOST_DEFAULT_ADDR_STR    "127.0.0.1"
-/** Default TCP/IP port the guest ATS (Audio Test Service) is running on. */
-#define ATS_TCP_GUEST_DEFAULT_PORT       6042
+/** Default TCP/IP bind port the guest ATS (Audio Test Service) is listening on. */
+#define ATS_TCP_DEF_BIND_PORT_GUEST       6052
+/** Default TCP/IP bind port the host ATS is listening on. */
+#define ATS_TCP_DEF_BIND_PORT_HOST        6042
+/** Default TCP/IP ATS bind port the ValidationKit Audio Driver ATS is listening on. */
+#define ATS_TCP_DEF_BIND_PORT_VALKIT      6052
+/** Default TCP/IP port the guest ATS is connecting to. */
+#define ATS_TCP_DEF_CONNECT_PORT_GUEST    ATS_TCP_DEF_BIND_PORT_HOST
+/** Default TCP/IP port the host ATS is connecting to the guest (needs NAT port forwarding). */
+#define ATS_TCP_DEF_CONNECT_PORT_HOST_PORT_FWD     6062
+/** Default TCP/IP port the host ATS is connecting to. */
+#define ATS_TCP_DEF_CONNECT_PORT_VALKIT   ATS_TCP_DEF_BIND_PORT_VALKIT
+/** Default TCP/IP address the host is connecting to. */
+#define ATS_TCP_DEF_CONNECT_HOST_ADDR_STR "127.0.0.1"
+/** Default TCP/IP address the guest ATS connects to when
+ *  running in client mode (reversed mode, needed for NATed VMs). */
+#define ATS_TCP_DEF_CONNECT_GUEST_STR     "10.0.2.2"
 
 /**
@@ -110 +125 @@
 
 /**
- * Structure for keeping Audio Test Service (ATS) transport instance-specific data.
- *
- * Currently only TCP/IP is supported.
- */
-typedef struct ATSTRANSPORTINST
-{
-    /** The addresses to bind to.  Empty string means any. */
-    char                 szTcpBindAddr[256];
-    /** The TCP port to listen to. */
-    uint32_t             uTcpBindPort;
-    /** Pointer to the TCP server instance. */
-    PRTTCPSERVER         pTcpServer;
-} ATSTRANSPORTINST;
-/** Pointer to an Audio Test Service (ATS) TCP/IP transport instance. */
-typedef ATSTRANSPORTINST *PATSTRANSPORTINSTTCP;
-
-/**
  * Structure for keeping an Audio Test Service (ATS) instance.
  */
 typedef struct ATSSERVER
 {
-    /** The selected transport layer. */
+    /** Pointer to the selected transport layer. */
     PCATSTRANSPORT       pTransport;
-    /** The transport instance. */
-    ATSTRANSPORTINST     TransportInst;
+    /** Pointer to the transport instance. */
+    PATSTRANSPORTINST    pTransportInst;
     /** The callbacks table. */
     ATSCALLBACKS         Callbacks;
@@ -159 +157 @@
 typedef ATSSERVER *PATSSERVER;
 
-int AudioTestSvcInit(PATSSERVER pThis, const char *pszBindAddr, uint32_t uBindPort, PCATSCALLBACKS pCallbacks);
+int AudioTestSvcCreate(PATSSERVER pThis);
+int AudioTestSvcInit(PATSSERVER pThis, PCATSCALLBACKS pCallbacks);
 int AudioTestSvcDestroy(PATSSERVER pThis);
+int AudioTestSvcHandleOption(PATSSERVER pThis, int ch, PCRTGETOPTUNION pVal);
 int AudioTestSvcStart(PATSSERVER pThis);
 int AudioTestSvcShutdown(PATSSERVER pThis);
 
+/** TCP/IP options for the ATS server.
+ *  @todo Make this more abstract later. */
+enum ATSTCPOPT
+{
+    ATSTCPOPT_MODE = 5000,
+    ATSTCPOPT_BIND_ADDRESS,
+    ATSTCPOPT_BIND_PORT,
+    ATSTCPOPT_CONNECT_ADDRESS,
+    ATSTCPOPT_CONNECT_PORT
+};
+
 #endif /* !VBOX_INCLUDED_SRC_Audio_AudioTestService_h */
 

trunk/src/VBox/Devices/Audio/AudioTestServiceClient.cpp

@@ -22 +22 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
-#define LOG_GROUP RTLOGGROUP_DEFAULT
-#include <VBox/log.h>
+#define LOG_GROUP LOG_GROUP_DRV_HOST_AUDIO /** @todo Add an own log group for this? */
 
 #include <iprt/crc.h>
@@ -32 +31 @@
 #include <iprt/tcp.h>
 
+#include <VBox/log.h>
+
 #include "AudioTestService.h"
-#include "AudioTestServiceProtocol.h"
+#include "AudioTestServiceInternal.h"
 #include "AudioTestServiceClient.h"
 
@@ -45 +46 @@
 {
     char   szOp[ATSPKT_OPCODE_MAX_LEN];
+    /** Pointer to payload data.
+     *  This does *not* include the header! */
     void  *pvPayload;
+    /** Size (in bytes) of the payload data.
+     *  This does *not* include the header! */
     size_t cbPayload;
 } ATSSRVREPLY;
@@ -59 +64 @@
 static void audioTestSvcClientInit(PATSCLIENT pClient)
 {
-    pClient->cbHdr = 0;
-    pClient->hSock = NIL_RTSOCKET;
+    RT_BZERO(pClient, sizeof(ATSCLIENT));
 }
 
@@ -94 +98 @@
 static int audioTestSvcClientRecvReply(PATSCLIENT pClient, PATSSRVREPLY pReply, bool fNoDataOk)
 {
-    int rc;
-
     LogFlowFuncEnter();
 
-    ATSPKTHDR Hdr;
-    RT_ZERO(Hdr);
-    size_t    cbHdr = 0;
-    if (pClient->cbHdr) /* Header already received? */
+    PATSPKTHDR pPktHdr;
+    int rc = pClient->pTransport->pfnRecvPkt(pClient->pTransportInst, pClient->pTransportClient, &pPktHdr);
+    if (RT_SUCCESS(rc))
     {
-        memcpy(&Hdr, &pClient->abHdr, sizeof(Hdr));
-        cbHdr = pClient->cbHdr;
-        pClient->cbHdr = 0;
-        rc = VINF_SUCCESS;
-    }
-    else /* No, receive header. */
-    {
-        rc = RTTcpRead(pClient->hSock, &Hdr, sizeof(Hdr), &cbHdr);
-    }
-
-    LogFlowFunc(("rc=%Rrc, hdr=%zu, hdr.cb=%zu, %.8s -> %.*Rhxd\n", rc, cbHdr, Hdr.cb, Hdr.achOpcode, RT_MIN(cbHdr, sizeof(ATSPKTHDR)), &Hdr));
-
-    if (RT_FAILURE(rc))
-        return rc;
-
-    if (cbHdr != sizeof(Hdr)) /* Check for bad packet sizes. */
-    {
-        AssertMsgFailed(("Packet is invalid (%RU32 bytes), must be at least %zu bytes\n", cbHdr, sizeof(Hdr)));
-        return VERR_NET_INCOMPLETE_TX_PACKET;
-    }
-
-    if (Hdr.cb < sizeof(ATSPKTHDR))
-    {
-        AssertMsgFailed(("Packet is too small (%RU32 bytes), must be at least %zu bytes\n", Hdr.cb, sizeof(Hdr)));
-        return VERR_NET_INCOMPLETE_TX_PACKET;
-    }
-
-    if (Hdr.cb > ATSPKT_MAX_SIZE)
-    {
-        AssertMsgFailed(("Packet is %RU32 bytes, only %zu bytes allowed\n", Hdr.cb, ATSPKT_MAX_SIZE));
-        return VERR_BUFFER_OVERFLOW;
-    }
-
-    if (Hdr.cb > ATSPKT_MAX_SIZE)
-    {
-        AssertMsgFailed(("Packet is %RU32 bytes, only %zu bytes allowed\n", Hdr.cb, ATSPKT_MAX_SIZE));
-        return VERR_BUFFER_OVERFLOW;
-    }
-
-    pReply->cbPayload = Hdr.cb - sizeof(ATSPKTHDR);
-    Log3Func(("cbHdr=%zu, Hdr.szOp=%s, Hdr.cb=%RU32 -> %zu bytes payload\n", cbHdr, Hdr.achOpcode, Hdr.cb, pReply->cbPayload));
-    if (pReply->cbPayload)
-    {
-        pReply->pvPayload = RTMemAlloc(pReply->cbPayload);
-        if (pReply->pvPayload)
+        AssertReturn(pPktHdr->cb >= sizeof(ATSPKTHDR), VERR_NET_PROTOCOL_ERROR);
+        pReply->cbPayload = pPktHdr->cb - sizeof(ATSPKTHDR);
+        Log3Func(("szOp=%.8s, cb=%RU32\n", pPktHdr->achOpcode, pPktHdr->cb));
+        if (pReply->cbPayload)
         {
-            uint32_t cbPayloadRead = 0;
-            while (cbPayloadRead < pReply->cbPayload)
-            {
-                size_t cbRead = 0;
-                rc = RTTcpRead(pClient->hSock, (uint8_t *)pReply->pvPayload + cbPayloadRead, pReply->cbPayload - cbPayloadRead, &cbRead);
-                if (RT_SUCCESS(rc))
-                {
-                    if (!cbRead)
-                    {
-                        memcpy(&pClient->abHdr, &Hdr, sizeof(pClient->abHdr));
-                        if (!fNoDataOk)
-                            rc = VERR_NET_PROTOCOL_ERROR;
-                    }
-
-                    cbPayloadRead += (uint32_t)cbRead;
-                    Assert(cbPayloadRead <= pReply->cbPayload);
-                }
-            }
-
-            if (RT_SUCCESS(rc))
-            {
-                Assert(cbPayloadRead == pReply->cbPayload);
-                if (Hdr.uCrc32) /* Checksum given? */
-                {
-                    uint32_t uMyCrc32 = RTCrc32Start();
-                             uMyCrc32 = RTCrc32Process(uMyCrc32, Hdr.achOpcode, sizeof(Hdr.achOpcode));
-                             uMyCrc32 = RTCrc32Process(uMyCrc32, pReply->pvPayload, pReply->cbPayload);
-
-                    if (Hdr.uCrc32 != RTCrc32Finish(uMyCrc32))
-                        AssertFailedStmt(rc = VERR_TAR_CHKSUM_MISMATCH /** @todo Fudge! */);
-
-                    if (RT_SUCCESS(rc))
-                    {
-                        /* Make sure to align the payload data (if not done by the sender already). */
-                        size_t const cbRestAlignment = RT_ALIGN_Z(pReply->cbPayload, ATSPKT_ALIGNMENT) - pReply->cbPayload;
-                        if (cbRestAlignment)
-                        {
-                            uint8_t abAlignment[ATSPKT_ALIGNMENT];
-                            rc = RTTcpRead(pClient->hSock, abAlignment, RT_MIN(cbRestAlignment, sizeof(abAlignment)), NULL);
-                        }
-                    }
-                }
-            }
-
-            if (RT_FAILURE(rc))
-                audioTestSvcClientReplyDestroy(pReply);
+            pReply->pvPayload = RTMemDup((uint8_t *)pPktHdr + sizeof(ATSPKTHDR), pReply->cbPayload);
         }
         else
-            rc = VERR_NO_MEMORY;
+            pReply->pvPayload = NULL;
+
+        if (   !pReply->cbPayload
+            && !fNoDataOk)
+        {
+            rc = VERR_NET_PROTOCOL_ERROR;
+        }
+        else
+        {
+            memcpy(&pReply->szOp, &pPktHdr->achOpcode, sizeof(pReply->szOp));
+        }
+
+        RTMemFree(pPktHdr);
+        pPktHdr = NULL;
     }
-
-    if (RT_SUCCESS(rc))
-        memcpy(pReply->szOp, Hdr.achOpcode, sizeof(pReply->szOp));
 
     LogFlowFuncLeaveRC(rc);
@@ -232 +157 @@
 
 /**
- * Sends data over the transport to the server.
- * For now only TCP/IP is implemented.
- *
- * @returns VBox status code.
- * @param   pClient             Client to send data for.
- * @param   pvData              Pointer to data to send.
- * @param   cbData              Size (in bytes) of \a pvData to send.
- */
-static int audioTestSvcClientSend(PATSCLIENT pClient, const void *pvData, size_t cbData)
-{
-    return RTTcpWrite(pClient->hSock, pvData, cbData);
-}
-
-/**
  * Sends a message plus optional payload to an ATS server.
  *
@@ -252 +163 @@
  * @param   pvHdr               Pointer to header data to send.
  * @param   cbHdr               Size (in bytes) of \a pvHdr to send.
- * @param   pvPayload           Pointer to payload to send. Optional.
- * @param   cbPayload           Size (in bytes) of \a pvPayload to send. Set to 0 if no payload needed.
- */
-static int audioTestSvcClientSendMsg(PATSCLIENT pClient,
-                                     void *pvHdr, size_t cbHdr, const void *pvPayload, size_t cbPayload)
-{
-    int rc = audioTestSvcClientSend(pClient, pvHdr, cbHdr);
-    if (   RT_SUCCESS(rc)
-        && cbPayload)
-    {
-        rc = audioTestSvcClientSend(pClient, (uint8_t *)pvPayload, cbPayload);
-    }
-
-    return rc;
+ */
+static int audioTestSvcClientSendMsg(PATSCLIENT pClient, void *pvHdr, size_t cbHdr)
+{
+    RT_NOREF(cbHdr);
+    AssertPtrReturn(pClient->pTransport,       VERR_WRONG_ORDER);
+    AssertPtrReturn(pClient->pTransportInst,   VERR_WRONG_ORDER);
+    AssertPtrReturn(pClient->pTransportClient, VERR_NET_NOT_CONNECTED);
+    return pClient->pTransport->pfnSendPkt(pClient->pTransportInst, pClient->pTransportClient, (PCATSPKTHDR)pvHdr);
 }
 
@@ -304 +209 @@
     audioTestSvcClientReqHdrInit(&Req, sizeof(Req), "ACK     ", 0);
 
-    return audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req), NULL, 0);
+    return audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req));
 }
 
@@ -318 +223 @@
     Req.uVersion = ATS_PROTOCOL_VS;
     audioTestSvcClientReqHdrInit(&Req.Hdr, sizeof(Req), ATSPKT_OPCODE_HOWDY, 0);
-    int rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req), NULL, 0);
+    int rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req));
     if (RT_SUCCESS(rc))
         rc = audioTestSvcClientRecvAck(pClient);
@@ -325 +230 @@
 
 /**
- * Sends a disconnect command to an ATS server.
- *
- * @returns VBox status code.
- * @param   pClient             Client to send command for.
- */
-static int audioTestSvcClientDoBye(PATSCLIENT pClient)
-{
-    ATSPKTHDR Hdr;
-    audioTestSvcClientReqHdrInit(&Hdr, sizeof(Hdr), ATSPKT_OPCODE_BYE, 0);
-    int rc = audioTestSvcClientSendMsg(pClient, &Hdr, sizeof(Hdr), NULL, 0);
-    if (RT_SUCCESS(rc))
-        rc = audioTestSvcClientRecvAck(pClient);
-
-    return rc;
-}
-
-/**
- * Connects to an ATS server.
+ * Creates an ATS client.
+ *
+ * @returns VBox status code.
+ * @param   pClient             Client to create.
+ */
+int AudioTestSvcClientCreate(PATSCLIENT pClient)
+{
+    audioTestSvcClientInit(pClient);
+
+    /*
+     * The default transporter is the first one.
+     */
+    pClient->pTransport = g_apTransports[0]; /** @todo Make this dynamic. */
+
+    return pClient->pTransport->pfnCreate(&pClient->pTransportInst);
+}
+
+/**
+ * Destroys an ATS client.
+ *
+ * @returns VBox status code.
+ * @param   pClient             Client to destroy.
+ */
+void AudioTestSvcClientDestroy(PATSCLIENT pClient)
+{
+    if (pClient->pTransport)
+        pClient->pTransport->pfnTerm(pClient->pTransportInst);
+}
+
+/**
+ * Handles a command line option.
+ *
+ * @returns VBox status code.
+ * @param   pClient             Client to handle option for.
+ * @param   ch                  Option (short) to handle.
+ * @param   pVal                Option union to store the result in on success.
+ */
+int AudioTestSvcClientHandleOption(PATSCLIENT pClient, int ch, PCRTGETOPTUNION pVal)
+{
+    AssertPtrReturn(pClient->pTransport, VERR_WRONG_ORDER); /* Must be created first via AudioTestSvcClientCreate(). */
+    if (!pClient->pTransport->pfnOption)
+        return VERR_GETOPT_UNKNOWN_OPTION;
+    return pClient->pTransport->pfnOption(pClient->pTransportInst, ch, pVal);
+}
+
+/**
+ * Connects to an ATS peer.
  *
  * @returns VBox status code.
  * @param   pClient             Client to connect.
- * @param   pszAddr             Address to connect to. If NULL, 127.0.0.1 (localhost) will be used.
- * @param   uPort               Port to connect. If set to 0, port 6052 (ATS_DEFAULT_PORT) will be used.
- */
-int AudioTestSvcClientConnect(PATSCLIENT pClient, const char *pszAddr, uint32_t uPort)
-{
-    audioTestSvcClientInit(pClient);
-
-    int rc = RTTcpClientConnect(pszAddr ? pszAddr : ATS_TCP_HOST_DEFAULT_ADDR_STR, uPort == 0 ? ATS_TCP_HOST_DEFAULT_PORT : uPort, &pClient->hSock);
+ */
+int AudioTestSvcClientConnect(PATSCLIENT pClient)
+{
+    int rc = pClient->pTransport->pfnStart(pClient->pTransportInst);
     if (RT_SUCCESS(rc))
     {
-        rc = audioTestSvcClientDoGreet(pClient);
+        rc = pClient->pTransport->pfnWaitForConnect(pClient->pTransportInst, &pClient->pTransportClient);
+        if (RT_SUCCESS(rc))
+        {
+            rc = audioTestSvcClientDoGreet(pClient);
+        }
     }
 
@@ -378 +312 @@
     audioTestSvcClientReqHdrInit(&Req.Hdr, sizeof(Req), ATSPKT_OPCODE_TESTSET_BEGIN, 0);
 
-    rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req), NULL, 0);
+    rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req));
     if (RT_SUCCESS(rc))
         rc = audioTestSvcClientRecvAck(pClient);
@@ -401 +335 @@
     audioTestSvcClientReqHdrInit(&Req.Hdr, sizeof(Req), ATSPKT_OPCODE_TESTSET_END, 0);
 
-    rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req), NULL, 0);
+    rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req));
     if (RT_SUCCESS(rc))
         rc = audioTestSvcClientRecvAck(pClient);
@@ -424 +358 @@
     audioTestSvcClientReqHdrInit(&Req.Hdr, sizeof(Req), ATSPKT_OPCODE_TONE_PLAY, 0);
 
-    int rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req), NULL, 0);
+    int rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req));
     if (RT_SUCCESS(rc))
         rc = audioTestSvcClientRecvAck(pClient);
@@ -447 +381 @@
     audioTestSvcClientReqHdrInit(&Req.Hdr, sizeof(Req), ATSPKT_OPCODE_TONE_RECORD, 0);
 
-    int rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req), NULL, 0);
+    int rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req));
     if (RT_SUCCESS(rc))
         rc = audioTestSvcClientRecvAck(pClient);
@@ -476 +410 @@
     AssertRCReturn(rc, rc);
 
-    rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req), NULL, 0);
+    rc = audioTestSvcClientSendMsg(pClient, &Req, sizeof(Req));
     while (RT_SUCCESS(rc))
     {
         ATSSRVREPLY Reply;
         RT_ZERO(Reply);
+
         rc = audioTestSvcClientRecvReply(pClient, &Reply, false /* fNoDataOk */);
         if (RT_SUCCESS(rc))
         {
-            /* Calculate and validate checksum. */
-            uint32_t uDataCrc32;
-            memcpy(&uDataCrc32, Reply.pvPayload, sizeof(uint32_t));
-
-            if (   uDataCrc32
-                && uDataCrc32 != RTCrc32((uint8_t *)Reply.pvPayload + 4, Reply.cbPayload - 4))
-                rc = VERR_TAR_CHKSUM_MISMATCH; /** @todo Fudge! */
+            /* Extract received CRC32 checksum. */
+            const size_t cbCrc32 = sizeof(uint32_t); /* Skip CRC32 in payload for actual CRC verification. */
+
+            uint32_t uSrcCrc32;
+            memcpy(&uSrcCrc32, Reply.pvPayload, cbCrc32);
+
+            if (uSrcCrc32)
+            {
+                const uint32_t uDstCrc32 = RTCrc32((uint8_t *)Reply.pvPayload + cbCrc32, Reply.cbPayload - cbCrc32);
+
+                Log2Func(("uSrcCrc32=%#x, cbRead=%zu -> uDstCrc32=%#x\n"
+                          "%.*Rhxd\n",
+                          uSrcCrc32, Reply.cbPayload - cbCrc32, uDstCrc32,
+                          RT_MIN(64, Reply.cbPayload - cbCrc32), (uint8_t *)Reply.pvPayload + cbCrc32));
+
+                if (uSrcCrc32 != uDstCrc32)
+                    rc = VERR_TAR_CHKSUM_MISMATCH; /** @todo Fudge! */
+            }
 
             if (RT_SUCCESS(rc))
@@ -498 +444 @@
                     && Reply.cbPayload)
                 {
-                    rc = RTFileWrite(hFile, (uint8_t *)Reply.pvPayload + 4, Reply.cbPayload - 4, NULL);
+                    rc = RTFileWrite(hFile, (uint8_t *)Reply.pvPayload + cbCrc32, Reply.cbPayload - cbCrc32, NULL);
                 }
                 else if (RTStrNCmp(Reply.szOp, "DATA EOF", ATSPKT_OPCODE_MAX_LEN) == 0)
@@ -537 +483 @@
 int AudioTestSvcClientClose(PATSCLIENT pClient)
 {
-    int rc = audioTestSvcClientDoBye(pClient);
-    if (RT_SUCCESS(rc))
-        rc = RTTcpClientClose(pClient->hSock);
-
-    return rc;
-}
-
+    pClient->pTransport->pfnNotifyBye(pClient->pTransportInst, pClient->pTransportClient);
+
+    return VINF_SUCCESS;
+}
+

trunk/src/VBox/Devices/Audio/AudioTestServiceClient.h

@@ -22 +22 @@
 #endif
 
+#include "AudioTestServiceInternal.h"
+
+/**
+ * Structure for maintaining an ATS client.
+ */
 typedef struct ATSCLIENT
 {
-    uint8_t  abHdr[16];
-    uint16_t cbHdr;
-    RTSOCKET hSock;
+    /** Pointer to the selected transport layer. */
+    PCATSTRANSPORT      pTransport;
+    /** Pointer to the selected transport instance to use. */
+    PATSTRANSPORTINST   pTransportInst;
+    /** The opaque client instance. */
+    PATSTRANSPORTCLIENT pTransportClient;
 } ATSCLIENT;
+/** Pointer to an ATS client. */
 typedef ATSCLIENT *PATSCLIENT;
 
-int AudioTestSvcClientConnect(PATSCLIENT pClient, const char *pszAddr, uint32_t uPort);
+int AudioTestSvcClientCreate(PATSCLIENT pClient);
+void AudioTestSvcClientDestroy(PATSCLIENT pClient);
+int AudioTestSvcClientConnect(PATSCLIENT pClient);
+int AudioTestSvcClientHandleOption(PATSCLIENT pClient, int ch, PCRTGETOPTUNION pVal);
 int AudioTestSvcClientTestSetBegin(PATSCLIENT pClient, const char *pszTag);
 int AudioTestSvcClientTestSetEnd(PATSCLIENT pClient, const char *pszTag);

trunk/src/VBox/Devices/Audio/AudioTestServiceInternal.h

@@ -46 +46 @@
     /** The description. */
     const char     *pszDesc;
-
-    /**
-     * Initializes the transport layer.
+    /** Pointer to an array of options. */
+    PCRTGETOPTDEF   paOpts;
+    /** The number of options in the array. */
+    size_t          cOpts;
+
+    /**
+     * Print the usage information for this transport layer.
+     *
+     * @param   pStream             The stream to print the usage info to.
+     *
+     * @remarks This is only required if TXSTRANSPORT::cOpts is greater than 0.
+     */
+    DECLR3CALLBACKMEMBER(void, pfnUsage,(PRTSTREAM pStream));
+
+    /**
+     * Creates a transport instance.
      *
      * @returns IPRT status code.  On errors, the transport layer shall call
      *          RTMsgError to display the error details to the user.
-     * @param   pThis               The transport instance.
-     * @param   pszBindAddr         Bind address. Empty means any address.
-     * @param   uBindPort           Bind port. If set to 0, ATS_DEFAULT_PORT is being used.
-     */
-    DECLR3CALLBACKMEMBER(int, pfnInit, (PATSTRANSPORTINST pThis, const char *pszBindAddr, uint32_t uBindPort));
-
-    /**
-     * Terminate the transport layer, closing and freeing resources.
+     * @param   ppThis              Where to return the created transport instance on success.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnCreate, (PPATSTRANSPORTINST ppThis));
+
+    /**
+     * Destroys a transport instance.
+     *
+     * On errors, the transport layer shall call RTMsgError to display the error
+     * details to the user.
+     *
+     * @returns IPRT status code.  On errors, the transport layer shall call
+     *          RTMsgError to display the error details to the user.
+     * @param   pThis               The transport instance.
+     *                              The pointer will be invalid on return.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnDestroy, (PATSTRANSPORTINST pThis));
+
+    /**
+     * Handle an option.
+     *
+     * When encountering an options that is not part of the base options, we'll call
+     * this method for each transport layer until one handles it.
+     *
+     * @retval  VINF_SUCCESS if handled.
+     * @retval  VERR_TRY_AGAIN if not handled.
+     * @retval  VERR_INVALID_PARAMETER if we should exit with a non-zero status.
+     *
+     * @param   pThis               Transport instance to set options for.
+     * @param   ch                  The short option value.
+     * @param   pVal                Pointer to the value union.
+     *
+     * @remarks This is only required if TXSTRANSPORT::cOpts is greater than 0.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnOption,(PATSTRANSPORTINST pThis, int ch, PCRTGETOPTUNION pVal));
+
+    /**
+     * Starts a transport instance.
+     *
+     * @returns IPRT status code.  On errors, the transport layer shall call
+     *          RTMsgError to display the error details to the user.
+     * @param   pThis               Transport instance to initialize.
+     */
+    DECLR3CALLBACKMEMBER(int, pfnStart, (PATSTRANSPORTINST pThis));
+
+    /**
+     * Terminate a transport instance, closing and freeing resources.
      *
      * On errors, the transport layer shall call RTMsgError to display the error

trunk/src/VBox/Devices/Audio/AudioTestServiceTcp.cpp

@@ -20 +20 @@
 *   Header Files                                                                                                                 *
 *********************************************************************************************************************************/
-#define LOG_GROUP RTLOGGROUP_DEFAULT
+#define LOG_GROUP LOG_GROUP_DRV_HOST_AUDIO /** @todo Add an own log group for this? */
 #include <iprt/asm.h>
 #include <iprt/assert.h>
@@ -34 +34 @@
 #include <iprt/time.h>
 
+#include <VBox/log.h>
+
 #include "AudioTestService.h"
 #include "AudioTestServiceInternal.h"
@@ -46 +48 @@
 *   Structures and Typedefs                                                                                                      *
 *********************************************************************************************************************************/
-
 /**
  * TCP specific client data.
@@ -53 +54 @@
 {
     /** Socket of the current client. */
-    RTSOCKET             hTcpClient;
+    RTSOCKET                           hTcpClient;
+    /** Indicates whether \a hTcpClient comes from the server or from a client
+     * connect (relevant when closing it). */
+    bool                               fFromServer;
     /** The size of the stashed data. */
-    size_t               cbTcpStashed;
+    size_t                             cbTcpStashed;
     /** The size of the stashed data allocation. */
-    size_t               cbTcpStashedAlloced;
+    size_t                             cbTcpStashedAlloced;
     /** The stashed data. */
-    uint8_t             *pbTcpStashed;
+    uint8_t                           *pbTcpStashed;
 } ATSTRANSPORTCLIENT;
+
+/**
+ * Enumeration for the TCP/IP connection mode.
+ */
+typedef enum ATSTCPMODE
+{
+    /** Both: Uses parallel client and server connection methods (via threads). */
+    ATSTCPMODE_BOTH = 0,
+    /** Client only: Connects to a server. */
+    ATSTCPMODE_CLIENT,
+    /** Server only: Listens for new incoming client connections. */
+    ATSTCPMODE_SERVER
+} ATSTCPMODE;
+
+/**
+ * Structure for keeping Audio Test Service (ATS) transport instance-specific data.
+ */
+typedef struct ATSTRANSPORTINST
+{
+    /** Critical section for serializing access. */
+    RTCRITSECT                         CritSect;
+    /** Connection mode to use. */
+    ATSTCPMODE                         enmMode;
+    /** The addresses to bind to.  Empty string means any. */
+    char                               szBindAddr[256];
+    /** The TCP port to listen to. */
+    uint32_t                           uBindPort;
+    /** The addresses to connect to if running in reversed (VM NATed) mode. */
+    char                               szConnectAddr[256];
+    /** The TCP port to connect to if running in reversed (VM NATed) mode. */
+    uint32_t                           uConnectPort;
+    /** Pointer to the TCP server instance. */
+    PRTTCPSERVER                       pTcpServer;
+    /** Thread calling RTTcpServerListen2. */
+    RTTHREAD                           hThreadServer;
+    /** Thread calling RTTcpClientConnect. */
+    RTTHREAD                           hThreadConnect;
+    /** The main thread handle (for signalling). */
+    RTTHREAD                           hThreadMain;
+    /** Stop connecting attempts when set. */
+    bool                               fStopConnecting;
+    /** Connect cancel cookie. */
+    PRTTCPCLIENTCONNECTCANCEL volatile pConnectCancelCookie;
+} ATSTRANSPORTINST;
+/** Pointer to an Audio Test Service (ATS) TCP/IP transport instance. */
+typedef ATSTRANSPORTINST *PATSTRANSPORTINST;
+
+/**
+ * Structure holding an ATS connection context, which is
+ * required when connecting a client via server (listening) or client (connecting).
+ */
+typedef struct ATSCONNCTX
+{
+    /** Pointer to transport instance to use. */
+    PATSTRANSPORTINST                  pInst;
+    /** Pointer to transport client to connect. */
+    PATSTRANSPORTCLIENT                pClient;
+} ATSCONNCTX;
+/** Pointer to an Audio Test Service (ATS) TCP/IP connection context. */
+typedef ATSCONNCTX *PATSCONNCTX;
 
 
@@ -76 +140 @@
     if (pClient->hTcpClient != NIL_RTSOCKET)
     {
-        int rc = RTTcpServerDisconnectClient2(pClient->hTcpClient);
+        int rc;
+        if (pClient->fFromServer)
+            rc = RTTcpServerDisconnectClient2(pClient->hTcpClient);
+        else
+            rc = RTTcpClientClose(pClient->hTcpClient);
         pClient->hTcpClient = NIL_RTSOCKET;
         AssertRCSuccess(rc);
@@ -89 +157 @@
 
 /**
+ * Sets the current client socket in a safe manner.
+ *
+ * @returns NIL_RTSOCKET if consumed, other wise hTcpClient.
+ * @param   pThis           Transport instance.
+ * @param   pClient         Client to set the socket for.
+ * @param   fFromServer     Whether the socket is from a server (listening) or client (connecting) call.
+ *                          Important when closing / disconnecting.
+ * @param   hTcpClient      The client socket.
+ */
+static RTSOCKET atsTcpSetClient(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, bool fFromServer, RTSOCKET hTcpClient)
+{
+    RTCritSectEnter(&pThis->CritSect);
+    if (   pClient->hTcpClient  == NIL_RTSOCKET
+        && !pThis->fStopConnecting)
+    {
+        LogFunc(("New client connected\n"));
+
+        pClient->fFromServer = fFromServer;
+        pClient->hTcpClient = hTcpClient;
+        hTcpClient = NIL_RTSOCKET; /* Invalidate, as pClient has now ownership. */
+    }
+    RTCritSectLeave(&pThis->CritSect);
+    return hTcpClient;
+}
+
+/**
+ * Checks if it's a fatal RTTcpClientConnect return code.
+ *
+ * @returns true / false.
+ * @param   rc              The IPRT status code.
+ */
+static bool atsTcpIsFatalClientConnectStatus(int rc)
+{
+    return rc != VERR_NET_UNREACHABLE
+        && rc != VERR_NET_HOST_DOWN
+        && rc != VERR_NET_HOST_UNREACHABLE
+        && rc != VERR_NET_CONNECTION_REFUSED
+        && rc != VERR_TIMEOUT
+        && rc != VERR_NET_CONNECTION_TIMED_OUT;
+}
+
+/**
+ * Server mode connection thread.
+ *
+ * @returns iprt status code.
+ * @param   hSelf           Thread handle. Ignored.
+ * @param   pvUser          Pointer to ATSTRANSPORTINST the thread is bound to.
+ */
+static DECLCALLBACK(int) atsTcpServerConnectThread(RTTHREAD hSelf, void *pvUser)
+{
+    RT_NOREF(hSelf);
+
+    PATSCONNCTX         pConnCtx = (PATSCONNCTX)pvUser;
+    PATSTRANSPORTINST   pThis    = pConnCtx->pInst;
+    PATSTRANSPORTCLIENT pClient  = pConnCtx->pClient;
+
+    RTSOCKET hTcpClient;
+    int rc = RTTcpServerListen2(pThis->pTcpServer, &hTcpClient);
+    if (RT_SUCCESS(rc))
+    {
+        hTcpClient = atsTcpSetClient(pThis, pClient, true /* fFromServer */, hTcpClient);
+        RTTcpServerDisconnectClient2(hTcpClient);
+    }
+
+    return rc;
+}
+
+/**
+ * Client mode connection thread.
+ *
+ * @returns iprt status code.
+ * @param   hSelf           Thread handle. Use to sleep on. The main thread will
+ *                          signal it to speed up thread shutdown.
+ * @param   pvUser          Pointer to a connection context (PATSCONNCTX) the thread is bound to.
+ */
+static DECLCALLBACK(int) atsTcpClientConnectThread(RTTHREAD hSelf, void *pvUser)
+{
+    PATSCONNCTX         pConnCtx = (PATSCONNCTX)pvUser;
+    PATSTRANSPORTINST   pThis    = pConnCtx->pInst;
+    PATSTRANSPORTCLIENT pClient  = pConnCtx->pClient;
+
+    for (;;)
+    {
+        /* Stop? */
+        RTCritSectEnter(&pThis->CritSect);
+        bool fStop = pThis->fStopConnecting;
+        RTCritSectLeave(&pThis->CritSect);
+        if (fStop)
+            return VINF_SUCCESS;
+
+        /* Try connect. */ /** @todo make cancelable! */
+        RTSOCKET hTcpClient;
+        int rc = RTTcpClientConnectEx(pThis->szConnectAddr, pThis->uConnectPort, &hTcpClient,
+                                      RT_SOCKETCONNECT_DEFAULT_WAIT, &pThis->pConnectCancelCookie);
+        if (RT_SUCCESS(rc))
+        {
+            hTcpClient = atsTcpSetClient(pThis, pClient, false /* fFromServer */, hTcpClient);
+            RTTcpClientCloseEx(hTcpClient, true /* fGracefulShutdown*/);
+            break;
+        }
+
+        if (atsTcpIsFatalClientConnectStatus(rc))
+            return rc;
+
+        /* Delay a wee bit before retrying. */
+        RTThreadUserWait(hSelf, 1536);
+    }
+    return VINF_SUCCESS;
+}
+
+/**
+ * Wait on the threads to complete.
+ *
+ * @returns Thread status (if collected), otherwise VINF_SUCCESS.
+ * @param   pThis           Transport instance.
+ * @param   cMillies        The period to wait on each thread.
+ */
+static int atsTcpConnectWaitOnThreads(PATSTRANSPORTINST pThis, RTMSINTERVAL cMillies)
+{
+    int rcRet = VINF_SUCCESS;
+
+    if (pThis->hThreadConnect != NIL_RTTHREAD)
+    {
+        int rcThread;
+        int rc2 = RTThreadWait(pThis->hThreadConnect, cMillies, &rcThread);
+        if (RT_SUCCESS(rc2))
+        {
+            pThis->hThreadConnect = NIL_RTTHREAD;
+            rcRet = rcThread;
+        }
+    }
+
+    if (pThis->hThreadServer != NIL_RTTHREAD)
+    {
+        int rcThread;
+        int rc2 = RTThreadWait(pThis->hThreadServer, cMillies, &rcThread);
+        if (RT_SUCCESS(rc2))
+        {
+            pThis->hThreadServer = NIL_RTTHREAD;
+            if (RT_SUCCESS(rc2))
+                rcRet = rcThread;
+        }
+    }
+    return rcRet;
+}
+
+/**
  * @interface_method_impl{ATSTRANSPORT,pfnWaitForConnect}
  */
 static DECLCALLBACK(int) atsTcpWaitForConnect(PATSTRANSPORTINST pThis, PPATSTRANSPORTCLIENT ppClientNew)
 {
+    PATSTRANSPORTCLIENT pClient = (PATSTRANSPORTCLIENT)RTMemAllocZ(sizeof(ATSTRANSPORTCLIENT));
+    AssertPtrReturn(pClient, VERR_NO_MEMORY);
+
     int rc;
-    RTSOCKET hClientNew;
-
-    rc = RTTcpServerListen2(pThis->pTcpServer, &hClientNew);
-    Log(("atsTcpWaitForConnect: RTTcpServerListen2 -> %Rrc\n", rc));
+
+    if (pThis->enmMode == ATSTCPMODE_SERVER)
+    {
+        pClient->fFromServer = true;
+        rc = RTTcpServerListen2(pThis->pTcpServer, &pClient->hTcpClient);
+        LogFunc(("RTTcpServerListen2 -> %Rrc\n", rc));
+    }
+    else if (pThis->enmMode == ATSTCPMODE_CLIENT)
+    {
+        pClient->fFromServer = false;
+        for (;;)
+        {
+            Log2Func(("Calling RTTcpClientConnect(%s, %u,)...\n", pThis->szConnectAddr, pThis->uConnectPort));
+            rc = RTTcpClientConnect(pThis->szConnectAddr, pThis->uConnectPort, &pClient->hTcpClient);
+            LogFunc(("RTTcpClientConnect -> %Rrc\n", rc));
+            if (RT_SUCCESS(rc) || atsTcpIsFatalClientConnectStatus(rc))
+                break;
+
+            /* Delay a wee bit before retrying. */
+            RTThreadSleep(1536);
+        }
+    }
+    else
+    {
+        Assert(pThis->enmMode == ATSTCPMODE_BOTH);
+
+        /*
+         * Create client threads.
+         */
+        RTCritSectEnter(&pThis->CritSect);
+
+        pThis->fStopConnecting = false;
+        RTCritSectLeave(&pThis->CritSect);
+
+        atsTcpConnectWaitOnThreads(pThis, 32 /* cMillies */);
+
+        ATSCONNCTX ConnCtx;
+        RT_ZERO(ConnCtx);
+        ConnCtx.pInst   = pThis;
+        ConnCtx.pClient = pClient;
+
+        rc = VINF_SUCCESS;
+        if (pThis->hThreadConnect == NIL_RTTHREAD)
+        {
+            pThis->pConnectCancelCookie = NULL;
+            rc = RTThreadCreate(&pThis->hThreadConnect, atsTcpClientConnectThread, &ConnCtx, 0, RTTHREADTYPE_DEFAULT,
+                                RTTHREADFLAGS_WAITABLE, "tcpconn");
+        }
+        if (pThis->hThreadServer == NIL_RTTHREAD && RT_SUCCESS(rc))
+            rc = RTThreadCreate(&pThis->hThreadServer, atsTcpServerConnectThread, &ConnCtx, 0, RTTHREADTYPE_DEFAULT,
+                                RTTHREADFLAGS_WAITABLE, "tcpserv");
+
+        RTCritSectEnter(&pThis->CritSect);
+
+        /*
+         * Wait for connection to be established.
+         */
+        while (   RT_SUCCESS(rc)
+               && pClient->hTcpClient == NIL_RTSOCKET)
+        {
+            RTCritSectLeave(&pThis->CritSect);
+            rc = atsTcpConnectWaitOnThreads(pThis, 10 /* cMillies */);
+            RTCritSectEnter(&pThis->CritSect);
+        }
+
+        /*
+         * Cancel the threads.
+         */
+        pThis->fStopConnecting = true;
+
+        RTCritSectLeave(&pThis->CritSect);
+        RTTcpClientCancelConnect(&pThis->pConnectCancelCookie);
+    }
 
     if (RT_SUCCESS(rc))
     {
-        PATSTRANSPORTCLIENT pClient = (PATSTRANSPORTCLIENT)RTMemAllocZ(sizeof(ATSTRANSPORTCLIENT));
-        if (RT_LIKELY(pClient))
-        {
-            pClient->hTcpClient          = hClientNew;
-            pClient->cbTcpStashed        = 0;
-            pClient->cbTcpStashedAlloced = 0;
-            pClient->pbTcpStashed        = NULL;
-            *ppClientNew = pClient;
-        }
-        else
-        {
-            RTTcpServerDisconnectClient2(hClientNew);
-            rc = VERR_NO_MEMORY;
+        *ppClientNew = pClient;
+    }
+    else
+    {
+        if (pClient)
+        {
+            RTTcpServerDisconnectClient2(pClient->hTcpClient);
+
+            RTMemFree(pClient);
+            pClient = NULL;
         }
     }
@@ -125 +409 @@
 static DECLCALLBACK(void) atsTcpNotifyReboot(PATSTRANSPORTINST pThis)
 {
-    Log(("atsTcpNotifyReboot: RTTcpServerDestroy(%p)\n", pThis->pTcpServer));
+    LogFunc(("RTTcpServerDestroy(%p)\n", pThis->pTcpServer));
     if (pThis->pTcpServer)
     {
@@ -140 +424 @@
 static DECLCALLBACK(void) atsTcpNotifyBye(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient)
 {
-    Log(("atsTcpNotifyBye: atsTcpDisconnectClient %RTsock\n", pClient->hTcpClient));
+    LogFunc(("atsTcpDisconnectClient %RTsock\n", pClient->hTcpClient));
     atsTcpDisconnectClient(pThis, pClient);
     RTMemFree(pClient);
@@ -171 +455 @@
      * Disconnect the client.
      */
-    Log(("atsTcpBabble: atsTcpDisconnectClient(%RTsock) (RTTcpWrite rc=%Rrc)\n", pClient->hTcpClient, rc));
+    LogFunc(("atsTcpDisconnectClient(%RTsock) (RTTcpWrite rc=%Rrc)\n", pClient->hTcpClient, rc));
     atsTcpDisconnectClient(pThis, pClient);
 }
@@ -180 +464 @@
 static DECLCALLBACK(int) atsTcpSendPkt(PATSTRANSPORTINST pThis, PATSTRANSPORTCLIENT pClient, PCATSPKTHDR pPktHdr)
 {
-    Assert(pPktHdr->cb >= sizeof(ATSPKTHDR));
+    AssertReturn(pPktHdr->cb >= sizeof(ATSPKTHDR), VERR_INVALID_PARAMETER);
 
     /*
@@ -186 +470 @@
      */
     size_t cbToSend = RT_ALIGN_Z(pPktHdr->cb, ATSPKT_ALIGNMENT);
-    LogFlowFunc(("%RU32 -> %zu\n", pPktHdr->cb, cbToSend));
+
+    Log3Func(("%RU32 -> %zu\n", pPktHdr->cb, cbToSend));
+
+    Log3Func(("Header:\n"
+              "%.*Rhxd\n", RT_MIN(sizeof(ATSPKTHDR), cbToSend), pPktHdr));
+
+    if (cbToSend > sizeof(ATSPKTHDR))
+        Log3Func(("Payload:\n"
+                  "%.*Rhxd\n",
+                  RT_MIN(64, cbToSend - sizeof(ATSPKTHDR)), (uint8_t *)pPktHdr + sizeof(ATSPKTHDR)));
+
     int rc = RTTcpWrite(pClient->hTcpClient, pPktHdr, cbToSend);
     if (    RT_FAILURE(rc)
@@ -192 +486 @@
     {
         /* assume fatal connection error. */
-        Log(("RTTcpWrite -> %Rrc -> atsTcpDisconnectClient(%RTsock)\n", rc, pClient->hTcpClient));
+        LogFunc(("RTTcpWrite -> %Rrc -> atsTcpDisconnectClient(%RTsock)\n", rc, pClient->hTcpClient));
         atsTcpDisconnectClient(pThis, pClient);
     }
@@ -237 +531 @@
 
     /*
-     * Read and valid the length.
+     * Read and validate the length.
      */
     while (offData < sizeof(uint32_t))
@@ -247 +541 @@
         if (cbRead == 0)
         {
-            Log(("atsTcpRecvPkt: RTTcpRead -> %Rrc / cbRead=0 -> VERR_NET_NOT_CONNECTED (#1)\n", rc));
+            LogFunc(("RTTcpRead -> %Rrc / cbRead=0 -> VERR_NET_NOT_CONNECTED (#1)\n", rc));
             rc = VERR_NET_NOT_CONNECTED;
             break;
@@ -287 +581 @@
                     if (cbRead == 0)
                     {
-                        Log(("atsTcpRecvPkt: RTTcpRead -> %Rrc / cbRead=0 -> VERR_NET_NOT_CONNECTED (#2)\n", rc));
+                        LogFunc(("RTTcpRead -> %Rrc / cbRead=0 -> VERR_NET_NOT_CONNECTED (#2)\n", rc));
                         rc = VERR_NET_NOT_CONNECTED;
                         break;
                     }
+
                     offData += cbRead;
                 }
+
+                Log3Func(("Header:\n"
+                          "%.*Rhxd\n", sizeof(ATSPKTHDR), pbData));
+
+                if (   RT_SUCCESS(rc)
+                    && cbData > sizeof(ATSPKTHDR))
+                    Log3Func(("Payload:\n"
+                              "%.*Rhxd\n", RT_MIN(64, cbData - sizeof(ATSPKTHDR)), (uint8_t *)pbData + sizeof(ATSPKTHDR)));
             }
         }
@@ -317 +620 @@
 
             /* assume fatal connection error. */
-            Log(("atsTcpRecvPkt: RTTcpRead -> %Rrc -> atsTcpDisconnectClient(%RTsock)\n", rc, pClient->hTcpClient));
+            LogFunc(("RTTcpRead -> %Rrc -> atsTcpDisconnectClient(%RTsock)\n", rc, pClient->hTcpClient));
             atsTcpDisconnectClient(pThis, pClient);
         }
@@ -358 +661 @@
 static DECLCALLBACK(void) atsTcpTerm(PATSTRANSPORTINST pThis)
 {
+    /* Signal thread */
+    if (RTCritSectIsInitialized(&pThis->CritSect))
+    {
+        RTCritSectEnter(&pThis->CritSect);
+        pThis->fStopConnecting = true;
+        RTCritSectLeave(&pThis->CritSect);
+    }
+
+    if (pThis->hThreadConnect != NIL_RTTHREAD)
+    {
+        RTThreadUserSignal(pThis->hThreadConnect);
+        RTTcpClientCancelConnect(&pThis->pConnectCancelCookie);
+    }
+
     /* Shut down the server (will wake up thread). */
     if (pThis->pTcpServer)
     {
-        Log(("atsTcpTerm: Destroying server...\n"));
+        LogFunc(("Destroying server...\n"));
         int rc = RTTcpServerDestroy(pThis->pTcpServer);
         if (RT_FAILURE(rc))
@@ -368 +685 @@
     }
 
-    Log(("atsTcpTerm: done\n"));
-}
-
-/**
- * @interface_method_impl{ATSTRANSPORT,pfnInit}
- */
-static DECLCALLBACK(int) atsTcpInit(PATSTRANSPORTINST pThis, const char *pszBindAddr, uint32_t uBindPort)
-{
-    int rc = RTTcpServerCreateEx(pszBindAddr[0] ? pszBindAddr : NULL, uBindPort, &pThis->pTcpServer);
-    if (RT_FAILURE(rc))
-    {
-        if (rc == VERR_NET_DOWN)
-        {
-            RTMsgInfo("RTTcpServerCreateEx(%s, %u,) failed: %Rrc, retrying for 20 seconds...\n",
-                      pszBindAddr[0] ? pszBindAddr : NULL, uBindPort, rc);
-            uint64_t StartMs = RTTimeMilliTS();
-            do
+    /* Wait for the thread (they should've had some time to quit by now). */
+    atsTcpConnectWaitOnThreads(pThis, 15000);
+
+    /* Finally, clean up the critical section. */
+    if (RTCritSectIsInitialized(&pThis->CritSect))
+        RTCritSectDelete(&pThis->CritSect);
+
+    LogFunc(("Done\n"));
+}
+
+/**
+ * @interface_method_impl{ATSTRANSPORT,pfnCreate}
+ */
+static DECLCALLBACK(int) atsTcpCreate(PATSTRANSPORTINST *ppThis)
+{
+    PATSTRANSPORTINST pThis = (PATSTRANSPORTINST)RTMemAllocZ(sizeof(ATSTRANSPORTINST));
+    AssertPtrReturn(pThis, VERR_NO_MEMORY);
+
+    *ppThis = pThis;
+    return VINF_SUCCESS;
+}
+
+/**
+ * @interface_method_impl{ATSTRANSPORT,pfnDestroy}
+ */
+static DECLCALLBACK(int) atsTcpDestroy(PATSTRANSPORTINST pThis)
+{
+    /** @todo Anything else to do here? */
+    RTMemFree(pThis);
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * @interface_method_impl{ATSTRANSPORT,pfnStart}
+ */
+static DECLCALLBACK(int) atsTcpStart(PATSTRANSPORTINST pThis)
+{
+    int rc = RTCritSectInit(&pThis->CritSect);
+    if (RT_SUCCESS(rc) && pThis->enmMode != ATSTCPMODE_CLIENT)
+    {
+        rc = RTTcpServerCreateEx(pThis->szBindAddr[0] ? pThis->szBindAddr : NULL, pThis->uBindPort, &pThis->pTcpServer);
+        if (RT_FAILURE(rc))
+        {
+            if (rc == VERR_NET_DOWN)
             {
-                RTThreadSleep(1000);
-                rc = RTTcpServerCreateEx(pszBindAddr[0] ? pszBindAddr : NULL, uBindPort, &pThis->pTcpServer);
-            } while (   rc == VERR_NET_DOWN
-                     && RTTimeMilliTS() - StartMs < 20000);
-            if (RT_SUCCESS(rc))
-                RTMsgInfo("RTTcpServerCreateEx succceeded.\n");
-        }
-        if (RT_FAILURE(rc))
-        {
-            pThis->pTcpServer = NULL;
-            RTMsgError("RTTcpServerCreateEx(%s, %u,) failed: %Rrc\n",
-                       pszBindAddr[0] ? pszBindAddr : NULL, uBindPort, rc);
+                RTMsgInfo("RTTcpServerCreateEx(%s, %u,) failed: %Rrc, retrying for 20 seconds...\n",
+                          pThis->szBindAddr[0] ? pThis->szBindAddr : NULL, pThis->uBindPort, rc);
+                uint64_t StartMs = RTTimeMilliTS();
+                do
+                {
+                    RTThreadSleep(1000);
+                    rc = RTTcpServerCreateEx(pThis->szBindAddr[0] ? pThis->szBindAddr : NULL, pThis->uBindPort, &pThis->pTcpServer);
+                } while (   rc == VERR_NET_DOWN
+                         && RTTimeMilliTS() - StartMs < 20000);
+                if (RT_SUCCESS(rc))
+                    RTMsgInfo("RTTcpServerCreateEx succceeded.\n");
+            }
+
+            if (RT_FAILURE(rc))
+            {
+                RTMsgError("RTTcpServerCreateEx(%s, %u,) failed: %Rrc\n",
+                           pThis->szBindAddr[0] ? pThis->szBindAddr : NULL, pThis->uBindPort, rc);
+            }
         }
     }
@@ -403 +754 @@
     return rc;
 }
+
+/**
+ * @interface_method_impl{ATSTRANSPORT,pfnOption}
+ */
+static DECLCALLBACK(int) atsTcpOption(PATSTRANSPORTINST pThis, int ch, PCRTGETOPTUNION pVal)
+{
+    int rc;
+
+    switch (ch)
+    {
+        case ATSTCPOPT_MODE:
+            if (!strcmp(pVal->psz, "both"))
+                pThis->enmMode = ATSTCPMODE_BOTH;
+            else if (!strcmp(pVal->psz, "client"))
+                pThis->enmMode = ATSTCPMODE_CLIENT;
+            else if (!strcmp(pVal->psz, "server"))
+                pThis->enmMode = ATSTCPMODE_SERVER;
+            else
+                return RTMsgErrorRc(VERR_INVALID_PARAMETER, "Invalid TCP mode: '%s'\n", pVal->psz);
+            return VINF_SUCCESS;
+
+        case ATSTCPOPT_BIND_ADDRESS:
+            rc = RTStrCopy(pThis->szBindAddr, sizeof(pThis->szBindAddr), pVal->psz);
+            if (RT_FAILURE(rc))
+                return RTMsgErrorRc(VERR_INVALID_PARAMETER, "TCP bind address is too long (%Rrc)", rc);
+            return VINF_SUCCESS;
+
+        case ATSTCPOPT_BIND_PORT:
+            pThis->uBindPort = pVal->u16 == 0 ? ATS_TCP_DEF_BIND_PORT_GUEST : pVal->u16;
+            return VINF_SUCCESS;
+
+        case ATSTCPOPT_CONNECT_ADDRESS:
+            rc = RTStrCopy(pThis->szConnectAddr, sizeof(pThis->szConnectAddr), pVal->psz);
+            if (RT_FAILURE(rc))
+                return RTMsgErrorRc(VERR_INVALID_PARAMETER, "TCP connect address is too long (%Rrc)", rc);
+            if (!pThis->szConnectAddr[0])
+                strcpy(pThis->szConnectAddr, ATS_TCP_DEF_CONNECT_GUEST_STR);
+            return VINF_SUCCESS;
+
+        case ATSTCPOPT_CONNECT_PORT:
+            pThis->uConnectPort = pVal->u16 == 0 ? ATS_TCP_DEF_BIND_PORT_GUEST : pVal->u16;
+            return VINF_SUCCESS;
+
+        default:
+            break;
+    }
+    return VERR_TRY_AGAIN;
+}
+
+/**
+ * @interface_method_impl{ATSTRANSPORT,pfnUsage}
+ */
+DECLCALLBACK(void) atsTcpUsage(PRTSTREAM pStream)
+{
+    RTStrmPrintf(pStream,
+                 "  --tcp-mode <both|client|server>\n"
+                 "       Selects the mode of operation.\n"
+                 "       Default: both\n"
+                 "  --tcp-bind-address <address>\n"
+                 "       The address(es) to listen to TCP connection on.  Empty string\n"
+                 "       means any address, this is the default.\n"
+                 "  --tcp-bind-port <port>\n"
+                 "       The port to listen to TCP connections on.\n"
+                 "       Default: %u\n"
+                 "  --tcp-connect-address <address>\n"
+                 "       The address of the server to try connect to in client mode.\n"
+                 "       Default: " ATS_TCP_DEF_CONNECT_GUEST_STR "\n"
+                 "  --tcp-connect-port <port>\n"
+                 "       The port on the server to connect to in client mode.\n"
+                 "       Default: %u\n"
+                 , ATS_TCP_DEF_BIND_PORT_GUEST, ATS_TCP_DEF_CONNECT_PORT_GUEST);
+}
+
+/** Command line options for the TCP/IP transport layer. */
+static const RTGETOPTDEF  g_TcpOpts[] =
+{
+    { "--tcp-mode",             ATSTCPOPT_MODE,             RTGETOPT_REQ_STRING },
+    { "--tcp-bind-address",     ATSTCPOPT_BIND_ADDRESS,     RTGETOPT_REQ_STRING },
+    { "--tcp-bind-port",        ATSTCPOPT_BIND_PORT,        RTGETOPT_REQ_UINT16 },
+    { "--tcp-connect-address",  ATSTCPOPT_CONNECT_ADDRESS,  RTGETOPT_REQ_STRING },
+    { "--tcp-connect-port",     ATSTCPOPT_CONNECT_PORT,     RTGETOPT_REQ_UINT16 }
+};
 
 /** TCP/IP transport layer. */
@@ -409 +842 @@
     /* .szName            = */ "tcp",
     /* .pszDesc           = */ "TCP/IP",
-    /* .pfnInit           = */ atsTcpInit,
+    /* .cOpts             = */ &g_TcpOpts[0],
+    /* .paOpts            = */ RT_ELEMENTS(g_TcpOpts),
+    /* .pfnUsage          = */ atsTcpUsage,
+    /* .pfnCreate         = */ atsTcpCreate,
+    /* .pfnDestroy        = */ atsTcpDestroy,
+    /* .pfnOption         = */ atsTcpOption,
+    /* .pfnStart          = */ atsTcpStart,
     /* .pfnTerm           = */ atsTcpTerm,
     /* .pfnWaitForConnect = */ atsTcpWaitForConnect,

trunk/src/VBox/Devices/Audio/DrvHostAudioValidationKit.cpp

@@ -1024 +1024 @@
 
     /** @todo Make this configurable via CFGM. */
-    const char *pszTcpAddr = ATS_TCP_HOST_DEFAULT_ADDR_STR;
-       uint32_t uTcpPort   = ATS_TCP_HOST_DEFAULT_PORT;
+    const char *pszTcpAddr = "127.0.0.1"; /* Only reachable for localhost for now. */
+    uint32_t    uTcpPort   = ATS_TCP_DEF_BIND_PORT_VALKIT;
 
     LogRel(("ValKit: Starting Audio Test Service (ATS) at %s:%RU32...\n",
             pszTcpAddr, uTcpPort));
 
-    rc = AudioTestSvcInit(&pThis->Srv,
-                          /* We only allow connections from localhost for now. */
-                          pszTcpAddr, uTcpPort, &Callbacks);
-    if (RT_SUCCESS(rc))
-        rc = AudioTestSvcStart(&pThis->Srv);
+    rc = AudioTestSvcCreate(&pThis->Srv);
+    if (RT_SUCCESS(rc))
+    {
+        RTGETOPTUNION Val;
+        RT_ZERO(Val);
+
+        Val.psz = "server"; /** @ŧodo No client connection mode needed here (yet). Make this configurable via CFGM. */
+        rc = AudioTestSvcHandleOption(&pThis->Srv, ATSTCPOPT_MODE, &Val);
+        AssertRC(rc);
+
+        Val.psz = pszTcpAddr;
+        rc = AudioTestSvcHandleOption(&pThis->Srv, ATSTCPOPT_BIND_ADDRESS, &Val);
+        AssertRC(rc);
+
+        Val.u16 = uTcpPort;
+        rc = AudioTestSvcHandleOption(&pThis->Srv, ATSTCPOPT_BIND_PORT, &Val);
+        AssertRC(rc);
+
+        rc = AudioTestSvcInit(&pThis->Srv, &Callbacks);
+        if (RT_SUCCESS(rc))
+            rc = AudioTestSvcStart(&pThis->Srv);
+    }
 
     if (RT_SUCCESS(rc))

trunk/src/VBox/Devices/Audio/testcase/tstAudioTestService.cpp

@@ -76 +76 @@
 
     ATSSERVER Srv;
-    rc = AudioTestSvcInit(&Srv, "127.0.0.1", ATS_TCP_HOST_DEFAULT_PORT, &Callbacks);
+    rc = AudioTestSvcCreate(&Srv);
     RTTEST_CHECK_RC_OK(hTest, rc);
     if (RT_SUCCESS(rc))
     {
-        rc = AudioTestSvcStart(&Srv);
+        rc = AudioTestSvcInit(&Srv, &Callbacks);
         RTTEST_CHECK_RC_OK(hTest, rc);
         if (RT_SUCCESS(rc))
         {
-            rc = AudioTestSvcClientConnect(&Client, "127.0.0.1", ATS_TCP_HOST_DEFAULT_PORT);
+            rc = AudioTestSvcStart(&Srv);
             RTTEST_CHECK_RC_OK(hTest, rc);
+            if (RT_SUCCESS(rc))
+            {
+                RTGETOPTUNION Val;
+                RT_ZERO(Val);
+
+                Val.psz = ATS_TCP_DEF_CONNECT_HOST_ADDR_STR;
+                rc = AudioTestSvcClientHandleOption(&Client, ATSTCPOPT_CONNECT_ADDRESS, &Val);
+                AssertRC(rc);
+
+                Val.u16 = ATS_TCP_DEF_CONNECT_PORT_HOST_PORT_FWD;
+                rc = AudioTestSvcClientHandleOption(&Client, ATSTCPOPT_CONNECT_PORT, &Val);
+                AssertRC(rc);
+
+                rc = AudioTestSvcClientConnect(&Client);
+                RTTEST_CHECK_RC_OK(hTest, rc);
+            }
         }
     }

trunk/src/VBox/ValidationKit/utils/audio/vkat.cpp

@@ -635 +635 @@
     RT_ZERO(TstEnv);
 
+    int rc = AudioTestSvcCreate(&TstEnv.u.Guest.Srv);
+
     const char *pszDevice     = NULL; /* Custom device to use. Can be NULL if not being used. */
     const char *pszTag        = NULL; /* Custom tag to use. Can be NULL if not being used. */
@@ -645 +647 @@
 
     const char *pszGuestTcpAddr  = NULL;
-    uint16_t    uGuestTcpPort    = ATS_TCP_GUEST_DEFAULT_PORT;
+    uint16_t    uGuestTcpPort    = ATS_TCP_DEF_BIND_PORT_GUEST;
     const char *pszValKitTcpAddr = NULL;
-    uint16_t    uValKitTcpPort   = ATS_TCP_HOST_DEFAULT_PORT;
-
-    int           rc;
+    uint16_t    uValKitTcpPort   = ATS_TCP_DEF_BIND_PORT_VALKIT;
+
+    int           ch;
     RTGETOPTUNION ValueUnion;
-    while ((rc = RTGetOpt(pGetState, &ValueUnion)))
-    {
-        switch (rc)
+    while ((ch = RTGetOpt(pGetState, &ValueUnion)))
+    {
+        switch (ch)
         {
             case 'a':
@@ -757 +759 @@
 
             default:
-                return RTGetOptPrintError(rc, &ValueUnion);
+                rc = AudioTestSvcHandleOption(&TstEnv.u.Guest.Srv, ch, &ValueUnion);
+                if (RT_FAILURE(rc))
+                    return RTGetOptPrintError(rc, &ValueUnion);
         }
     }
@@ -774 +778 @@
         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No test mode (--mode) specified!\n");
 
-    if (TstEnv.enmMode == AUDIOTESTMODE_HOST)
-    {
-        if (!pszGuestTcpAddr)
-            return RTMsgErrorExit(RTEXITCODE_SYNTAX, "No guest ATS address (--guest-ats-addr) specified!\n");
-    }
-
     /* For now all tests have the same test environment. */
-    rc = audioTestEnvInit(&TstEnv, pDrvReg, fWithDrvAudio,
-                          pszValKitTcpAddr, uValKitTcpPort,
-                          pszGuestTcpAddr, uGuestTcpPort);
+    rc = audioTestEnvInit(&TstEnv, pDrvReg, fWithDrvAudio);
     if (RT_SUCCESS(rc))
         rc = audioTestWorker(&TstEnv);
@@ -806 +802 @@
     g_aCmdTestOptions,
     RT_ELEMENTS(g_aCmdTestOptions),
-    audioTestCmdTestHelp
+    audioTestCmdTestHelp,
+    true /* fNeedsTransport */
 };
 
@@ -985 +982 @@
     RT_ELEMENTS(g_aCmdVerifyOptions),
     NULL,
+    false /* fNeedsTransport */
 };
 
@@ -1067 +1065 @@
                 RTStrmPrintf(pStrm, "    %s\n", pszHelp);
         }
+
+        if (pCmd->fNeedsTransport)
+        {
+            for (uintptr_t iTx = 0; iTx < g_cTransports; iTx++)
+                g_apTransports[iTx]->pfnUsage(pStrm);
+        }
     }
 
@@ -1155 +1159 @@
                     if (strcmp(ValueUnion.psz, pCmd->pszCommand) == 0)
                     {
-                        size_t const cCombinedOptions  = pCmd->cOptions + RT_ELEMENTS(g_aCmdCommonOptions);
+                        size_t cCombinedOptions  = pCmd->cOptions + RT_ELEMENTS(g_aCmdCommonOptions);
+                        if (pCmd->fNeedsTransport)
+                        {
+                            for (uintptr_t iTx = 0; iTx < g_cTransports; iTx++)
+                                cCombinedOptions += g_apTransports[iTx]->cOpts;
+                        }
                         PRTGETOPTDEF paCombinedOptions = (PRTGETOPTDEF)RTMemAlloc(cCombinedOptions * sizeof(RTGETOPTDEF));
                         if (paCombinedOptions)
                         {
+                            unsigned idxOpts = 0;
                             memcpy(paCombinedOptions, g_aCmdCommonOptions, sizeof(g_aCmdCommonOptions));
-                            memcpy(&paCombinedOptions[RT_ELEMENTS(g_aCmdCommonOptions)],
-                                   pCmd->paOptions, pCmd->cOptions * sizeof(RTGETOPTDEF));
+                            idxOpts += RT_ELEMENTS(g_aCmdCommonOptions);
+                            memcpy(&paCombinedOptions[idxOpts], pCmd->paOptions, pCmd->cOptions * sizeof(RTGETOPTDEF));
+                            idxOpts += pCmd->cOptions;
+                            if (pCmd->fNeedsTransport)
+                            {
+                                for (uintptr_t iTx = 0; iTx < g_cTransports; iTx++)
+                                {
+                                    memcpy(&paCombinedOptions[idxOpts],
+                                           g_apTransports[iTx]->paOpts, g_apTransports[iTx]->cOpts * sizeof(RTGETOPTDEF));
+                                    idxOpts += g_apTransports[iTx]->cOpts;
+                                }
+                            }
 
                             rc = RTGetOptInit(&GetState, argc, argv, paCombinedOptions, cCombinedOptions,

trunk/src/VBox/ValidationKit/utils/audio/vkatCmdGeneric.cpp

@@ -157 +157 @@
     RT_ELEMENTS(g_aCmdEnumOptions),
     audioTestCmdEnumHelp,
+    false /* fNeedsTransport */
 };
 
@@ -486 +487 @@
     RT_ELEMENTS(g_aCmdPlayOptions),
     audioTestCmdPlayHelp,
+    false /* fNeedsTransport */
 };
 
@@ -866 +868 @@
     RT_ELEMENTS(g_aCmdRecOptions),
     audioTestCmdRecHelp,
+    false /* fNeedsTransport */
 };
 

trunk/src/VBox/ValidationKit/utils/audio/vkatCmdSelfTest.cpp

@@ -77 +77 @@
                       2 /* 16-bit */, true  /* fSigned */, 2 /* cChannels */, 44100 /* uHz */);
 
-    rc = audioTestEnvInit(pTstEnvGst, pTstEnvGst->DrvStack.pDrvReg, pCtx->fWithDrvAudio,
-                          pCtx->Host.szValKitAtsAddr, pCtx->Host.uValKitAtsPort,
-                          pCtx->Guest.szAtsAddr, pCtx->Guest.uAtsPort);
+    rc = audioTestEnvInit(pTstEnvGst, pTstEnvGst->DrvStack.pDrvReg, pCtx->fWithDrvAudio);
     if (RT_SUCCESS(rc))
     {
@@ -159 +157 @@
         pTstEnvHst->enmMode = AUDIOTESTMODE_HOST;
 
-        rc = audioTestEnvInit(pTstEnvHst, &g_DrvHostValidationKitAudio, true /* fWithDrvAudio */,
-                              pCtx->Host.szValKitAtsAddr, pCtx->Host.uValKitAtsPort,
-                              pCtx->Host.szGuestAtsAddr, pCtx->Host.uGuestAtsPort);
+        rc = audioTestEnvInit(pTstEnvHst, &g_DrvHostValidationKitAudio, true /* fWithDrvAudio */);
         if (RT_SUCCESS(rc))
         {
@@ -346 +342 @@
     RT_ELEMENTS(s_aCmdSelftestOptions),
     audioTestCmdSelftestHelp,
+    true /* fNeedsTransport */
 };
 

trunk/src/VBox/ValidationKit/utils/audio/vkatCommon.cpp

@@ -574 +574 @@
 *********************************************************************************************************************************/
 
-int audioTestEnvConnectToHostAts(PAUDIOTESTENV pTstEnv,
-                                 const char *pszHostTcpAddr, uint32_t uHostTcpPort)
-{
-    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connecting to host ATS at %s:%RU32 ...\n",
-                 (pszHostTcpAddr && *pszHostTcpAddr) ? pszHostTcpAddr : ATS_TCP_HOST_DEFAULT_ADDR_STR,
-                 uHostTcpPort ? uHostTcpPort : ATS_TCP_HOST_DEFAULT_PORT);
-
-    int rc = AudioTestSvcClientConnect(&pTstEnv->u.Host.AtsClValKit, pszHostTcpAddr, uHostTcpPort);
+/**
+ * Connects an ATS client via TCP/IP to a peer.
+ *
+ * @returns VBox status code.
+ * @param   pTstEnv             Test environment to use.
+ * @param   pClient             Client to connect.
+ * @param   pszWhat             Hint of what to connect to where.
+ * @param   pszTcpBindAddr      TCP/IP bind address. Optionl and can be NULL.
+ *                              Server mode will be disabled then.
+ * @param   uTcpBindPort        TCP/IP bind port. Optionl and can be 0.
+ *                              Server mode will be disabled then. *
+ * @param   pszTcpConnectAddr   TCP/IP connect address. Optionl and can be NULL.
+ *                              Client mode will be disabled then.
+ * @param   uTcpConnectPort     TCP/IP connect port. Optionl and can be 0.
+ *                              Client mode will be disabled then.
+ */
+int audioTestEnvConnectViaTcp(PAUDIOTESTENV pTstEnv, PATSCLIENT pClient, const char *pszWhat,
+                              const char *pszTcpBindAddr, uint16_t uTcpBindPort,
+                              const char *pszTcpConnectAddr, uint16_t uTcpConnectPort)
+{
+    RT_NOREF(pTstEnv);
+
+    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connecting %s ...\n", pszWhat);
+
+    RTGETOPTUNION Val;
+    RT_ZERO(Val);
+
+    int rc;
+
+    if (   !pszTcpBindAddr
+        || !uTcpBindPort)
+    {
+        Val.psz = "client";
+    }
+    else if (   !pszTcpConnectAddr
+             || !uTcpConnectPort)
+    {
+        Val.psz = "server";
+    }
+    else
+        Val.psz = "both";
+
+    rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_MODE, &Val);
+    AssertRCReturn(rc, rc);
+
+    if (   !RTStrCmp(Val.psz, "client")
+        || !RTStrCmp(Val.psz, "both"))
+           RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connecting at %s:%RU32\n", pszTcpConnectAddr, uTcpConnectPort);
+
+    if (   !RTStrCmp(Val.psz, "server")
+        || !RTStrCmp(Val.psz, "both"))
+        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Listening at %s:%RU32\n", pszTcpBindAddr ? pszTcpBindAddr : "<None>", uTcpBindPort);
+
+    if (pszTcpBindAddr)
+    {
+        Val.psz = pszTcpBindAddr;
+        rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_BIND_ADDRESS, &Val);
+        AssertRCReturn(rc, rc);
+    }
+
+    if (uTcpBindPort)
+    {
+        Val.u16 = uTcpBindPort;
+        rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_BIND_PORT, &Val);
+        AssertRCReturn(rc, rc);
+    }
+
+    if (pszTcpConnectAddr)
+    {
+        Val.psz = pszTcpConnectAddr;
+        rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_CONNECT_ADDRESS, &Val);
+        AssertRCReturn(rc, rc);
+    }
+
+    if (uTcpConnectPort)
+    {
+        Val.u16 = uTcpConnectPort;
+        rc = AudioTestSvcClientHandleOption(pClient, ATSTCPOPT_CONNECT_PORT, &Val);
+        AssertRCReturn(rc, rc);
+    }
+
+    rc = AudioTestSvcClientConnect(pClient);
     if (RT_FAILURE(rc))
     {
-        RTTestFailed(g_hTest, "Connecting to host ATS failed with %Rrc\n", rc);
+        RTTestFailed(g_hTest, "Connecting %s failed with %Rrc\n", pszWhat, rc);
         return rc;
     }
 
-    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connected to host ATS\n");
-    return rc;
-}
-
-int audioTestEnvConnectToGuestAts(PAUDIOTESTENV pTstEnv,
-                                  const char *pszGuestTcpAddr, uint32_t uGuestTcpPort)
-{
-    RTTestPrintf(g_hTest, RTTESTLVL_DEBUG, "Connecting to guest ATS at %s:%RU32 ...\n",
-                 (pszGuestTcpAddr && *pszGuestTcpAddr) ? pszGuestTcpAddr : "127.0.0.1",
-                 uGuestTcpPort ? uGuestTcpPort : ATS_TCP_GUEST_DEFAULT_PORT);
-
-    int rc = AudioTestSvcClientConnect(&pTstEnv->u.Host.AtsClGuest, pszGuestTcpAddr, uGuestTcpPort);
+    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connected %s\n", pszWhat);
+    return rc;
+}
+
+/**
+ * Configures and starts an ATS TCP/IP server.
+ *
+ * @returns VBox status code.
+ * @param   pSrv                ATS server instance to configure and start.
+ * @param   pCallbacks          ATS callback table to use.
+ * @param   pszDesc             Hint of server type which is being started.
+ * @param   pszTcpBindAddr      TCP/IP bind address. Optionl and can be NULL.
+ *                              Server mode will be disabled then.
+ * @param   uTcpBindPort        TCP/IP bind port. Optionl and can be 0.
+ *                              Server mode will be disabled then. *
+ * @param   pszTcpConnectAddr   TCP/IP connect address. Optionl and can be NULL.
+ *                              Client mode will be disabled then.
+ * @param   uTcpConnectPort     TCP/IP connect port. Optionl and can be 0.
+ *                              Client mode will be disabled then.
+ */
+int audioTestEnvConfigureAndStartTcpServer(PATSSERVER pSrv, PCATSCALLBACKS pCallbacks, const char *pszDesc,
+                                           const char *pszTcpBindAddr, uint16_t uTcpBindPort,
+                                           const char *pszTcpConnectAddr, uint16_t uTcpConnectPort)
+{
+    RTGETOPTUNION Val;
+    RT_ZERO(Val);
+
+    if (pszTcpBindAddr)
+    {
+        Val.psz = pszTcpBindAddr;
+        AudioTestSvcHandleOption(pSrv, ATSTCPOPT_BIND_ADDRESS, &Val);
+    }
+
+    if (uTcpBindPort)
+    {
+        Val.u16 = uTcpBindPort;
+        AudioTestSvcHandleOption(pSrv, ATSTCPOPT_BIND_PORT, &Val);
+    }
+
+    if (pszTcpConnectAddr)
+    {
+        Val.psz = pszTcpConnectAddr;
+        AudioTestSvcHandleOption(pSrv, ATSTCPOPT_CONNECT_ADDRESS, &Val);
+    }
+
+    if (uTcpConnectPort)
+    {
+        Val.u16 = uTcpConnectPort;
+        AudioTestSvcHandleOption(pSrv, ATSTCPOPT_CONNECT_PORT, &Val);
+    }
+
+    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Starting server for %s at %s:%RU32 ...\n",
+                 pszDesc, pszTcpBindAddr[0] ? pszTcpBindAddr : "0.0.0.0", uTcpBindPort);
+    if (pszTcpConnectAddr[0])
+        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Trying %s to connect as client to %s:%RU32 ...\n",
+                     pszDesc, pszTcpConnectAddr[0] ? pszTcpConnectAddr : "0.0.0.0", uTcpConnectPort);
+
+    int rc = AudioTestSvcInit(pSrv, pCallbacks);
+    if (RT_SUCCESS(rc))
+        rc = AudioTestSvcStart(pSrv);
+
     if (RT_FAILURE(rc))
-    {
-        RTTestFailed(g_hTest, "Connecting to guest ATS failed with %Rrc\n", rc);
-        return rc;
-    }
-
-    RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Connected to guest ATS\n");
+        RTTestFailed(g_hTest, "Starting server for %s failed with %Rrc\n", pszDesc, rc);
+
     return rc;
 }
@@ -616 +735 @@
  * @param   pDrvReg             Audio driver to use.
  * @param   fWithDrvAudio       Whether to include DrvAudio in the stack or not.
- * @param   pszHostTcpAddr      Host ATS TCP/IP address to connect to.
- *                              If NULL, ATS_TCP_HOST_DEFAULT_ADDR_STR will be used.
- * @param   uHostTcpPort        Host ATS TCP/IP port to connect to.
- *                              If 0, ATS_TCP_HOST_DEFAULT_PORT will be used.
- * @param   pszGuestTcpAddr     Guest ATS TCP/IP address to connect to.
- *                              If NULL, any address (0.0.0.0) will be used.
- * @param   uGuestTcpPort       Guest ATS TCP/IP port to connect to.
- *                              If 0, ATS_TCP_GUEST_DEFAULT_PORT will be used.
  */
 int audioTestEnvInit(PAUDIOTESTENV pTstEnv,
-                     PCPDMDRVREG pDrvReg, bool fWithDrvAudio,
-                     const char *pszHostTcpAddr, uint32_t uHostTcpPort,
-                     const char *pszGuestTcpAddr, uint32_t uGuestTcpPort)
+                     PCPDMDRVREG pDrvReg, bool fWithDrvAudio)
 {
     int rc = VINF_SUCCESS;
@@ -656 +765 @@
     if (!pDrvReg)
         pDrvReg = AudioTestGetDefaultBackend();
-
-    if (!uHostTcpPort)
-        uHostTcpPort = ATS_TCP_HOST_DEFAULT_PORT;
-
-    if (!uGuestTcpPort)
-        uGuestTcpPort = ATS_TCP_GUEST_DEFAULT_PORT;
 
     RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Initializing environment for mode '%s'\n", pTstEnv->enmMode == AUDIOTESTMODE_HOST ? "host" : "guest");
@@ -732 +835 @@
         return rc;
 
-    /** @todo Implement NAT mode like we do for TxS later? */
     if (pTstEnv->enmMode == AUDIOTESTMODE_GUEST)
     {
@@ -749 +851 @@
         Callbacks.pvUser              = &Ctx;
 
+        if (!pTstEnv->u.Guest.TcpOpts.uTcpBindPort)
+            pTstEnv->u.Guest.TcpOpts.uTcpBindPort = ATS_TCP_DEF_BIND_PORT_GUEST;
+
+        if (!pTstEnv->u.Guest.TcpOpts.szTcpBindAddr[0])
+            RTStrCopy(pTstEnv->u.Guest.TcpOpts.szTcpBindAddr, sizeof(pTstEnv->u.Guest.TcpOpts.szTcpBindAddr), "0.0.0.0");
+
+        if (!pTstEnv->u.Guest.TcpOpts.uTcpConnectPort)
+            pTstEnv->u.Guest.TcpOpts.uTcpConnectPort = ATS_TCP_DEF_CONNECT_PORT_GUEST;
+
+        if (!pTstEnv->u.Guest.TcpOpts.szTcpConnectAddr[0])
+            RTStrCopy(pTstEnv->u.Guest.TcpOpts.szTcpConnectAddr, sizeof(pTstEnv->u.Guest.TcpOpts.szTcpConnectAddr), "10.0.2.2");
+
         /*
          * Start the ATS (Audio Test Service) on the guest side.
@@ -756 +870 @@
          * Note that we have to bind to "0.0.0.0" by default so that the host can connect to it.
          */
-        RTTestPrintf(g_hTest, RTTESTLVL_ALWAYS, "Starting guest ATS at %s:%RU32...\n",
-                     (pszGuestTcpAddr && *pszGuestTcpAddr) ? pszGuestTcpAddr : "0.0.0.0", uGuestTcpPort);
-        rc = AudioTestSvcInit(&pTstEnv->u.Guest.Srv,
-                              (pszGuestTcpAddr && *pszGuestTcpAddr) ? pszGuestTcpAddr : "0.0.0.0", uGuestTcpPort, &Callbacks);
+        rc = audioTestEnvConfigureAndStartTcpServer(&pTstEnv->u.Guest.Srv, &Callbacks, "Guest ATS",
+                                                    pTstEnv->u.Guest.TcpOpts.szTcpBindAddr, pTstEnv->u.Guest.TcpOpts.uTcpBindPort,
+                                                    pTstEnv->u.Guest.TcpOpts.szTcpConnectAddr, pTstEnv->u.Guest.TcpOpts.uTcpConnectPort);
+
+    }
+    else /* Host mode */
+    {
+
+        ATSCALLBACKCTX Ctx;
+        Ctx.pTstEnv = pTstEnv;
+
+        ATSCALLBACKS Callbacks;
+        RT_ZERO(Callbacks);
+        Callbacks.pvUser              = &Ctx;
+
+        if (!pTstEnv->u.Host.TcpOpts.uTcpBindPort)
+            pTstEnv->u.Host.TcpOpts.uTcpBindPort = ATS_TCP_DEF_BIND_PORT_HOST;
+
+        if (!pTstEnv->u.Host.TcpOpts.szTcpBindAddr[0])
+            RTStrCopy(pTstEnv->u.Host.TcpOpts.szTcpBindAddr, sizeof(pTstEnv->u.Host.TcpOpts.szTcpBindAddr), "0.0.0.0");
+
+        if (!pTstEnv->u.Host.TcpOpts.uTcpConnectPort)
+            pTstEnv->u.Host.TcpOpts.uTcpConnectPort = ATS_TCP_DEF_CONNECT_PORT_HOST_PORT_FWD;
+
+        if (!pTstEnv->u.Host.TcpOpts.szTcpConnectAddr[0])
+            RTStrCopy(pTstEnv->u.Host.TcpOpts.szTcpConnectAddr, sizeof(pTstEnv->u.Host.TcpOpts.szTcpConnectAddr),
+                      ATS_TCP_DEF_CONNECT_HOST_ADDR_STR); /** @todo Get VM IP? Needs port forwarding. */
+
+        /* We need to start a server on the host so that VMs configured with NAT networking
+         * can connect to it as well. */
+        rc = AudioTestSvcClientCreate(&pTstEnv->u.Host.AtsClGuest);
         if (RT_SUCCESS(rc))
-            rc = AudioTestSvcStart(&pTstEnv->u.Guest.Srv);
-
-        if (RT_FAILURE(rc))
-            RTTestFailed(g_hTest, "Starting ATS failed with %Rrc\n", rc);
-    }
-    else /* Host mode */
-    {
-        rc = audioTestEnvConnectToHostAts(pTstEnv, pszHostTcpAddr, uHostTcpPort);
+            rc = audioTestEnvConnectViaTcp(pTstEnv, &pTstEnv->u.Host.AtsClGuest,
+                                           "Host -> Guest ATS",
+                                           pTstEnv->u.Host.TcpOpts.szTcpBindAddr, pTstEnv->u.Host.TcpOpts.uTcpBindPort,
+                                           pTstEnv->u.Host.TcpOpts.szTcpConnectAddr, pTstEnv->u.Host.TcpOpts.uTcpConnectPort);
         if (RT_SUCCESS(rc))
-            rc = audioTestEnvConnectToGuestAts(pTstEnv, pszGuestTcpAddr, uGuestTcpPort);
+        {
+            if (!pTstEnv->ValKitTcpOpts.uTcpConnectPort)
+                pTstEnv->ValKitTcpOpts.uTcpConnectPort = ATS_TCP_DEF_CONNECT_PORT_VALKIT;
+
+            if (!pTstEnv->ValKitTcpOpts.szTcpConnectAddr[0])
+                RTStrCopy(pTstEnv->ValKitTcpOpts.szTcpConnectAddr, sizeof(pTstEnv->ValKitTcpOpts.szTcpConnectAddr),
+                          ATS_TCP_DEF_CONNECT_HOST_ADDR_STR);
+
+            rc = AudioTestSvcClientCreate(&pTstEnv->u.Host.AtsClValKit);
+            if (RT_SUCCESS(rc))
+                rc = audioTestEnvConnectViaTcp(pTstEnv, &pTstEnv->u.Host.AtsClValKit,
+                                               "Host -> Validation Kit Host Audio Driver ATS",
+                                               pTstEnv->ValKitTcpOpts.szTcpBindAddr, pTstEnv->ValKitTcpOpts.uTcpBindPort,
+                                               pTstEnv->ValKitTcpOpts.szTcpConnectAddr, pTstEnv->ValKitTcpOpts.uTcpConnectPort);
+        }
     }
 

trunk/src/VBox/ValidationKit/utils/audio/vkatInternal.h

@@ -173 +173 @@
 /** Maximum audio streams a test environment can handle. */
 #define AUDIOTESTENV_MAX_STREAMS 8
+
+/**
+ * Structure for keeping TCP/IP-specific options.
+ */
+typedef struct AUDIOTESTENVTCPOPTS
+{
+    /** Bind address (server mode). When empty, "0.0.0.0" (any host) will be used. */
+    char            szTcpBindAddr[128];
+    /** Bind port (server mode). */
+    uint16_t        uTcpBindPort;
+    /** Connection address (client mode). */
+    char            szTcpConnectAddr[128];
+    /** Connection port (client mode). */
+    uint16_t        uTcpConnectPort;
+} AUDIOTESTENVTCPOPTS;
+typedef AUDIOTESTENVTCPOPTS *PAUDIOTESTENVTCPOPTS;
 
 /**
@@ -218 +234 @@
         struct
         {
+            AUDIOTESTENVTCPOPTS TcpOpts;
             /** ATS instance to use. */
-            ATSSERVER       Srv;
+            ATSSERVER           Srv;
         } Guest;
         struct
         {
+            AUDIOTESTENVTCPOPTS TcpOpts;
+            /** ATS instance to use. */
+            ATSSERVER           Srv;
             /** Client connected to the ATS on the guest side. */
             ATSCLIENT       AtsClGuest;
@@ -233 +253 @@
         } Host;
     } u;
+    AUDIOTESTENVTCPOPTS         ValKitTcpOpts;
 } AUDIOTESTENV;
 
@@ -312 +333 @@
     /** Gets help for an option. */
     DECLCALLBACKMEMBER(const char *, pfnOptionHelp,(PCRTGETOPTDEF pOpt));
+    /** Flag indicating if the command needs the ATS transport layer.
+     *  Needed for command line parsing. */
+    bool            fNeedsTransport;
 } VKATCMD;
 /** Pointer to a const VKAT command entry. */
@@ -423 +447 @@
 /** @name ATS routines
  * @{ */
-int         audioTestEnvConnectToHostAts(PAUDIOTESTENV pTstEnv,
+int         audioTestEnvConnectToValKitAts(PAUDIOTESTENV pTstEnv,
                                          const char *pszHostTcpAddr, uint32_t uHostTcpPort);
 /** @}  */
@@ -429 +453 @@
 /** @name Test environment handling
  * @{ */
-int         audioTestEnvInit(PAUDIOTESTENV pTstEnv, PCPDMDRVREG pDrvReg, bool fWithDrvAudio, const char *pszHostTcpAddr, uint32_t uHostTcpPort, const char *pszGuestTcpAddr, uint32_t uGuestTcpPort);
+int         audioTestEnvInit(PAUDIOTESTENV pTstEnv, PCPDMDRVREG pDrvReg, bool fWithDrvAudio);
 void        audioTestEnvDestroy(PAUDIOTESTENV pTstEnv);
 int         audioTestEnvPrologue(PAUDIOTESTENV pTstEnv, bool fPack, char *pszPackFile, size_t cbPackFile);