Changeset 73930 in vbox

Timestamp:

Aug 28, 2018 6:09:54 PM (6 years ago)

Author:

vboxsync

Message:

IPRT/rest: Implemented parsing json response bodies. bugref:9167

Location:

trunk

Files:

• include/iprt/cpp/restbase.h (modified) (3 diffs)
• include/iprt/err.h (modified) (2 diffs)
• include/iprt/json.h (modified) (1 diff)
• src/VBox/Runtime/common/misc/json.cpp (modified) (1 diff)
• src/VBox/Runtime/common/rest/RTCRestClientResponseBase.cpp (modified) (4 diffs)

trunk/include/iprt/cpp/restbase.h

@@ -707 +707 @@
     int getHttpStatus() { return m_rcHttp; }
 
+    /**
+     * Getter for m_pErrInfo.
+     */
+    PCRTERRINFO  getErrIfno(void) const { return m_pErrInfo; }
+
+    /**
+     * Getter for m_strContentType.
+     */
+    RTCString const &getContentType(void) const { return m_strContentType; }
+
+
 protected:
     /** Negative numbers are IPRT errors, positive are HTTP status codes. */
-    int m_rcStatus;
+    int         m_rcStatus;
     /** The HTTP status code, VERR_NOT_AVAILABLE if not set. */
-    int m_rcHttp;
+    int         m_rcHttp;
     /** Error information. */
-    PRTERRINFO m_pErrInfo;
+    PRTERRINFO  m_pErrInfo;
     /** The value of the Content-Type header field. */
-    RTCString m_strContentType;
-
-    PRTERRINFO  allocErrInfo(void);
+    RTCString   m_strContentType;
+
+    PRTERRINFO  getErrInfo(void);
     void        deleteErrInfo(void);
     void        copyErrInfo(PCRTERRINFO pErrInfo);
+
+    /**
+     * Reports an error (or warning if a_rc non-negative).
+     *
+     * @returns a_rc
+     * @param   a_rc        The status code to report and return.  The first
+     *                      error status is assigned to m_rcStatus, subsequent
+     *                      ones as well as informational statuses are not
+     *                      recorded by m_rcStatus.
+     * @param   a_pszFormat The message format string.
+     * @param   ...         Message arguments.
+     */
+    int         addError(int a_rc, const char *a_pszFormat, ...);
 
     /**
@@ -735 +759 @@
     int extractHeaderFromBlob(const char *a_pszField, size_t a_cchField, const char *a_pchData, size_t a_cbData,
                               RTCString *a_pStrDst);
+
+    /**
+     * Helper that does the deserializing of the response body.
+     *
+     * @param   a_pDst      The destination object for the body content.
+     * @param   a_pchData   The body blob.
+     * @param   a_cbData    The size of the body blob.
+     */
+    void deserializeBody(RTCRestObjectBase *a_pDst, const char *a_pchData, size_t a_cbData);
+
+    /**
+     * Primary json cursor for parsing bodies.
+     */
+    class PrimaryJsonCursorForBody : public RTCRestJsonPrimaryCursor
+    {
+    public:
+        RTCRestClientResponseBase *m_pThat; /**< Pointer to response object. */
+        PrimaryJsonCursorForBody(RTJSONVAL hValue, const char *pszName, RTCRestClientResponseBase *a_pThat);
+        virtual int addError(RTCRestJsonCursor const &a_rCursor, int a_rc, const char *a_pszFormat, ...) RT_OVERRIDE;
+        virtual int unknownField(RTCRestJsonCursor const &a_rCursor) RT_OVERRIDE;
+    };
 };
 
@@ -821 +866 @@
     virtual void doCall(RTCRestClientRequestBase const &a_rRequest, RTHTTPMETHOD a_enmHttpMethod,
                         RTCRestClientResponseBase *a_pResponse);
+
 };
 

trunk/include/iprt/err.h

