Changeset 60287 in vbox for trunk/src/VBox

Timestamp:

Apr 1, 2016 12:49:19 PM (9 years ago)

Author:

vboxsync

Message:

ValidationKit/usb: Updates to the new USB test service, add configuration file parsing. Work in progress (Backup because switching to something else)

Location:

trunk/src/VBox/ValidationKit/utils/usb

Files:

• Makefile.kmk (modified) (1 diff)
• UsbTestService.cpp (modified) (16 diffs)
• UsbTestServiceCfg.cpp (copied) (copied from trunk/src/VBox/Frontends/VBoxAutostart/VBoxAutostartCfg.cpp ) (31 diffs)
• UsbTestServiceCfg.h (added)
• UsbTestServiceProtocol.cpp (added)
• UsbTestServiceProtocol.h (modified) (7 diffs)

trunk/src/VBox/ValidationKit/utils/usb/Makefile.kmk

@@ -44 +44 @@
 UsbTestService_SOURCES = \
         UsbTestService.cpp \
+        UsbTestServiceCfg.cpp \
+        UsbTestServiceProtocol.cpp \
         UsbTestServiceTcp.cpp
 

trunk/src/VBox/ValidationKit/utils/usb/UsbTestService.cpp

@@ -56 +56 @@
 
 #include "UsbTestServiceInternal.h"
+#include "UsbTestServiceCfg.h"
 
 
@@ -64 +65 @@
 
 /**
+ * UTS client state.
+ */
+typedef enum UTSCLIENTSTATE
+{
+    /** Invalid client state. */
+    UTSCLIENTSTATE_INVALID = 0,
+    /** Client is initialising, only the HOWDY and BYE packets are allowed. */
+    UTSCLIENTSTATE_INITIALISING,
+    /** Client is in fully cuntional state and ready to process all requests. */
+    UTSCLIENTSTATE_READY,
+    /** Client is destroying. */
+    UTSCLIENTSTATE_DESTROYING,
+    /** 32bit hack. */
+    UTSCLIENTSTATE_32BIT_HACK = 0x7fffffff
+} UTSCLIENTSTATE;
+
+/**
  * UTS client instance.
  */
@@ -70 +88 @@
     /** List node for new clients. */
     RTLISTNODE             NdLst;
+    /** The current client state. */
+    UTSCLIENTSTATE         enmState;
     /** Transport backend specific data. */
     PUTSTRANSPORTCLIENT    pTransportClient;
+    /** Client hostname. */
+    char                  *pszHostname;
 } UTSCLIENT;
 /** Pointer to a UTS client instance. */
@@ -93 +115 @@
 /** The select transport layer. */
 static PCUTSTRANSPORT       g_pTransport;
+/** The scratch path. */
+static char                 g_szCfgPath[RTPATH_MAX];
 /** The scratch path. */
 static char                 g_szScratchPath[RTPATH_MAX];
@@ -118 +142 @@
  * @todo implement signals and stuff.  */
 static bool volatile        g_fTerminate = false;
+/** Configuration AST. */
+static PCFGAST              g_pCfgAst = NULL;
 /** Pipe for communicating with the serving thread about new clients. - read end */
 static RTPIPE               g_hPipeR;
@@ -129 +155 @@
 static RTLISTANCHOR         g_LstClientsNew;
 