@@ -3194 +3194 @@
 /** Internal processing error \#5.  */
 #define VERR_ISOFS_IPE_5                                (-25395)
-
 /** @} */
 
@@ -3204 +3203 @@
 /** The chosen baudrate is invalid or not supported by the given serial port. */
 #define VERR_SERIALPORT_INVALID_BAUDRATE                (-25501)
-
+/** @} */
+
+
+/** @name RTCRest status codes
+ * @{ */
+/** Do not know how to handle the content type in the server response. */
+#define VERR_REST_RESPONSE_CONTENT_TYPE_NOT_SUPPORTED   (-25700)
+/** Invalid UTF-8 encoding in the response. */
+#define VERR_REST_RESPONSE_INVALID_UTF8_ENCODING        (-25701)
+/** Server response contains embedded zero character(s). */
+#define VERR_REST_RESPONSE_EMBEDDED_ZERO_CHAR           (-25702)
 /** @} */
 

trunk/include/iprt/json.h

@@ -88 +88 @@
  * @param   cbBuf           Size of the buffer.
  * @param   pErrInfo        Where to store extended error info. Optional.
+ *
+ * @todo    r=bird: The use of uint8_t makes no sense here since the parser
+ *          expects ASCII / UTF-8.  What's more, if this is a real buffer the
+ *          type should be 'const void *' rather than 'const uint8_t *'.
+ *          This function should be modified to reflect that it's really for
+ *          handling unterminated strings.
  */
 RTDECL(int) RTJsonParseFromBuf(PRTJSONVAL phJsonVal, const uint8_t *pbBuf, size_t cbBuf, PRTERRINFO pErrInfo);

trunk/src/VBox/Runtime/common/misc/json.cpp

@@ -1225 +1225 @@
     AssertPtrReturn(pszStr, VERR_INVALID_POINTER);
 
+    /** @todo r=bird: The rtJsonTokenizerParseFromString function does
+     *        strlen() on the whole pszStr for each read.  For larger strings (
+     *        longer than sizeof(Tokenizer.achBuf)) it would be good to join
+     *        forces with RTJsonParseFromBuf. */
     RTJSONTOKENIZER Tokenizer;
     int rc = rtJsonTokenizerInit(&Tokenizer, rtJsonTokenizerParseFromString, (void *)pszStr);

trunk/src/VBox/Runtime/common/rest/RTCRestClientResponseBase.cpp

@@ -125 +125 @@
 
 
-PRTERRINFO RTCRestClientResponseBase::allocErrInfo(void)
-{
+PRTERRINFO RTCRestClientResponseBase::getErrInfo(void)
+{
+    if (m_pErrInfo)
+        return m_pErrInfo;
     size_t cbMsg = _4K;
     m_pErrInfo = (PRTERRINFO)RTMemAllocZ(sizeof(*m_pErrInfo) + cbMsg);
@@ -155 +157 @@
         m_pErrInfo->apvReserved[1] = NULL;
     }
+}
+
+
+int RTCRestClientResponseBase::addError(int rc, const char *pszFormat, ...)
+{
+    PRTERRINFO pErrInfo = getErrInfo();
+    if (pErrInfo)
+    {
+        va_list va;
+        va_start(va, pszFormat);
+        if (   !RTErrInfoIsSet(pErrInfo)
+            || pErrInfo->cbMsg == 0
+            || pErrInfo->pszMsg[pErrInfo->cbMsg - 1] == '\n')
+            RTErrInfoAddV(pErrInfo, rc, pszFormat, va);
+        else
+            RTErrInfoAddF(pErrInfo, rc, "\n%N", pszFormat, &va);
+        va_end(va);
+    }
+    if (RT_SUCCESS(m_rcStatus) && RT_FAILURE_NP(rc))
+        m_rcStatus = rc;
+    return rc;
 }
 
@@ -198 +221 @@
             int rc = a_pStrDst->assignNoThrow(a_pchData, cchField);
             if (RT_SUCCESS(rc))