+
+
+/**
+ * Returns the string represenation of the given state.
+ */
+static const char *utsClientStateStringify(UTSCLIENTSTATE enmState)
+{
+    switch (enmState)
+    {
+        case UTSCLIENTSTATE_INVALID:
+            return "INVALID";
+        case UTSCLIENTSTATE_INITIALISING:
+            return "INITIALISING";
+        case UTSCLIENTSTATE_READY:
+            return "READY";
+        case UTSCLIENTSTATE_DESTROYING:
+            return "DESTROYING";
+        case UTSCLIENTSTATE_32BIT_HACK:
+        default:
+            break;
+    }
+
+    AssertMsgFailed(("Unknown state %#x\n", enmState));
+    return "UNKNOWN";
+}
 
 /**
@@ -451 +502 @@
 
 /**
- * Checks if the two opcodes match.
- *
- * @returns true on match, false on mismatch.
- * @param   pPktHdr             The packet header.
- * @param   pszOpcode2          The opcode we're comparing with.  Does not have
- *                              to be the whole 8 chars long.
- */
-DECLINLINE(bool) utsIsSameOpcode(PCUTSPKTHDR pPktHdr, const char *pszOpcode2)
-{
-    if (pPktHdr->achOpcode[0] != pszOpcode2[0])
-        return false;
-    if (pPktHdr->achOpcode[1] != pszOpcode2[1])
-        return false;
-
-    unsigned i = 2;
-    while (   i < RT_SIZEOFMEMB(UTSPKTHDR, achOpcode)
-           && pszOpcode2[i] != '\0')
-    {
-        if (pPktHdr->achOpcode[i] != pszOpcode2[i])
-            break;
-        i++;
-    }
-
-    if (   i < RT_SIZEOFMEMB(UTSPKTHDR, achOpcode)
-        && pszOpcode2[i] == '\0')
-    {
-        while (   i < RT_SIZEOFMEMB(UTSPKTHDR, achOpcode)
-               && pPktHdr->achOpcode[i] == ' ')
-            i++;
-    }
-
-    return i == RT_SIZEOFMEMB(UTSPKTHDR, achOpcode);
+ * Deals with a command which contains an unterminated string.
+ *
+ * @returns IPRT status code of the send.
+ * @param   pClient             The UTS client structure.
+ * @param   pPktHdr             The packet containing the unterminated string.
+ */
+static int utsReplyBadStrTermination(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
+{
+    return utsReplyFailure(pClient, pPktHdr, "BAD TERM", VERR_INVALID_PARAMETER, "Opcode '%.8s' contains an unterminated string", pPktHdr->achOpcode);
+}
+
+/**
+ * Deals with a command sent in an invalid client state.
+ *
+ * @returns IPRT status code of the send.
+ * @param   pClient             The UTS client structure.
+ * @param   pPktHdr             The packet containing the unterminated string.
+ */
+static int utsReplyInvalidState(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
+{
+    return utsReplyFailure(pClient, pPktHdr, "INVSTATE", VERR_INVALID_STATE, "Opcode '%.8s' is not supported at client state '%s",
+                           pPktHdr->achOpcode, utsClientStateStringify(pClient->enmState));
 }
 
@@ -512 +553 @@
 static int utsDoHowdy(PUTSCLIENT pClient, PCUTSPKTHDR pPktHdr)
 {
-    if (pPktHdr->cb != sizeof(UTSPKTHDR))
-        return utsReplyBadSize(pClient, pPktHdr, sizeof(UTSPKTHDR));
+    if (pPktHdr->cb != sizeof(UTSPKTREQHOWDY))
+        return utsReplyBadSize(pClient, pPktHdr, sizeof(UTSPKTREQHOWDY));
+
+    if (pClient->enmState != UTSCLIENTSTATE_INITIALISING)
+        return utsReplyInvalidState(pClient, pPktHdr);
+
+    PUTSPKTREQHOWDY pReq = (PUTSPKTREQHOWDY)pPktHdr;
+
+    if (pReq->uVersion != UTS_PROTOCOL_VS)
+        return utsReplyRC(pClient, pPktHdr, VERR_VERSION_MISMATCH, "The given version %#x is not supported", pReq->uVersion);
+
+    /* Verify hostname string. */
+    if (pReq->cchHostname >= sizeof(pReq->achHostname))
+        return utsReplyBadSize(pClient, pPktHdr, sizeof(pReq->achHostname) - 1);
+
+    if (pReq->achHostname[pReq->cchHostname] != '\0')
+        return utsReplyBadStrTermination(pClient, pPktHdr);
+
+    /* Extract string. */
+    pClient->pszHostname = RTStrDup(pClient->pszHostname);
+    if (!pClient->pszHostname)
+        return utsReplyRC(pClient, pPktHdr, VERR_NO_MEMORY, "Failed to alllocate memory for the hostname string");
+
     int rc = utsReplyAck(pClient, pPktHdr);
     if (RT_SUCCESS(rc))
@@ -564 +626 @@
 static void utsClientDestroy(PUTSCLIENT pClient)
 {
+    if (pClient->pszHostname)
+        RTStrFree(pClient->pszHostname);
     RTMemFree(pClient);
 }
@@ -702 +766 @@
         if (RT_LIKELY(pClient))
         {
+            pClient->enmState         = UTSCLIENTSTATE_INITIALISING;
             pClient->pTransportClient = pTransportClient;
         }
@@ -724 +789 @@
 {
     int rc = VINF_SUCCESS;
+    PRTERRINFO pErrInfo = NULL;
 
     RTListInit(&g_LstClientsNew);
 
-    rc = RTCritSectInit(&g_CritSectClients);
+    rc = utsParseConfig(g_szCfgPath, &g_pCfgAst, &pErrInfo);
     if (RT_SUCCESS(rc))
     {
-        rc = RTPipeCreate(&g_hPipeR, &g_hPipeW, 0);
+        rc = RTCritSectInit(&g_CritSectClients);
         if (RT_SUCCESS(rc))
         {
-            /* Spin off the thread serving connections. */
-            rc = RTThreadCreate(&g_hThreadServing, utsClientWorker, NULL, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE,
-                                "USBTSTSRV");
+            rc = RTPipeCreate(&g_hPipeR, &g_hPipeW, 0);
             if (RT_SUCCESS(rc))
-                return VINF_SUCCESS;
+            {
+                /* Spin off the thread serving connections. */
+                rc = RTThreadCreate(&g_hThreadServing, utsClientWorker, NULL, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE,
+                                    "USBTSTSRV");
+                if (RT_SUCCESS(rc))
+                    return VINF_SUCCESS;
+                else
+                    RTMsgError("Creating the client worker thread failed with %Rrc\n", rc);
+
+                RTPipeClose(g_hPipeR);
+                RTPipeClose(g_hPipeW);
+            }
             else
-                RTMsgError("Creating the client worker thread failed with %Rrc\n", rc);
-
-            RTPipeClose(g_hPipeR);
-            RTPipeClose(g_hPipeW);
+                RTMsgError("Creating communications pipe failed with %Rrc\n", rc);
+
+            RTCritSectDelete(&g_CritSectClients);
         }
         else
-            RTMsgError("Creating communications pipe failed with %Rrc\n", rc);
-
-        RTCritSectDelete(&g_CritSectClients);
+            RTMsgError("Creating global critical section failed with %Rrc\n", rc);
+
+        utsConfigAstDestroy(g_pCfgAst);
     }
     else
-        RTMsgError("Creating global critical section failed with %Rrc\n", rc);
+    {
+        if (RTErrInfoIsSet(pErrInfo))
+        {
+            RTMsgError("Failed to parse config with detailed error: %s (%Rrc)\n",
+                       pErrInfo->pszMsg, pErrInfo->rc);
+            RTErrInfoFree(pErrInfo);
+        }
+        else
+            RTMsgError("Faield to parse config with unknown error (%Rrc)\n", rc);
+        return rc;
+    }
 
     return rc;
@@ -821 +905 @@
 
     /*
+     * Config file location.
+     */
+    /** @todo: Improve */
+#if !defined(RT_OS_WINDOWS)
+    strcpy(g_szCfgPath, "/etc/uts.conf");
+#else
+    strcpy(g_szCfgPath, "");
+#endif
+
+    /*
      * The default transporter is the first one.
      */
@@ -838 +932 @@
                  "\n"
                  "Options:\n"
+                 "  --config <path>\n"
+                 "      Where to load the config from\n"
                  "  --cdrom <path>\n"
                  "      Where the CD/DVD-ROM will be mounted.\n"
@@ -891 +987 @@
      * Storage for locally handled options.
      */
-    bool        fDaemonize      = true;
-    bool        fDaemonized     = false;
+    bool fDaemonize  = true;
+    bool fDaemonized = false;
 
     /*
@@ -899 +995 @@
     static const RTGETOPTDEF s_aBaseOptions[] =
     {
+        { "--config",           'C', RTGETOPT_REQ_STRING  },
         { "--transport",        't', RTGETOPT_REQ_STRING  },
         { "--cdrom",            'c', RTGETOPT_REQ_STRING  },
@@ -937 +1034 @@
         switch (ch)
         {
+            case 'C':
+                rc = RTStrCopy(g_szCfgPath, sizeof(g_szCfgPath), Val.psz);
+                if (RT_FAILURE(rc))
+                    return RTMsgErrorExit(RTEXITCODE_FAILURE, "Config file path is path too long (%Rrc)\n", rc);
+                break;
+
             case 'c':
                 rc = RTStrCopy(g_szCdRomPath, sizeof(g_szCdRomPath), Val.psz);

trunk/src/VBox/ValidationKit/utils/usb/UsbTestServiceCfg.cpp

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBoxAutostart - VirtualBox Autostart service, configuration parser.
+ * UsbTestServ - Remote USB test configuration and execution server, Config file API.
  */
 
 /*
- * Copyright (C) 2012 Oracle Corporation
+ * Copyright (C) 2016 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -28 +28 @@
 #include <iprt/message.h>
 
-#include "VBoxAutostart.h"
+#include "UsbTestServiceCfg.h"
 
 
@@ -126 +126 @@
  * @param   pToken           The token to free.
  */
-static void autostartConfigTokenFree(PCFGTOKENIZER pCfgTokenizer, PCFGTOKEN pToken)
+static void utsConfigTokenFree(PCFGTOKENIZER pCfgTokenizer, PCFGTOKEN pToken)
 {
     NOREF(pCfgTokenizer);
@@ -138 +138 @@
  * @param   pCfgTokenizer    The config tokenizer.
  */
-static int autostartConfigTokenizerReadNextLine(PCFGTOKENIZER pCfgTokenizer)
+static int utsConfigTokenizerReadNextLine(PCFGTOKENIZER pCfgTokenizer)
 {
     int rc = VINF_SUCCESS;
@@ -184 +184 @@
  * @param   ppCfgToken       Where to store the pointer to the next token on success.
  */
-static int autostartConfigTokenizerCreateToken(PCFGTOKENIZER pCfgTokenizer,
+static int utsConfigTokenizerCreateToken(PCFGTOKENIZER pCfgTokenizer,
                                                PCFGTOKEN pCfgTokenUse, PCFGTOKEN *ppCfgToken)
 {
@@ -208 +208 @@
             || *pszToken == '#')
         {
-            rc = autostartConfigTokenizerReadNextLine(pCfgTokenizer);
+            rc = utsConfigTokenizerReadNextLine(pCfgTokenizer);
             if (rc == VERR_EOF)
             {
@@ -267 +267 @@
                 || enmType == CFGTOKENTYPE_ID))
         {
-            autostartConfigTokenFree(pCfgTokenizer, pCfgTokenUse);
+            utsConfigTokenFree(pCfgTokenizer, pCfgTokenUse);
             pCfgTokenUse = NULL;
         }
@@ -295 +295 @@
         }
         else if (pCfgTokenUse)
-            autostartConfigTokenFree(pCfgTokenizer, pCfgTokenUse);
+            utsConfigTokenFree(pCfgTokenizer, pCfgTokenUse);
 
         if (RT_SUCCESS(rc))
@@ -315 +315 @@
  * @param   pCfgTokenizer    The config tokenizer to destroy.
  */
-static void autostartConfigTokenizerDestroy(PCFGTOKENIZER pCfgTokenizer)
+static void utsConfigTokenizerDestroy(PCFGTOKENIZER pCfgTokenizer)
 {
     if (pCfgTokenizer->pszLine)
@@ -334 +334 @@
  *                         success.
  */
-static int autostartConfigTokenizerCreate(const char *pszFilename, PCFGTOKENIZER *ppCfgTokenizer)
+static int utsConfigTokenizerCreate(const char *pszFilename, PCFGTOKENIZER *ppCfgTokenizer)
 {
     int rc = VINF_SUCCESS;
@@ -349 +349 @@
             if (RT_SUCCESS(rc))
             {
-                rc = autostartConfigTokenizerReadNextLine(pCfgTokenizer);
+                rc = utsConfigTokenizerReadNextLine(pCfgTokenizer);
                 if (RT_SUCCESS(rc))
-                    rc = autostartConfigTokenizerCreateToken(pCfgTokenizer, NULL,
+                    rc = utsConfigTokenizerCreateToken(pCfgTokenizer, NULL,
                                                              &pCfgTokenizer->pTokenNext);
             }
@@ -365 +365 @@
     else if (   RT_FAILURE(rc)
              && pCfgTokenizer)
-        autostartConfigTokenizerDestroy(pCfgTokenizer);
+        utsConfigTokenizerDestroy(pCfgTokenizer);
 
     return rc;
@@ -377 +377 @@
  * @param   ppCfgToken      Where to store the next token.
  */
-static int autostartConfigTokenizerGetNextToken(PCFGTOKENIZER pCfgTokenizer,
+static int utsConfigTokenizerGetNextToken(PCFGTOKENIZER pCfgTokenizer,
                                                 PCFGTOKEN *ppCfgToken)
 {
     *ppCfgToken = pCfgTokenizer->pTokenNext;
-    return autostartConfigTokenizerCreateToken(pCfgTokenizer, NULL, &pCfgTokenizer->pTokenNext);
+    return utsConfigTokenizerCreateToken(pCfgTokenizer, NULL, &pCfgTokenizer->pTokenNext);
 }
 
@@ -390 +390 @@
  * @param   enmType         Token type.
  */
-static const char *autostartConfigTokenTypeToStr(CFGTOKENTYPE enmType)
+static const char *utsConfigTokenTypeToStr(CFGTOKENTYPE enmType)
 {
     switch (enmType)
@@ -421 +421 @@
  * @param   pToken         Token.
  */
-static const char *autostartConfigTokenToString(PCFGTOKEN pToken)
+static const char *utsConfigTokenToString(PCFGTOKEN pToken)
 {
     if (pToken->enmType == CFGTOKENTYPE_ID)
         return pToken->u.Id.achToken;
     else
-        return autostartConfigTokenTypeToStr(pToken->enmType);
+        return utsConfigTokenTypeToStr(pToken->enmType);
 }
 
@@ -435 +435 @@
  * @param   pToken          Token.
  */
-static size_t autostartConfigTokenGetLength(PCFGTOKEN pToken)
+static size_t utsConfigTokenGetLength(PCFGTOKEN pToken)
 {
     switch (pToken->enmType)
@@ -463 +463 @@
  * @param   pToken          The token which caused the error.
  * @param   pszExpected     String of the token which was expected.
- */
-static void autostartConfigTokenizerMsgUnexpectedToken(PCFGTOKEN pToken, const char *pszExpected)
-{
-    autostartSvcLogError("Unexpected token '%s' at %d:%d.%d, expected '%s'",
-                         autostartConfigTokenToString(pToken),
-                         pToken->iLine, pToken->cchStart,
-                         pToken->cchStart + autostartConfigTokenGetLength(pToken) - 1, pszExpected);
+ * @param   ppErrInfo       Where to store the detailed error info.
+ */
+static void utsConfigTokenizerMsgUnexpectedToken(PCFGTOKEN pToken, const char *pszExpected,
+                                                 PRTERRINFO *ppErrInfo)
+{
+    if (ppErrInfo)
+    {
+        PRTERRINFO pErrInfo = RTErrInfoAlloc(256);
+        if (RT_LIKELY(pErrInfo))
+        {
+            RTErrInfoSetF(pErrInfo, VERR_INVALID_STATE, "Unexpected token '%s' at %d:%d.%d, expected '%s'",
+                          utsConfigTokenToString(pToken),
+                          pToken->iLine, pToken->cchStart,
+                          pToken->cchStart + utsConfigTokenGetLength(pToken) - 1, pszExpected);
+            *ppErrInfo = pErrInfo;
+        }
+    }
 }
 
@@ -478 +488 @@
  * @param   pCfgTokenizer    The config tokenizer.
  * @param   pszTokenCheck    The token to check for.
- */
-static int autostartConfigTokenizerCheckAndConsume(PCFGTOKENIZER pCfgTokenizer, CFGTOKENTYPE enmType)
+ * @param   ppErrInfo        Where to store the detailed error info.
+ */
+static int utsConfigTokenizerCheckAndConsume(PCFGTOKENIZER pCfgTokenizer, CFGTOKENTYPE enmType,
+                                             PRTERRINFO *ppErrInfo)
 {
     int rc = VINF_SUCCESS;
     PCFGTOKEN pCfgToken = NULL;
 
-    rc = autostartConfigTokenizerGetNextToken(pCfgTokenizer, &pCfgToken);
+    rc = utsConfigTokenizerGetNextToken(pCfgTokenizer, &pCfgToken);
     if (RT_SUCCESS(rc))
     {
         if (pCfgToken->enmType != enmType)
         {
-            autostartConfigTokenizerMsgUnexpectedToken(pCfgToken, autostartConfigTokenTypeToStr(enmType));
+            utsConfigTokenizerMsgUnexpectedToken(pCfgToken, utsConfigTokenTypeToStr(enmType), ppErrInfo);
             rc = VERR_INVALID_PARAMETER;
         }
 
-        autostartConfigTokenFree(pCfgTokenizer, pCfgToken);
+        utsConfigTokenFree(pCfgTokenizer, pCfgToken);
     }
     return rc;
@@ -504 +516 @@
  * @param   pCfgTokenizer    Tokenizer instance data.
  */
-static int autostartConfigTokenizerConsume(PCFGTOKENIZER pCfgTokenizer)
+static int utsConfigTokenizerConsume(PCFGTOKENIZER pCfgTokenizer)
 {
     int rc = VINF_SUCCESS;
     PCFGTOKEN pCfgToken = NULL;
 
-    rc = autostartConfigTokenizerGetNextToken(pCfgTokenizer, &pCfgToken);
+    rc = utsConfigTokenizerGetNextToken(pCfgTokenizer, &pCfgToken);
     if (RT_SUCCESS(rc))
-        autostartConfigTokenFree(pCfgTokenizer, pCfgToken);
+        utsConfigTokenFree(pCfgTokenizer, pCfgToken);
 
     return rc;
@@ -522 +534 @@
  * @param   pCfgTokenizer    Tokenizer instance data.
  */
-DECLINLINE(PCFGTOKEN) autostartConfigTokenizerPeek(PCFGTOKENIZER pCfgTokenizer)
+DECLINLINE(PCFGTOKEN) utsConfigTokenizerPeek(PCFGTOKENIZER pCfgTokenizer)
 {
     return pCfgTokenizer->pTokenNext;
@@ -534 +546 @@
  * @param   pszToken    The token to check for.
  */
-DECLINLINE(bool) autostartConfigTokenizerPeekIsEqual(PCFGTOKENIZER pCfgTokenizer, CFGTOKENTYPE enmType)
-{
-    PCFGTOKEN pToken = autostartConfigTokenizerPeek(pCfgTokenizer);
+DECLINLINE(bool) utsConfigTokenizerPeekIsEqual(PCFGTOKENIZER pCfgTokenizer, CFGTOKENTYPE enmType)
+{
+    PCFGTOKEN pToken = utsConfigTokenizerPeek(pCfgTokenizer);
     return pToken->enmType == enmType;
 }
@@ -547 +559 @@
  * @param   pszKey           The key for the pair.
  * @param   ppCfgAst         Where to store the resulting AST on success.
- */
-static int autostartConfigParseValue(PCFGTOKENIZER pCfgTokenizer, const char *pszKey,
-                                     PCFGAST *ppCfgAst)
+ * @param   ppErrInfo        Where to store the detailed error info.
+ */
+static int utsConfigParseValue(PCFGTOKENIZER pCfgTokenizer, const char *pszKey,
+                               PCFGAST *ppCfgAst, PRTERRINFO *ppErrInfo)
 {
     int rc = VINF_SUCCESS;
     PCFGTOKEN pToken = NULL;
 
-    rc = autostartConfigTokenizerGetNextToken(pCfgTokenizer, &pToken);
+    rc = utsConfigTokenizerGetNextToken(pCfgTokenizer, &pToken);
     if (   RT_SUCCESS(rc)
         && pToken->enmType == CFGTOKENTYPE_ID)
@@ -578 +591 @@
     else
     {
-        autostartConfigTokenizerMsgUnexpectedToken(pToken, "non reserved token");
+        utsConfigTokenizerMsgUnexpectedToken(pToken, "non reserved token", ppErrInfo);
         rc = VERR_INVALID_PARAMETER;
     }
@@ -593 +606 @@
  * @param   ppCfgAst         Where to store the resulting AST on success.
  */
-static int autostartConfigParseCompoundNode(PCFGTOKENIZER pCfgTokenizer, const char *pszScopeId,
-                                            PCFGAST *ppCfgAst)
+static int utsConfigParseCompoundNode(PCFGTOKENIZER pCfgTokenizer, const char *pszScopeId,
+                                      PCFGAST *ppCfgAst, PRTERRINFO *ppErrInfo)
 {
     int rc = VINF_SUCCESS;
@@ -619 +632 @@
         PCFGAST pAstNode = NULL;
 
-        if (   autostartConfigTokenizerPeekIsEqual(pCfgTokenizer, CFGTOKENTYPE_CURLY_CLOSING)
-            || autostartConfigTokenizerPeekIsEqual(pCfgTokenizer, CFGTOKENTYPE_EOF))
+        if (   utsConfigTokenizerPeekIsEqual(pCfgTokenizer, CFGTOKENTYPE_CURLY_CLOSING)
+            || utsConfigTokenizerPeekIsEqual(pCfgTokenizer, CFGTOKENTYPE_EOF))
             break;
 
-        rc = autostartConfigTokenizerGetNextToken(pCfgTokenizer, &pToken);
+        rc = utsConfigTokenizerGetNextToken(pCfgTokenizer, &pToken);
         if (   RT_SUCCESS(rc)
             && pToken->enmType == CFGTOKENTYPE_ID)
         {
             /* Next must be a = token in all cases at this place. */
-            rc = autostartConfigTokenizerCheckAndConsume(pCfgTokenizer, CFGTOKENTYPE_EQUAL);
+            rc = utsConfigTokenizerCheckAndConsume(pCfgTokenizer, CFGTOKENTYPE_EQUAL, ppErrInfo);
             if (RT_SUCCESS(rc))
             {
                 /* Check whether this is a compound node. */
-                if (autostartConfigTokenizerPeekIsEqual(pCfgTokenizer, CFGTOKENTYPE_CURLY_OPEN))
+                if (utsConfigTokenizerPeekIsEqual(pCfgTokenizer, CFGTOKENTYPE_CURLY_OPEN))
                 {
-                    rc = autostartConfigTokenizerConsume(pCfgTokenizer);
+                    rc = utsConfigTokenizerConsume(pCfgTokenizer);
                     if (RT_SUCCESS(rc))
-                        rc = autostartConfigParseCompoundNode(pCfgTokenizer, pToken->u.Id.achToken,
-                                                              &pAstNode);
+                        rc = utsConfigParseCompoundNode(pCfgTokenizer, pToken->u.Id.achToken,
+                                                        &pAstNode, ppErrInfo);
 
                     if (RT_SUCCESS(rc))
-                        rc = autostartConfigTokenizerCheckAndConsume(pCfgTokenizer, CFGTOKENTYPE_CURLY_CLOSING);
+                        rc = utsConfigTokenizerCheckAndConsume(pCfgTokenizer, CFGTOKENTYPE_CURLY_CLOSING, ppErrInfo);
                 }
                 else
-                    rc = autostartConfigParseValue(pCfgTokenizer, pToken->u.Id.achToken,
-                                                   &pAstNode);
+                    rc = utsConfigParseValue(pCfgTokenizer, pToken->u.Id.achToken,
+                                             &pAstNode, ppErrInfo);
             }
         }
         else if (RT_SUCCESS(rc))
         {
-            autostartConfigTokenizerMsgUnexpectedToken(pToken, "non reserved token");
+            utsConfigTokenizerMsgUnexpectedToken(pToken, "non reserved token", ppErrInfo);
             rc = VERR_INVALID_PARAMETER;
         }
@@ -674 +687 @@
         }
 
-        autostartConfigTokenFree(pCfgTokenizer, pToken);
+        utsConfigTokenFree(pCfgTokenizer, pToken);
 
     } while (RT_SUCCESS(rc));
@@ -681 +694 @@
         *ppCfgAst = pCfgAst;
     else
-        autostartConfigAstDestroy(pCfgAst);
+        utsConfigAstDestroy(pCfgAst);
 
     return rc;
 }
 
-DECLHIDDEN(int) autostartParseConfig(const char *pszFilename, PCFGAST *ppCfgAst)
+DECLHIDDEN(int) utsParseConfig(const char *pszFilename, PCFGAST *ppCfgAst, PRTERRINFO *ppErrInfo)
 {
     PCFGTOKENIZER pCfgTokenizer = NULL;
@@ -695 +708 @@
     AssertPtrReturn(ppCfgAst, VERR_INVALID_POINTER);
 
-    rc = autostartConfigTokenizerCreate(pszFilename, &pCfgTokenizer);
+    rc = utsConfigTokenizerCreate(pszFilename, &pCfgTokenizer);
     if (RT_SUCCESS(rc))
     {
-        rc = autostartConfigParseCompoundNode(pCfgTokenizer, "", &pCfgAst);
+        rc = utsConfigParseCompoundNode(pCfgTokenizer, "", &pCfgAst, ppErrInfo);
         if (RT_SUCCESS(rc))
-            rc = autostartConfigTokenizerCheckAndConsume(pCfgTokenizer, CFGTOKENTYPE_EOF);
+            rc = utsConfigTokenizerCheckAndConsume(pCfgTokenizer, CFGTOKENTYPE_EOF, ppErrInfo);
     }
 
     if (pCfgTokenizer)
-        autostartConfigTokenizerDestroy(pCfgTokenizer);
+        utsConfigTokenizerDestroy(pCfgTokenizer);
 
     if (RT_SUCCESS(rc))
@@ -712 +725 @@
 }
 
-DECLHIDDEN(void) autostartConfigAstDestroy(PCFGAST pCfgAst)
+DECLHIDDEN(void) utsConfigAstDestroy(PCFGAST pCfgAst)
 {
     AssertPtrReturnVoid(pCfgAst);
@@ -726 +739 @@
         {
             for (unsigned i = 0; i < pCfgAst->u.Compound.cAstNodes; i++)
-                autostartConfigAstDestroy(pCfgAst->u.Compound.apAstNodes[i]);
+                utsConfigAstDestroy(pCfgAst->u.Compound.apAstNodes[i]);
             RTMemFree(pCfgAst);
             break;
@@ -736 +749 @@
 }
 
-DECLHIDDEN(PCFGAST) autostartConfigAstGetByName(PCFGAST pCfgAst, const char *pszName)
+DECLHIDDEN(PCFGAST) utsConfigAstGetByName(PCFGAST pCfgAst, const char *pszName)
 {
     if (!pCfgAst)

trunk/src/VBox/ValidationKit/utils/usb/UsbTestServiceProtocol.h

@@ -79 +79 @@
 #define UTSPKT_OPCODE_HOWDY             "HOWDY   "
 
+/** 32bit protocol version consisting of a 16bit major and 16bit minor part. */
+#define UTS_PROTOCOL_VS (UTS_PROTOCOL_VS_MAJOR | UTS_PROTOCOL_VS_MINOR)
+/** The major version part of the protocol version. */
+#define UTS_PROTOCOL_VS_MAJOR (1 << 16)
+/** The minor version part of the protocol version. */
+#define UTS_PROTOCOL_VS_MINOR (0)
+
 /**
  * The HOWDY request structure.
@@ -96 +103 @@
 } UTSPKTREQHOWDY;
 AssertCompileSizeAlignment(UTSPKTREQHOWDY, UTSPKT_ALIGNMENT);
+/** Pointer to a HOWDY request structure. */
+typedef UTSPKTREQHOWDY *PUTSPKTREQHOWDY;
 
 /**
@@ -122 +131 @@
 } UTSPKTREPHOWDY;
 AssertCompileSizeAlignment(UTSPKTREPHOWDY, UTSPKT_ALIGNMENT);
+/** Pointer to a HOWDY reply structure. */
+typedef UTSPKTREPHOWDY *PUTSPKTREPHOWDY;
 
 /** Connections over USB/IP are supported. */
@@ -150 +161 @@
 } UTSPKTREQGDGTDTOR;
 AssertCompileSizeAlignment(UTSPKTREQGDGTDTOR, UTSPKT_ALIGNMENT);
+/** Pointer to a GADGET DESTROY structure. */
+typedef UTSPKTREQGDGTDTOR *PUTSPKTREQGDGTDTOR;
 
 /* No additional structure for the reply (just standard STATUS packet). */
@@ -168 +181 @@
 } UTSPKTREQGDGTCNCT;
 AssertCompileSizeAlignment(UTSPKTREQGDGTCNCT, UTSPKT_ALIGNMENT);
+/** Pointer to a GADGET CONNECT request structure. */
+typedef UTSPKTREQGDGTCNCT *PUTSPKTREQGDGTCNCT;
 
 /* No additional structure for the reply (just standard STATUS packet). */
@@ -174 +189 @@
 
 /**
- * The GADGET CONNECT request structure.
+ * The GADGET DISCONNECT request structure.
  */
 typedef struct UTSPKTREQGDGTDCNT
@@ -186 +201 @@
 } UTSPKTREQGDGTDCNT;
 AssertCompileSizeAlignment(UTSPKTREQGDGTDCNT, UTSPKT_ALIGNMENT);
+/** Pointer to a GADGET CONNECT request structure. */
+typedef UTSPKTREQGDGTDCNT *PUTSPKTREQGDGTDCNT;
 
 /* No additional structure for the reply (just standard STATUS packet). */
 
+/**
+ * Checks if the two opcodes match.
+ *
+ * @returns true on match, false on mismatch.
+ * @param   pPktHdr             The packet header.
+ * @param   pszOpcode2          The opcode we're comparing with.  Does not have
+ *                              to be the whole 8 chars long.
+ */
+DECLINLINE(bool) utsIsSameOpcode(PCUTSPKTHDR pPktHdr, const char *pszOpcode2)
+{
+    if (pPktHdr->achOpcode[0] != pszOpcode2[0])
+        return false;
+    if (pPktHdr->achOpcode[1] != pszOpcode2[1])
+        return false;
+
+    unsigned i = 2;
+    while (   i < RT_SIZEOFMEMB(UTSPKTHDR, achOpcode)
+           && pszOpcode2[i] != '\0')
+    {
+        if (pPktHdr->achOpcode[i] != pszOpcode2[i])
+            break;
+        i++;
+    }
+
+    if (   i < RT_SIZEOFMEMB(UTSPKTHDR, achOpcode)
+        && pszOpcode2[i] == '\0')
+    {
+        while (   i < RT_SIZEOFMEMB(UTSPKTHDR, achOpcode)
+               && pPktHdr->achOpcode[i] == ' ')
+            i++;
+    }
+
+    return i == RT_SIZEOFMEMB(UTSPKTHDR, achOpcode);
+}
+
+/**
+ * Converts a UTS request packet from host to network byte ordering.
+ *
+ * @returns nothing.
+ * @param   pPktHdr           The packet to convert.
+ */
+DECLHIDDEN(void) utsProtocolReqH2N(PUTSPKTHDR pPktHdr);
+
+/**
+ * Converts a UTS request packet from network to host byte ordering.
+ *
+ * @returns nothing.
+ * @param   pPktHdr           The packet to convert.
+ */
+DECLHIDDEN(void) utsProtocolReqN2H(PUTSPKTHDR pPktHdr);
+
+/**
+ * Converts a UTS reply packet from host to network byte ordering.
+ *
+ * @returns nothing.
+ * @param   pPktHdr           The packet to convert.
+ */
+DECLHIDDEN(void) utsProtocolRepH2N(PUTSPKTHDR pPktHdr);
+
+/**
+ * Converts a UTS reply packet from network to host byte ordering.
+ *
+ * @returns nothing.
+ * @param   pPktHdr           The packet to convert.
+ */
+DECLHIDDEN(void) utsProtocolRepN2H(PUTSPKTHDR pPktHdr);
+
 RT_C_DECLS_END