-                RTStrPurgeEncoding(a_pStrDst->mutableRaw());
+                RTStrPurgeEncoding(a_pStrDst->mutableRaw()); /** @todo this is probably a little wrong... */
             return rc;
         }
@@ -210 +233 @@
 }
 
+
+
+RTCRestClientResponseBase::PrimaryJsonCursorForBody::PrimaryJsonCursorForBody(RTJSONVAL hValue, const char *pszName,
+                                                                              RTCRestClientResponseBase *a_pThat)
+    : RTCRestJsonPrimaryCursor(hValue, pszName, a_pThat->getErrInfo())
+    , m_pThat(a_pThat)
+{
+}
+
+
+int RTCRestClientResponseBase::PrimaryJsonCursorForBody::addError(RTCRestJsonCursor const &a_rCursor, int a_rc,
+                                                                  const char *a_pszFormat, ...)
+{
+    va_list va;
+    va_start(va, a_pszFormat);
+    char szPath[256];
+    m_pThat->addError(a_rc, "response body/%s: %N", getPath(a_rCursor, szPath, sizeof(szPath)), a_pszFormat, &va);
+    va_end(va);
+    return a_rc;
+}
+
+
+int RTCRestClientResponseBase::PrimaryJsonCursorForBody::unknownField(RTCRestJsonCursor const &a_rCursor)
+{
+    char szPath[256];
+    m_pThat->addError(VWRN_NOT_FOUND, "response body/%s: unknown field (type %s)",
+                      getPath(a_rCursor, szPath, sizeof(szPath)), RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue)));
+    return VWRN_NOT_FOUND;
+}
+
+
+void RTCRestClientResponseBase::deserializeBody(RTCRestObjectBase *a_pDst, const char *a_pchData, size_t a_cbData)
+{
+    if (m_strContentType.startsWith("application/json;"))
+    {
+        int rc = RTStrValidateEncodingEx(a_pchData, a_cbData, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH);
+        if (RT_SUCCESS(rc))
+        {
+            RTERRINFOSTATIC ErrInfo;
+            RTJSONVAL hValue;
+            rc = RTJsonParseFromBuf(&hValue, (const uint8_t *)a_pchData, a_cbData, RTErrInfoInitStatic(&ErrInfo));
+            if (RT_SUCCESS(rc))
+            {
+                PrimaryJsonCursorForBody PrimaryCursor(hValue, a_pDst->getType(), this); /* note: consumes hValue */
+                a_pDst->deserializeFromJson(PrimaryCursor.m_Cursor);
+            }
+            else if (RTErrInfoIsSet(&ErrInfo.Core))
+                addError(rc, "Error %Rrc parsing server response as JSON (type %s): %s",
+                         rc, a_pDst->getType(), ErrInfo.Core.pszMsg);
+            else
+                addError(rc, "Error %Rrc parsing server response as JSON (type %s)", rc, a_pDst->getType());
+        }
+        else if (rc == VERR_INVALID_UTF8_ENCODING)
+            addError(VERR_REST_RESPONSE_INVALID_UTF8_ENCODING, "Invalid UTF-8 body encoding (object type %s; Content-Type: %s)",
+                     a_pDst->getType(), m_strContentType.c_str());
+        else if (rc == VERR_BUFFER_UNDERFLOW)
+            addError(VERR_REST_RESPONSE_EMBEDDED_ZERO_CHAR, "Embedded zero character in response (object type %s; Content-Type: %s)",
+                     a_pDst->getType(), m_strContentType.c_str());
+        else
+            addError(rc, "Unexpected body validation error (object type %s; Content-Type: %s): %Rrc",
+                     a_pDst->getType(), m_strContentType.c_str(), rc);
+    }
+    else
+        addError(VERR_REST_RESPONSE_CONTENT_TYPE_NOT_SUPPORTED, "Unsupported content type for '%s': %s",
+                 a_pDst->getType(), m_strContentType.c_str());
+}
+