diff options
Diffstat (limited to 'src/VBox/Runtime/common/rest')
15 files changed, 6292 insertions, 0 deletions
diff --git a/src/VBox/Runtime/common/rest/Makefile.kup b/src/VBox/Runtime/common/rest/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/Runtime/common/rest/Makefile.kup diff --git a/src/VBox/Runtime/common/rest/RTCRestAnyObject.cpp b/src/VBox/Runtime/common/rest/RTCRestAnyObject.cpp new file mode 100644 index 00000000..3d771ddd --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestAnyObject.cpp @@ -0,0 +1,596 @@ +/* $Id: RTCRestAnyObject.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestAnyObject implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restanyobject.h> + +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/cpp/restoutput.h> + + + +/** + * Default constructor. + */ +RTCRestAnyObject::RTCRestAnyObject() RT_NOEXCEPT + : RTCRestObjectBase() + , m_pData(NULL) +{ + m_fNullIndicator = true; +} + + +/** + * Destructor. + */ +RTCRestAnyObject::~RTCRestAnyObject() +{ + if (m_pData) + { + delete m_pData; + m_pData = NULL; + } +} + + +/** + * Copy constructor. + */ +RTCRestAnyObject::RTCRestAnyObject(RTCRestAnyObject const &a_rThat) + : RTCRestObjectBase() + , m_pData(NULL) +{ + int rc = assignCopy(a_rThat); + if (RT_FAILURE(rc)) + throw std::bad_alloc(); +} + + +/** + * Copy assignment operator. + */ +RTCRestAnyObject &RTCRestAnyObject::operator=(RTCRestAnyObject const &a_rThat) +{ + int rc = assignCopy(a_rThat); + if (RT_FAILURE(rc)) + throw std::bad_alloc(); + return *this; +} + + +/** + * Safe copy assignment method. + */ +int RTCRestAnyObject::assignCopy(RTCRestAnyObject const &a_rThat) RT_NOEXCEPT +{ + setNull(); + if ( !a_rThat.m_fNullIndicator + && a_rThat.m_pData != NULL) + { + kTypeClass enmType = a_rThat.m_pData->typeClass(); + switch (enmType) + { + case kTypeClass_Bool: return assignCopy(*(RTCRestBool const *)a_rThat.m_pData); + case kTypeClass_Int64: return assignCopy(*(RTCRestInt64 const *)a_rThat.m_pData); + case kTypeClass_Int32: return assignCopy(*(RTCRestInt32 const *)a_rThat.m_pData); + case kTypeClass_Int16: return assignCopy(*(RTCRestInt16 const *)a_rThat.m_pData); + case kTypeClass_Double: return assignCopy(*(RTCRestDouble const *)a_rThat.m_pData); + case kTypeClass_String: return assignCopy(*(RTCRestString const *)a_rThat.m_pData); + case kTypeClass_Array: return assignCopy(*(RTCRestArray<RTCRestAnyObject> const *)a_rThat.m_pData); + case kTypeClass_StringMap: return assignCopy(*(RTCRestStringMap<RTCRestAnyObject> const *)a_rThat.m_pData); + + /* Currently unused of invalid: */ + case kTypeClass_Date: + case kTypeClass_Uuid: + case kTypeClass_Binary: + case kTypeClass_StringEnum: + case kTypeClass_AnyObject: + case kTypeClass_DataObject: + case kTypeClass_Invalid: + AssertFailedReturn(VERR_REST_INTERNAL_ERROR_7); + } + } + return VINF_SUCCESS; +} + + +/** + * Safe copy assignment method, boolean variant. + */ +int RTCRestAnyObject::assignCopy(RTCRestBool const &a_rThat) RT_NOEXCEPT +{ + setNull(); + RTCRestBool *pData = new (std::nothrow) RTCRestBool(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignCopy(a_rThat); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe copy assignment method, int64_t variant. + */ +int RTCRestAnyObject::assignCopy(RTCRestInt64 const &a_rThat) RT_NOEXCEPT +{ + setNull(); + RTCRestInt64 *pData = new (std::nothrow) RTCRestInt64(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignCopy(a_rThat); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe copy assignment method, int32_t variant. + */ +int RTCRestAnyObject::assignCopy(RTCRestInt32 const &a_rThat) RT_NOEXCEPT +{ + setNull(); + RTCRestInt32 *pData = new (std::nothrow) RTCRestInt32(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignCopy(a_rThat); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe copy assignment method, int16_t variant. + */ +int RTCRestAnyObject::assignCopy(RTCRestInt16 const &a_rThat) RT_NOEXCEPT +{ + setNull(); + RTCRestInt16 *pData = new (std::nothrow) RTCRestInt16(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignCopy(a_rThat); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe copy assignment method, double variant. + */ +int RTCRestAnyObject::assignCopy(RTCRestDouble const &a_rThat) RT_NOEXCEPT +{ + setNull(); + RTCRestDouble *pData = new (std::nothrow) RTCRestDouble(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignCopy(a_rThat); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe copy assignment method, string variant. + */ +int RTCRestAnyObject::assignCopy(RTCRestString const &a_rThat) RT_NOEXCEPT +{ + setNull(); + RTCRestString *pData = new (std::nothrow) RTCRestString(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignCopy(a_rThat); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe copy assignment method, array variant. + */ +int RTCRestAnyObject::assignCopy(RTCRestArray<RTCRestAnyObject> const &a_rThat) RT_NOEXCEPT +{ + setNull(); + RTCRestArray<RTCRestAnyObject> *pData = new (std::nothrow) RTCRestArray<RTCRestAnyObject>(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignCopy(a_rThat); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe copy assignment method, string map variant. + */ +int RTCRestAnyObject::assignCopy(RTCRestStringMap<RTCRestAnyObject> const &a_rThat) RT_NOEXCEPT +{ + setNull(); + RTCRestStringMap<RTCRestAnyObject> *pData = new (std::nothrow) RTCRestStringMap<RTCRestAnyObject>(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignCopy(a_rThat); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe value assignment method, boolean variant. + */ +int RTCRestAnyObject::assignValue(bool a_fValue) RT_NOEXCEPT +{ + setNull(); + RTCRestBool *pData = new (std::nothrow) RTCRestBool(); + if (pData) + { + m_pData = pData; + pData->assignValue(a_fValue); + m_fNullIndicator = false; + return VINF_SUCCESS; + } + return VERR_NO_MEMORY; +} + + +/** + * Safe value assignment method, int64_t variant. + */ +int RTCRestAnyObject::assignValue(int64_t a_iValue) RT_NOEXCEPT +{ + setNull(); + RTCRestInt64 *pData = new (std::nothrow) RTCRestInt64(); + if (pData) + { + m_pData = pData; + pData->assignValue(a_iValue); + m_fNullIndicator = false; + return VINF_SUCCESS; + } + return VERR_NO_MEMORY; +} + + +/** + * Safe value assignment method, int32_t variant. + */ +int RTCRestAnyObject::assignValue(int32_t a_iValue) RT_NOEXCEPT +{ + setNull(); + RTCRestInt32 *pData = new (std::nothrow) RTCRestInt32(); + if (pData) + { + m_pData = pData; + pData->assignValue(a_iValue); + m_fNullIndicator = false; + return VINF_SUCCESS; + } + return VERR_NO_MEMORY; +} + + +/** + * Safe value assignment method, int16_t variant. + */ +int RTCRestAnyObject::assignValue(int16_t a_iValue) RT_NOEXCEPT +{ + setNull(); + RTCRestInt16 *pData = new (std::nothrow) RTCRestInt16(); + if (pData) + { + m_pData = pData; + pData->assignValue(a_iValue); + m_fNullIndicator = false; + return VINF_SUCCESS; + } + return VERR_NO_MEMORY; +} + + +/** + * Safe value assignment method, double variant. + */ +int RTCRestAnyObject::assignValue(double a_iValue) RT_NOEXCEPT +{ + setNull(); + RTCRestDouble *pData = new (std::nothrow) RTCRestDouble(); + if (pData) + { + m_pData = pData; + pData->assignValue(a_iValue); + m_fNullIndicator = false; + return VINF_SUCCESS; + } + return VERR_NO_MEMORY; +} + + +/** + * Safe value assignment method, string variant. + */ +int RTCRestAnyObject::assignValue(RTCString const &a_rValue) RT_NOEXCEPT +{ + setNull(); + RTCRestString *pData = new (std::nothrow) RTCRestString(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignNoThrow(a_rValue); + } + return VERR_NO_MEMORY; +} + + +/** + * Safe value assignment method, C-string variant. + */ +int RTCRestAnyObject::assignValue(const char *a_pszValue) RT_NOEXCEPT +{ + setNull(); + RTCRestString *pData = new (std::nothrow) RTCRestString(); + if (pData) + { + m_pData = pData; + m_fNullIndicator = false; + return pData->assignNoThrow(a_pszValue); + } + return VERR_NO_MEMORY; +} + + +RTCRestObjectBase *RTCRestAnyObject::baseClone() const RT_NOEXCEPT +{ + RTCRestAnyObject *pClone = new (std::nothrow) RTCRestAnyObject(); + if (pClone) + { + int rc = pClone->assignCopy(*this); + if (RT_SUCCESS(rc)) + return pClone; + delete pClone; + } + return NULL; +} + + +int RTCRestAnyObject::setNull(void) RT_NOEXCEPT +{ + if (m_pData) + { + delete m_pData; + m_pData = NULL; + } + return RTCRestObjectBase::setNull(); +} + + +int RTCRestAnyObject::resetToDefault() RT_NOEXCEPT +{ + if (m_pData) + return m_pData->resetToDefault(); + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestAnyObject::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (m_pData) + return m_pData->serializeAsJson(a_rDst); + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestAnyObject::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + setNull(); + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + switch (enmType) + { + case RTJSONVALTYPE_OBJECT: + { + RTCRestStringMap<RTCRestAnyObject> *pMap = new (std::nothrow) RTCRestStringMap<RTCRestAnyObject>(); + if (pMap) + { + m_pData = pMap; + m_fNullIndicator = false; + return pMap->deserializeFromJson(a_rCursor); + } + break; + } + + case RTJSONVALTYPE_ARRAY: + { + RTCRestArray<RTCRestAnyObject> *pArray = new (std::nothrow) RTCRestArray<RTCRestAnyObject>(); + if (pArray) + { + m_pData = pArray; + m_fNullIndicator = false; + return pArray->deserializeFromJson(a_rCursor); + } + break; + } + + case RTJSONVALTYPE_STRING: + { + RTCRestString *pString = new (std::nothrow) RTCRestString(); + if (pString) + { + m_pData = pString; + m_fNullIndicator = false; + return pString->deserializeFromJson(a_rCursor); + } + break; + } + + case RTJSONVALTYPE_INTEGER: + { + RTCRestInt64 *pInt64 = new (std::nothrow) RTCRestInt64(); + if (pInt64) + { + m_pData = pInt64; + m_fNullIndicator = false; + return pInt64->deserializeFromJson(a_rCursor); + } + break; + } + + case RTJSONVALTYPE_NUMBER: + { + RTCRestDouble *pDouble = new (std::nothrow) RTCRestDouble(); + if (pDouble) + { + m_pData = pDouble; + m_fNullIndicator = false; + return pDouble->deserializeFromJson(a_rCursor); + } + break; + } + + case RTJSONVALTYPE_NULL: + return VINF_SUCCESS; + + case RTJSONVALTYPE_TRUE: + case RTJSONVALTYPE_FALSE: + { + RTCRestBool *pBool = new (std::nothrow) RTCRestBool(); + if (pBool) + { + m_pData = pBool; + m_fNullIndicator = false; + pBool->assignValue(enmType == RTJSONVALTYPE_TRUE); + return VINF_SUCCESS; + } + break; + } + + /* no break. */ + case RTJSONVALTYPE_INVALID: + case RTJSONVALTYPE_32BIT_HACK: + break; + } + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_WRONG_TYPE, "RTCRestAnyObject found %d (%s)", + enmType, RTJsonValueTypeName(enmType)); +} + + +int RTCRestAnyObject::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + if (m_pData) + return m_pData->toString(a_pDst, a_fFlags); + if (a_fFlags & kToString_Append) + return a_pDst->appendNoThrow(RT_STR_TUPLE("null")); + return a_pDst->assignNoThrow(RT_STR_TUPLE("null")); +} + + +int RTCRestAnyObject::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + return RTCRestObjectBase::fromString(a_rValue, a_pszName, a_pErrInfo, a_fFlags); +} + + +RTCRestObjectBase::kTypeClass RTCRestAnyObject::typeClass(void) const RT_NOEXCEPT +{ + return kTypeClass_AnyObject; +} + + +const char *RTCRestAnyObject::typeName(void) const RT_NOEXCEPT +{ + if (m_pData) + { + kTypeClass enmType = m_pData->typeClass(); + switch (enmType) + { + case kTypeClass_Bool: return "RTCRestAnyObject[Bool]"; + case kTypeClass_Int64: return "RTCRestAnyObject[Int64]"; + case kTypeClass_Int32: return "RTCRestAnyObject[Int32]"; + case kTypeClass_Int16: return "RTCRestAnyObject[Int16]"; + case kTypeClass_Double: return "RTCRestAnyObject[Double]"; + case kTypeClass_String: return "RTCRestAnyObject[String]"; + case kTypeClass_Array: return "RTCRestAnyObject[Array]"; + case kTypeClass_StringMap: return "RTCRestAnyObject[StringMap]"; + + /* Currently unused of invalid: */ + case kTypeClass_Date: + case kTypeClass_Uuid: + case kTypeClass_Binary: + case kTypeClass_StringEnum: + case kTypeClass_DataObject: + case kTypeClass_AnyObject: + case kTypeClass_Invalid: + AssertFailed(); + } + } + return "RTCRestAnyObject"; +} + + +/** + * Factory method. + */ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestAnyObject::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestAnyObject(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestAnyObject::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) +{ + RTCRestObjectBase *pObj = createInstance(); + *a_ppInstance = pObj; + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestArrayBase.cpp b/src/VBox/Runtime/common/rest/RTCRestArrayBase.cpp new file mode 100644 index 00000000..61efe7b1 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestArrayBase.cpp @@ -0,0 +1,486 @@ +/* $Id: RTCRestArrayBase.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestArrayBase implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restarray.h> + +#include <iprt/err.h> +#include <iprt/string.h> +#include <iprt/cpp/restoutput.h> + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** Separator characters. */ +static char const g_szSep[RTCRestObjectBase::kCollectionFormat_Mask + 1] = ",, \t|,,"; + + +/** + * Default destructor. + */ +RTCRestArrayBase::RTCRestArrayBase() RT_NOEXCEPT + : RTCRestObjectBase() + , m_papElements(NULL) + , m_cElements(0) + , m_cCapacity(0) +{ +} + + +#if 0 /* should not be used */ +/** + * Copy constructor. + */ +RTCRestArrayBase::RTCRestArrayBase(RTCRestArrayBase const &a_rThat); +#endif + +/** + * Destructor. + */ +RTCRestArrayBase::~RTCRestArrayBase() +{ + clear(); + + if (m_papElements) + { + RTMemFree(m_papElements); + m_papElements = NULL; + m_cCapacity = 0; + } +} + + +#if 0 /* should not be used */ +/** + * Copy assignment operator. + */ +RTCRestArrayBase &RTCRestArrayBase::operator=(RTCRestArrayBase const &a_rThat); +#endif + + +/********************************************************************************************************************************* +* Overridden methods * +*********************************************************************************************************************************/ + +RTCRestObjectBase *RTCRestArrayBase::baseClone() const RT_NOEXCEPT +{ + RTCRestArrayBase *pClone = createClone(); + if (pClone) + { + int rc = pClone->copyArrayWorkerNoThrow(*this); + if (RT_SUCCESS(rc)) + return pClone; + delete pClone; + } + return NULL; +} + + +int RTCRestArrayBase::resetToDefault() RT_NOEXCEPT +{ + /* The default state of an array is empty. At least for now. */ + clear(); + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestArrayBase::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + { + uint32_t const uOldState = a_rDst.beginArray(); + for (size_t i = 0; i < m_cElements; i++) + { + a_rDst.valueSeparator(); + m_papElements[i]->serializeAsJson(a_rDst); + } + a_rDst.endArray(uOldState); + } + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestArrayBase::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + /* + * Make sure the object starts out with an empty map. + */ + if (m_cElements > 0) + clear(); + m_fNullIndicator = false; + + /* + * Iterate the array values. + */ + RTJSONIT hIterator; + int rcRet = RTJsonIteratorBeginArray(a_rCursor.m_hValue, &hIterator); + if (RT_SUCCESS(rcRet)) + { + for (size_t idxName = 0;; idxName++) + { + /* Setup sub-cursor. */ + RTCRestJsonCursor SubCursor(a_rCursor); + int rc = RTJsonIteratorQueryValue(hIterator, &SubCursor.m_hValue, &SubCursor.m_pszName); + if (RT_SUCCESS(rc)) + { + char szName[32]; + RTStrPrintf(szName, sizeof(szName), "[%u]", idxName); + SubCursor.m_pszName = szName; + + /* Call the static deserializeInstanceFromJson method of the value class. */ + RTCRestObjectBase *pObj = NULL; + rc = deserializeValueInstanceFromJson(SubCursor, &pObj); + if (RT_SUCCESS(rc)) + Assert(pObj); + else if (RT_SUCCESS(rcRet)) + rcRet = rc; + if (pObj) + { + rc = insertWorker(~(size_t)0, pObj, false /*a_fReplace*/); + if (RT_SUCCESS(rc)) + { /* likely */ } + else + { + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rc, "Array insert failed (index %zu): %Rrc", + idxName, rc); + delete pObj; + } + } + } + else + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonIteratorQueryValue failed: %Rrc", rc); + + /* + * Advance. + */ + rc = RTJsonIteratorNext(hIterator); + if (RT_SUCCESS(rc)) + { /* likely */ } + else if (rc == VERR_JSON_ITERATOR_END) + break; + else + { + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonIteratorNext failed: %Rrc", rc); + break; + } + } + + RTJsonIteratorFree(hIterator); + } + else if (rcRet == VERR_JSON_IS_EMPTY) + rcRet = VINF_SUCCESS; + else if ( rcRet == VERR_JSON_VALUE_INVALID_TYPE + && RTJsonValueGetType(a_rCursor.m_hValue) == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + rcRet = VINF_SUCCESS; + } + else + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rcRet, + "RTJsonIteratorBeginrray failed: %Rrc (type %s)", + rcRet, RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); + return rcRet; + +} + + +int RTCRestArrayBase::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + int rc; + if (!m_fNullIndicator) + { + if (m_cElements) + { + char const chSep = g_szSep[a_fFlags & kCollectionFormat_Mask]; + + rc = m_papElements[0]->toString(a_pDst, a_fFlags); + for (size_t i = 1; RT_SUCCESS(rc) && i < m_cElements; i++) + { + rc = a_pDst->appendNoThrow(chSep); + if (RT_SUCCESS(rc)) + rc = m_papElements[i]->toString(a_pDst, a_fFlags | kToString_Append); + } + } + else + { + if (!(a_fFlags & kToString_Append)) + a_pDst->setNull(); + rc = VINF_SUCCESS; + } + } + else if (a_fFlags & kToString_Append) + rc = a_pDst->appendNoThrow(RT_STR_TUPLE("null")); + else + rc = a_pDst->appendNoThrow(RT_STR_TUPLE("null")); + + return rc; +} + + +int RTCRestArrayBase::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + /* + * Clear the array. If the string is empty, we have an empty array and is done. + */ + if (!(a_fFlags & kToString_Append)) + clear(); + if (a_rValue.isEmpty()) + return VINF_SUCCESS; + + /* + * Look for a separator so we don't mistake a initial null element for a null array. + */ + char const chSep = g_szSep[a_fFlags & kCollectionFormat_Mask]; + size_t offSep = a_rValue.find(chSep); + if ( offSep != RTCString::npos + || !a_rValue.startsWithWord("null", RTCString::CaseInsensitive)) + { + RTCString strTmp; + size_t offStart = 0; + int rcRet = VINF_SUCCESS; + for (;;) + { + /* Copy the element value into its own string buffer. */ + int rc = strTmp.assignNoThrow(a_rValue, offStart, (offSep == RTCString::npos ? a_rValue.length() : offSep) - offStart); + AssertRCReturn(rc, rc); + + /* Create a new element, insert it and pass it the value string. */ + RTCRestObjectBase *pObj = createValue(); + AssertPtrReturn(pObj, VERR_NO_MEMORY); + + rc = insertWorker(~(size_t)0, pObj, false); + AssertRCReturnStmt(rc, delete pObj, rc); + + char szName[128]; + RTStrPrintf(szName, sizeof(szName), "%.*s[%zu]", 116, a_pszName ? a_pszName : "", size()); + rc = pObj->fromString(strTmp, a_pszName, a_pErrInfo, 0); + if (RT_SUCCESS(rc)) + { /* likely */ } + else if (RT_SUCCESS(rcRet)) + rcRet = rc; + + /* + * Done? Otherwise advance. + */ + if (offSep == RTCString::npos) + break; + offStart = offSep + 1; + offSep = a_rValue.find(chSep, offStart); + } + return rcRet; + } + + /* + * Consider this a null array even if it could also be an array with a single + * null element. This is just an artifact of an imperfect serialization format. + */ + setNull(); + return VINF_SUCCESS; +} + + +RTCRestObjectBase::kTypeClass RTCRestArrayBase::typeClass(void) const RT_NOEXCEPT +{ + return kTypeClass_Array; +} + + +const char *RTCRestArrayBase::typeName(void) const RT_NOEXCEPT +{ + return "RTCRestArray<ElementType>"; +} + + + +/********************************************************************************************************************************* +* Array methods * +*********************************************************************************************************************************/ + +void RTCRestArrayBase::clear() RT_NOEXCEPT +{ + size_t i = m_cElements; + while (i-- > 0) + { + delete m_papElements[i]; + m_papElements[i] = NULL; + } + m_cElements = 0; + m_fNullIndicator = false; +} + + +bool RTCRestArrayBase::removeAt(size_t a_idx) RT_NOEXCEPT +{ + if (a_idx == ~(size_t)0) + a_idx = m_cElements - 1; + if (a_idx < m_cElements) + { + delete m_papElements[a_idx]; + m_papElements[a_idx] = NULL; + + m_cElements--; + if (a_idx < m_cElements) + memmove(&m_papElements[a_idx], &m_papElements[a_idx + 1], (m_cElements - a_idx) * sizeof(m_papElements[0])); + } + return false; +} + + +int RTCRestArrayBase::ensureCapacity(size_t a_cEnsureCapacity) RT_NOEXCEPT +{ + if (m_cCapacity < a_cEnsureCapacity) + { + if (a_cEnsureCapacity < 512) + a_cEnsureCapacity = RT_ALIGN_Z(a_cEnsureCapacity, 16); + else if (a_cEnsureCapacity < 16384) + a_cEnsureCapacity = RT_ALIGN_Z(a_cEnsureCapacity, 128); + else + a_cEnsureCapacity = RT_ALIGN_Z(a_cEnsureCapacity, 512); + + void *pvNew = RTMemRealloc(m_papElements, sizeof(m_papElements[0]) * a_cEnsureCapacity); + if (pvNew) + { + m_papElements = (RTCRestObjectBase **)pvNew; + memset(&m_papElements[m_cCapacity], 0, (a_cEnsureCapacity - m_cCapacity) * sizeof(sizeof(m_papElements[0]))); + m_cCapacity = a_cEnsureCapacity; + } + else + return VERR_NO_MEMORY; + } + return VINF_SUCCESS; +} + + +int RTCRestArrayBase::copyArrayWorkerNoThrow(RTCRestArrayBase const &a_rThat) RT_NOEXCEPT +{ + int rc; + clear(); + if (a_rThat.m_cElements == 0) + { + m_fNullIndicator = a_rThat.m_fNullIndicator; + rc = VINF_SUCCESS; + } + else + { + Assert(!a_rThat.m_fNullIndicator); + rc = ensureCapacity(a_rThat.m_cElements); + if (RT_SUCCESS(rc)) + { + for (size_t i = 0; i < a_rThat.m_cElements; i++) + { + AssertPtr(a_rThat.m_papElements[i]); + rc = insertCopyWorker(i, *a_rThat.m_papElements[i], false); + if (RT_SUCCESS(rc)) + { /* likely */ } + else + return rc; + } + } + } + return rc; +} + +void RTCRestArrayBase::copyArrayWorkerMayThrow(RTCRestArrayBase const &a_rThat) +{ + int rc = copyArrayWorkerNoThrow(a_rThat); + if (RT_SUCCESS(rc)) + return; + throw std::bad_alloc(); +} + + +int RTCRestArrayBase::insertWorker(size_t a_idx, RTCRestObjectBase *a_pValue, bool a_fReplace) RT_NOEXCEPT +{ + AssertPtrReturn(a_pValue, VERR_INVALID_POINTER); + + if (a_idx == ~(size_t)0) + a_idx = m_cElements; + + if (a_idx <= m_cElements) + { + if (a_idx == m_cElements || !a_fReplace) + { + /* Make sure we've got array space. */ + if (m_cElements + 1 < m_cCapacity) + { /* kind of likely */ } + else + { + int rc = ensureCapacity(m_cElements + 1); + if (RT_SUCCESS(rc)) + { /* likely */ } + else + return rc; + } + + /* Shift following elements before inserting. */ + if (a_idx < m_cElements) + memmove(&m_papElements[a_idx + 1], &m_papElements[a_idx], (m_cElements - a_idx) * sizeof(m_papElements[0])); + m_papElements[a_idx] = a_pValue; + m_cElements++; +#ifdef RT_STRICT + for (size_t i = 0; i < m_cElements; i++) + AssertPtr(m_papElements[i]); +#endif + m_fNullIndicator = false; + return VINF_SUCCESS; + } + + /* Replace element. */ + delete m_papElements[a_idx]; + m_papElements[a_idx] = a_pValue; + m_fNullIndicator = false; + return VWRN_ALREADY_EXISTS; + } + return VERR_OUT_OF_RANGE; +} + + +int RTCRestArrayBase::insertCopyWorker(size_t a_idx, RTCRestObjectBase const &a_rValue, bool a_fReplace) RT_NOEXCEPT +{ + int rc; + RTCRestObjectBase *pValueCopy = a_rValue.baseClone(); + if (pValueCopy) + { + rc = insertWorker(a_idx, pValueCopy, a_fReplace); + if (RT_SUCCESS(rc)) + { /* likely */ } + else + delete pValueCopy; + } + else + rc = VERR_NO_MEMORY; + return rc; +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestClientApiBase.cpp b/src/VBox/Runtime/common/rest/RTCRestClientApiBase.cpp new file mode 100644 index 00000000..c0aef3d2 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestClientApiBase.cpp @@ -0,0 +1,298 @@ +/* $Id: RTCRestClientApiBase.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestClientApiBase implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restclient.h> + +#include <iprt/assert.h> +#include <iprt/ctype.h> +#include <iprt/errcore.h> +#include <iprt/http.h> +#include <iprt/log.h> +#include <iprt/uri.h> + + +/** + * Default constructor. + */ +RTCRestClientApiBase::RTCRestClientApiBase() RT_NOEXCEPT + : m_hHttp(NIL_RTHTTP) +{ +} + + +/** + * The destructor. + */ +RTCRestClientApiBase::~RTCRestClientApiBase() +{ + if (m_hHttp != NIL_RTHTTP) + { + int rc = RTHttpDestroy(m_hHttp); + AssertRC(rc); + m_hHttp = NIL_RTHTTP; + } +} + + +const char *RTCRestClientApiBase::getServerUrl(void) const RT_NOEXCEPT +{ + if (m_strServerUrl.isEmpty()) + return getDefaultServerUrl(); + return m_strServerUrl.c_str(); +} + + +int RTCRestClientApiBase::setServerUrl(const char *a_pszUrl) RT_NOEXCEPT +{ +#ifdef RT_STRICT + if (a_pszUrl) + { + RTURIPARSED Parsed; + int rc = RTUriParse(a_pszUrl, &Parsed); + AssertRC(rc); + } +#endif + + return m_strServerUrl.assignNoThrow(a_pszUrl); +} + + +int RTCRestClientApiBase::setServerUrlPart(const char *a_pszServerUrl, size_t a_offDst, size_t a_cchDst, + const char *a_pszSrc, size_t a_cchSrc) RT_NOEXCEPT +{ + if ( a_cchDst == a_cchSrc + && memcmp(&a_pszServerUrl[0], a_pszSrc, a_cchSrc) == 0) + return VINF_SUCCESS; + + if (m_strServerUrl.isEmpty()) + { + int rc = m_strServerUrl.assignNoThrow(a_pszServerUrl); + AssertRCReturn(rc, rc); + } + return m_strServerUrl.replaceNoThrow(a_offDst, a_cchDst, a_pszSrc, a_cchSrc); +} + + +int RTCRestClientApiBase::setServerScheme(const char *a_pszScheme) RT_NOEXCEPT +{ + /* + * Validate. + */ + AssertReturn(a_pszScheme, VERR_INVALID_POINTER); + size_t const cchScheme = strlen(a_pszScheme); + AssertReturn(cchScheme > 0, VERR_INVALID_PARAMETER); + Assert(cchScheme < 16); +#ifdef RT_STRICT + for (size_t i = 0; i < cchScheme; i++) + Assert(RT_C_IS_ALNUM(a_pszScheme[i])); +#endif + + /* + * Parse, compare & replace. + */ + RTURIPARSED Parsed; + const char *pszUrl = getServerUrl(); + int rc = RTUriParse(pszUrl, &Parsed); + AssertRCReturn(rc, rc); + return setServerUrlPart(pszUrl, 0, Parsed.cchScheme, a_pszScheme, cchScheme); +} + + +int RTCRestClientApiBase::setServerAuthority(const char *a_pszAuthority) RT_NOEXCEPT +{ + /* + * Validate. + */ + AssertReturn(a_pszAuthority, VERR_INVALID_POINTER); + size_t const cchAuthority = strlen(a_pszAuthority); + AssertReturn(cchAuthority > 0, VERR_INVALID_PARAMETER); + Assert(memchr(a_pszAuthority, '/', cchAuthority) == NULL); + Assert(memchr(a_pszAuthority, '\\', cchAuthority) == NULL); + Assert(memchr(a_pszAuthority, '#', cchAuthority) == NULL); + Assert(memchr(a_pszAuthority, '?', cchAuthority) == NULL); + + /* + * Parse, compare & replace. + */ + RTURIPARSED Parsed; + const char *pszUrl = getServerUrl(); + int rc = RTUriParse(pszUrl, &Parsed); + AssertRCReturn(rc, rc); + return setServerUrlPart(pszUrl, Parsed.offAuthority, Parsed.cchAuthority, a_pszAuthority, cchAuthority); +} + + +int RTCRestClientApiBase::setServerBasePath(const char *a_pszBasePath) RT_NOEXCEPT +{ + /* + * Validate. + */ + AssertReturn(a_pszBasePath, VERR_INVALID_POINTER); + size_t const cchBasePath = strlen(a_pszBasePath); + AssertReturn(cchBasePath > 0, VERR_INVALID_PARAMETER); + Assert(memchr(a_pszBasePath, '?', cchBasePath) == NULL); + Assert(memchr(a_pszBasePath, '#', cchBasePath) == NULL); + + /* + * Parse, compare & replace. + */ + RTURIPARSED Parsed; + const char *pszUrl = getServerUrl(); + int rc = RTUriParse(pszUrl, &Parsed); + AssertRCReturn(rc, rc); + return setServerUrlPart(pszUrl, Parsed.offPath, Parsed.cchPath, a_pszBasePath, cchBasePath); +} + + +int RTCRestClientApiBase::reinitHttpInstance() RT_NOEXCEPT +{ + if (m_hHttp != NIL_RTHTTP) + return RTHttpReset(m_hHttp, 0 /*fFlags*/); + + int rc = RTHttpCreate(&m_hHttp); + if (RT_FAILURE(rc)) + m_hHttp = NIL_RTHTTP; + return rc; +} + + +int RTCRestClientApiBase::xmitReady(RTHTTP a_hHttp, RTCString const &a_rStrFullUrl, RTHTTPMETHOD a_enmHttpMethod, + RTCString const &a_rStrXmitBody, uint32_t a_fFlags) RT_NOEXCEPT +{ + RT_NOREF(a_hHttp, a_rStrFullUrl, a_enmHttpMethod, a_rStrXmitBody, a_fFlags); + return VINF_SUCCESS; +} + + +int RTCRestClientApiBase::doCall(RTCRestClientRequestBase const &a_rRequest, RTHTTPMETHOD a_enmHttpMethod, + RTCRestClientResponseBase *a_pResponse, const char *a_pszMethod, uint32_t a_fFlags) RT_NOEXCEPT +{ + LogFlow(("doCall: %s %s\n", a_pszMethod, RTHttpMethodName(a_enmHttpMethod))); + + + /* + * Reset the response object (allowing reuse of such) and check the request + * object for assignment errors. + */ + int rc; + RTHTTP hHttp = NIL_RTHTTP; + + a_pResponse->reset(); + if (!a_rRequest.hasAssignmentErrors()) + { + /* + * Initialize the HTTP instance. + */ + rc = reinitHttpInstance(); + if (RT_SUCCESS(rc)) + { + hHttp = m_hHttp; + Assert(hHttp != NIL_RTHTTP); + + /* + * Prepare the response side. + */ + rc = a_pResponse->receivePrepare(hHttp); + if (RT_SUCCESS(rc)) + { + /* + * Prepare the request for the transmission. + */ + RTCString strExtraPath; + RTCString strQuery; + RTCString strXmitBody; + rc = a_rRequest.xmitPrepare(&strExtraPath, &strQuery, hHttp, &strXmitBody); + if (RT_SUCCESS(rc)) + { + /* + * Construct the full URL. + */ + RTCString strFullUrl; + rc = strFullUrl.assignNoThrow(getServerUrl()); + if (strExtraPath.isNotEmpty()) + { + if (!strExtraPath.startsWith("/") && !strFullUrl.endsWith("/") && RT_SUCCESS(rc)) + rc = strFullUrl.appendNoThrow('/'); + if (RT_SUCCESS(rc)) + rc = strFullUrl.appendNoThrow(strExtraPath); + strExtraPath.setNull(); + } + if (strQuery.isNotEmpty()) + { + Assert(strQuery.startsWith("?")); + rc = strFullUrl.appendNoThrow(strQuery); + strQuery.setNull(); + } + if (RT_SUCCESS(rc)) + { + rc = xmitReady(hHttp, strFullUrl, a_enmHttpMethod, strXmitBody, a_fFlags); + if (RT_SUCCESS(rc)) + { + /* + * Perform HTTP request. + */ + uint32_t uHttpStatus = 0; + size_t cbBody = 0; + void *pvBody = NULL; + rc = RTHttpPerform(hHttp, strFullUrl.c_str(), a_enmHttpMethod, + strXmitBody.c_str(), strXmitBody.length(), + &uHttpStatus, NULL /*ppvHdrs*/, NULL /*pcbHdrs*/, &pvBody, &cbBody); + if (RT_SUCCESS(rc)) + { + a_rRequest.xmitComplete(uHttpStatus, hHttp); + + /* + * Do response processing. + */ + a_pResponse->receiveComplete(uHttpStatus, hHttp); + a_pResponse->consumeBody((const char *)pvBody, cbBody); + if (pvBody) + RTHttpFreeResponse(pvBody); + a_pResponse->receiveFinal(); + + return a_pResponse->getStatus(); + } + } + } + } + a_rRequest.xmitComplete(rc, hHttp); + } + } + } + else + rc = VERR_NO_MEMORY; + + a_pResponse->receiveComplete(rc, hHttp); + RT_NOREF_PV(a_pszMethod); + + return a_pResponse->getStatus(); +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestClientApiBaseOci.cpp b/src/VBox/Runtime/common/rest/RTCRestClientApiBaseOci.cpp new file mode 100644 index 00000000..872dd4cb --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestClientApiBaseOci.cpp @@ -0,0 +1,167 @@ +/* $Id: RTCRestClientApiBaseOci.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestClientApiBase implementation, OCI specific bits. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restclient.h> + +#include <iprt/assert.h> +#include <iprt/base64.h> +#include <iprt/errcore.h> +#include <iprt/http.h> +#include <iprt/log.h> +#include <iprt/sha.h> +#include <iprt/time.h> +#include <iprt/uri.h> + + + +/** + * Ensures that we've got a 'Content-Length' header. + * + * @returns IPRT status code. + * @param hHttp The HTTP client handle. + * @param pvContent + */ +static int ociSignRequestEnsureDateOrXDate(RTHTTP hHttp) RT_NOEXCEPT +{ + if (RTHttpGetHeader(hHttp, RT_STR_TUPLE("x-date"))) + return VINF_SUCCESS; + if (RTHttpGetHeader(hHttp, RT_STR_TUPLE("date"))) + return VINF_SUCCESS; + + RTTIMESPEC NowSpec; + RTTIME Now; + char szDate[RTTIME_RFC2822_LEN]; + ssize_t cch = RTTimeToRfc2822(RTTimeExplode(&Now, RTTimeNow(&NowSpec)), szDate, sizeof(szDate), RTTIME_RFC2822_F_GMT); + AssertRCReturn((int)cch, (int)cch); + + return RTHttpAddHeader(hHttp, "x-date", szDate, cch, RTHTTPADDHDR_F_BACK); +} + + +/** + * Ensures that we've got a 'x-content-sha256' header. + * + * @returns IPRT status code. + * @param hHttp The HTTP client handle. + * @param pvContent + */ +static int ociSignRequestEnsureXContentSha256(RTHTTP hHttp, void const *pvContent, size_t cbContent) RT_NOEXCEPT +{ + if (RTHttpGetHeader(hHttp, RT_STR_TUPLE("x-content-sha256"))) + return VINF_SUCCESS; + +#ifdef RT_STRICT + const char *pszContentLength = RTHttpGetHeader(hHttp, RT_STR_TUPLE("Content-Length")); + Assert(pszContentLength); + AssertMsg(!pszContentLength || RTStrToUInt64(pszContentLength) == cbContent, ("'%s' vs %RU64\n", pszContentLength, cbContent)); +#endif + + uint8_t abHash[RTSHA256_HASH_SIZE]; + RTSha256(pvContent, cbContent, abHash); + + char szBase64[RTSHA256_DIGEST_LEN + 1]; /* (base64 should be shorter) */ + int rc = RTBase64EncodeEx(abHash, sizeof(abHash), RTBASE64_FLAGS_NO_LINE_BREAKS, szBase64, sizeof(szBase64), NULL); + AssertRCReturn(rc, rc); + + return RTHttpAddHeader(hHttp, "x-content-sha256", szBase64, RTSTR_MAX, RTHTTPADDHDR_F_BACK); +} + + +/** + * Ensures that we've got a 'Content-Length' header. + * + * @returns IPRT status code. + * @param hHttp The HTTP client handle. + * @param cbContent The content length. + */ +static int ociSignRequestEnsureContentLength(RTHTTP hHttp, uint64_t cbContent) RT_NOEXCEPT +{ + if (RTHttpGetHeader(hHttp, RT_STR_TUPLE("Content-Length"))) + return VINF_SUCCESS; + char szValue[64]; + ssize_t cchValue = RTStrFormatU64(szValue, sizeof(szValue), cbContent, 10, 0, 0, 0); + AssertRCReturn((int)cchValue, (int)cchValue); + return RTHttpAddHeader(hHttp, "Content-Length", szValue, cchValue, RTHTTPADDHDR_F_BACK); +} + + +/** + * Ensures that we've got a host header. + * + * @returns IPRT status code. + * @param hHttp The HTTP client handle. + * @param pszUrl The URL. + */ +static int ociSignRequestEnsureHost(RTHTTP hHttp, const char *pszUrl) RT_NOEXCEPT +{ + if (RTHttpGetHeader(hHttp, RT_STR_TUPLE("host"))) + return VINF_SUCCESS; + + RTURIPARSED ParsedUrl; + int rc = RTUriParse(pszUrl, &ParsedUrl); + AssertRCReturn(rc, rc); + + return RTHttpAddHeader(hHttp, "host", &pszUrl[ParsedUrl.offAuthorityHost], ParsedUrl.cchAuthorityHost, RTHTTPADDHDR_F_BACK); +} + + +int RTCRestClientApiBase::ociSignRequest(RTHTTP a_hHttp, RTCString const &a_rStrFullUrl, RTHTTPMETHOD a_enmHttpMethod, + RTCString const &a_rStrXmitBody, uint32_t a_fFlags, + RTCRKEY a_hKey, RTCString const &a_rStrKeyId) RT_NOEXCEPT +{ + /* + * First make sure required headers are present, adding them as needed. + */ + int rc = ociSignRequestEnsureHost(a_hHttp, a_rStrFullUrl.c_str()); + if (RT_SUCCESS(rc)) + { + bool fHasBody = a_rStrXmitBody.isNotEmpty() || (a_fFlags & kDoCall_RequireBody); + + if ( fHasBody + || a_enmHttpMethod == RTHTTPMETHOD_POST + || a_enmHttpMethod == RTHTTPMETHOD_PUT) + rc = ociSignRequestEnsureContentLength(a_hHttp, a_rStrXmitBody.length()); + if ( RT_SUCCESS(rc) + && fHasBody) + rc = ociSignRequestEnsureXContentSha256(a_hHttp, a_rStrXmitBody.c_str(), a_rStrXmitBody.length()); + if (RT_SUCCESS(rc)) + rc = ociSignRequestEnsureDateOrXDate(a_hHttp); + if (RT_SUCCESS(rc)) + { + /* + * Do the signing. + */ + rc = RTHttpSignHeaders(a_hHttp, a_enmHttpMethod, a_rStrFullUrl.c_str(), a_hKey, a_rStrKeyId.c_str(), 0 /*fFlags*/); + } + } + return rc; +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestClientRequestBase.cpp b/src/VBox/Runtime/common/rest/RTCRestClientRequestBase.cpp new file mode 100644 index 00000000..3c726d16 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestClientRequestBase.cpp @@ -0,0 +1,248 @@ +/* $Id: RTCRestClientRequestBase.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestClientRequestBase implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restclient.h> + +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/cpp/restarray.h> +#include <iprt/cpp/reststringmap.h> + + +/** + * Default constructor. + */ +RTCRestClientRequestBase::RTCRestClientRequestBase() RT_NOEXCEPT + : m_fIsSet(0) + , m_fErrorSet(0) +{ +} + + +/** + * Copy constructor. + */ +RTCRestClientRequestBase::RTCRestClientRequestBase(RTCRestClientRequestBase const &a_rThat) RT_NOEXCEPT + : m_fIsSet(a_rThat.m_fIsSet) + , m_fErrorSet(a_rThat.m_fErrorSet) +{ +} + + +/** + * Destructor + */ +RTCRestClientRequestBase::~RTCRestClientRequestBase() +{ + /* nothing to do */ +} + + +/** + * Copy assignment operator. + */ +RTCRestClientRequestBase &RTCRestClientRequestBase::operator=(RTCRestClientRequestBase const &a_rThat) RT_NOEXCEPT +{ + m_fIsSet = a_rThat.m_fIsSet; + m_fErrorSet = a_rThat.m_fErrorSet; + return *this; +} + + +int RTCRestClientRequestBase::doPathParameters(RTCString *a_pStrPath, const char *a_pszPathTemplate, size_t a_cchPathTemplate, + PATHPARAMDESC const *a_paPathParams, PATHPARAMSTATE *a_paPathParamStates, + size_t a_cPathParams) const RT_NOEXCEPT +{ + int rc = a_pStrPath->assignNoThrow(a_pszPathTemplate, a_cchPathTemplate); + AssertRCReturn(rc, rc); + + /* Locate the sub-string to replace with values first: */ + for (size_t i = 0; i < a_cPathParams; i++) + { + char const *psz = strstr(a_pszPathTemplate, a_paPathParams[i].pszName); + AssertReturn(psz, VERR_INTERNAL_ERROR_5); + a_paPathParamStates[i].offName = psz - a_pszPathTemplate; + } + + /* Replace with actual values: */ + for (size_t i = 0; i < a_cPathParams; i++) + { + AssertReturn( (a_paPathParams[i].fFlags & RTCRestObjectBase::kCollectionFormat_Mask) + != RTCRestObjectBase::kCollectionFormat_multi, + VERR_INTERNAL_ERROR_3); + AssertMsgReturn(a_paPathParamStates[i].pObj != NULL, + ("Path parameter '%s' is not set!\n", a_paPathParams[i].pszName), + VERR_REST_PATH_PARAMETER_NOT_SET); + AssertMsgReturn(m_fIsSet & RT_BIT_64(a_paPathParams[i].iBitNo), + ("Path parameter '%s' is not set!\n", a_paPathParams[i].pszName), + VERR_REST_PATH_PARAMETER_NOT_SET); + + RTCString strPathParam; + rc = a_paPathParamStates[i].pObj->toString(&strPathParam, a_paPathParams[i].fFlags); + AssertRCReturn(rc, rc); + + RTCString strTmpVal; + rc = strTmpVal.printfNoThrow("%RMpa", strPathParam.c_str()); /* urlencode */ + AssertRCReturn(rc, rc); + + /* Replace. */ + ssize_t cchAdjust = strTmpVal.length() - a_paPathParams[i].cchName; + rc = a_pStrPath->replaceNoThrow(a_paPathParamStates[i].offName, a_paPathParams[i].cchName, strTmpVal); + AssertRCReturn(rc, rc); + + /* Adjust subsequent fields. */ + if (cchAdjust != 0) + for (size_t j = i + 1; j < a_cPathParams; j++) + if (a_paPathParamStates[j].offName > a_paPathParamStates[i].offName) + a_paPathParamStates[j].offName += cchAdjust; + } + + return VINF_SUCCESS; +} + + +int RTCRestClientRequestBase::doQueryParameters(RTCString *a_pStrQuery, QUERYPARAMDESC const *a_paQueryParams, + RTCRestObjectBase const **a_papQueryParamObjs, size_t a_cQueryParams) const RT_NOEXCEPT +{ + RTCString strTmpVal; + char chSep = a_pStrQuery->isEmpty() ? '?' : '&'; + for (size_t i = 0; i < a_cQueryParams; i++) + { + if ( a_paQueryParams[i].fRequired + || (m_fIsSet & RT_BIT_64(a_paQueryParams[i].iBitNo)) ) + { + AssertMsgReturn(a_papQueryParamObjs[i] != NULL, + ("Required query parameter '%s' is not set!\n", a_paQueryParams[i].pszName), + VERR_REST_REQUIRED_QUERY_PARAMETER_NOT_SET); + AssertMsgReturn(m_fIsSet & RT_BIT_64(a_paQueryParams[i].iBitNo), + ("Required query parameter '%s' is not set!\n", a_paQueryParams[i].pszName), + VERR_REST_REQUIRED_QUERY_PARAMETER_NOT_SET); + + if ( (a_paQueryParams[i].fFlags & RTCRestObjectBase::kCollectionFormat_Mask) + != RTCRestObjectBase::kCollectionFormat_multi) + { + int rc = a_papQueryParamObjs[i]->toString(&strTmpVal, a_paQueryParams[i].fFlags); + AssertRCReturn(rc, rc); + + rc = a_pStrQuery->appendPrintfNoThrow("%c%RMpa=%RMpa", chSep, a_paQueryParams[i].pszName, strTmpVal.c_str()); + AssertRCReturn(rc, rc); + + chSep = '&'; + } + else + { + /* + * Enumerate array and add 'name=element' for each element in it. + */ + AssertReturn(a_papQueryParamObjs[i]->typeClass() == RTCRestObjectBase::kTypeClass_Array, + VERR_REST_INTERNAL_ERROR_2); + RTCRestArrayBase const *pArray = (RTCRestArrayBase const *)a_papQueryParamObjs[i]; + for (size_t j = 0; j < pArray->size(); j++) + { + RTCRestObjectBase const *pObj = pArray->atBase(j); + int rc = pObj->toString(&strTmpVal, a_paQueryParams[i].fFlags & ~RTCRestObjectBase::kCollectionFormat_Mask); + AssertRCReturn(rc, rc); + + rc = a_pStrQuery->appendPrintfNoThrow("%c%RMpa=%RMpa", chSep, a_paQueryParams[i].pszName, strTmpVal.c_str()); + AssertRCReturn(rc, rc); + + chSep = '&'; + } + } + } + } + return VINF_SUCCESS; +} + + +int RTCRestClientRequestBase::doHeaderParameters(RTHTTP a_hHttp, HEADERPARAMDESC const *a_paHeaderParams, + RTCRestObjectBase const **a_papHeaderParamObjs, size_t a_cHeaderParams) const RT_NOEXCEPT +{ + RTCString strTmpVal; + for (size_t i = 0; i < a_cHeaderParams; i++) + { + AssertReturn( (a_paHeaderParams[i].fFlags & RTCRestObjectBase::kCollectionFormat_Mask) + != RTCRestObjectBase::kCollectionFormat_multi, + VERR_INTERNAL_ERROR_3); + + if ( a_paHeaderParams[i].fRequired + || (m_fIsSet & RT_BIT_64(a_paHeaderParams[i].iBitNo)) ) + { + AssertMsgReturn(m_fIsSet & RT_BIT_64(a_paHeaderParams[i].iBitNo), + ("Required header parameter '%s' is not set!\n", a_paHeaderParams[i].pszName), + VERR_REST_REQUIRED_HEADER_PARAMETER_NOT_SET); + AssertMsgReturn(a_papHeaderParamObjs[i] != NULL, + ("Required header parameter '%s' is not set!\n", a_paHeaderParams[i].pszName), + VERR_REST_REQUIRED_HEADER_PARAMETER_NOT_SET); + + if (!a_paHeaderParams[i].fMapCollection) + { + int rc = a_papHeaderParamObjs[i]->toString(&strTmpVal, a_paHeaderParams[i].fFlags); + AssertRCReturn(rc, rc); + + rc = RTHttpAddHeader(a_hHttp, a_paHeaderParams[i].pszName, strTmpVal.c_str(), strTmpVal.length(), + RTHTTPADDHDR_F_BACK); + AssertRCReturn(rc, rc); + } + else if (!a_papHeaderParamObjs[i]->isNull()) + { + /* + * Enumerate the map and produce a series of head fields on the form: + * (a_paHeaderParams[i].pszName + key): value.toString() + */ + AssertReturn(a_papHeaderParamObjs[i]->typeClass() == RTCRestObjectBase::kTypeClass_StringMap, + VERR_REST_INTERNAL_ERROR_1); + RTCRestStringMapBase const *pMap = (RTCRestStringMapBase const *)a_papHeaderParamObjs[i]; + const size_t cchName = strlen(a_paHeaderParams[i].pszName); + Assert(a_paHeaderParams[i].pszName[cchName - 1] != '*'); + RTCString strTmpName; + for (RTCRestStringMapBase::ConstIterator it = pMap->begin(); it != pMap->end(); ++it) + { + int rc = strTmpName.assignNoThrow(a_paHeaderParams[i].pszName, cchName); + AssertRCReturn(rc, rc); + rc = strTmpName.appendNoThrow(it.getKey()); + AssertRCReturn(rc, rc); + + rc = it.getValue()->toString(&strTmpVal, a_paHeaderParams[i].fFlags); + AssertRCReturn(rc, rc); + + rc = RTHttpAddHeader(a_hHttp, strTmpName.c_str(), strTmpVal.c_str(), strTmpVal.length(), + RTHTTPADDHDR_F_BACK); + AssertRCReturn(rc, rc); + } + } + else + Assert(!a_paHeaderParams[i].fRequired); + } + } + return VINF_SUCCESS; +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestClientResponseBase.cpp b/src/VBox/Runtime/common/rest/RTCRestClientResponseBase.cpp new file mode 100644 index 00000000..241b8b59 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestClientResponseBase.cpp @@ -0,0 +1,380 @@ +/* $Id: RTCRestClientResponseBase.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestClientResponseBase implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restclient.h> + +#include <iprt/ctype.h> +#include <iprt/err.h> +#include <iprt/cpp/reststringmap.h> + + +/** + * Default constructor. + */ +RTCRestClientResponseBase::RTCRestClientResponseBase() RT_NOEXCEPT + : m_rcStatus(VERR_WRONG_ORDER) + , m_rcHttp(VERR_NOT_AVAILABLE) + , m_pErrInfo(NULL) +{ +} + + +/** + * Destructor. + */ +RTCRestClientResponseBase::~RTCRestClientResponseBase() +{ + deleteErrInfo(); +} + + +/** + * Copy constructor. + */ +RTCRestClientResponseBase::RTCRestClientResponseBase(RTCRestClientResponseBase const &a_rThat) + : m_rcStatus(a_rThat.m_rcStatus) + , m_rcHttp(a_rThat.m_rcHttp) + , m_pErrInfo(NULL) + , m_strContentType(a_rThat.m_strContentType) +{ + if (a_rThat.m_pErrInfo) + copyErrInfo(a_rThat.m_pErrInfo); +} + + +/** + * Copy assignment operator. + */ +RTCRestClientResponseBase &RTCRestClientResponseBase::operator=(RTCRestClientResponseBase const &a_rThat) +{ + m_rcStatus = a_rThat.m_rcStatus; + m_rcHttp = a_rThat.m_rcHttp; + m_strContentType = a_rThat.m_strContentType; + if (a_rThat.m_pErrInfo) + copyErrInfo(a_rThat.m_pErrInfo); + else if (m_pErrInfo) + deleteErrInfo(); + + return *this; +} + + +void RTCRestClientResponseBase::reset() RT_NOEXCEPT +{ + /* Return to default constructor state. */ + m_rcStatus = VERR_WRONG_ORDER; + m_rcHttp = VERR_NOT_AVAILABLE; + if (m_pErrInfo) + deleteErrInfo(); + m_strContentType.setNull(); +} + + +int RTCRestClientResponseBase::receivePrepare(RTHTTP a_hHttp) RT_NOEXCEPT +{ + int rc = RTHttpSetHeaderCallback(a_hHttp, receiveHttpHeaderCallback, this); + AssertRCReturn(rc, rc); + + return VINF_SUCCESS; +} + + +void RTCRestClientResponseBase::receiveComplete(int a_rcStatus, RTHTTP a_hHttp) RT_NOEXCEPT +{ + RT_NOREF_PV(a_hHttp); + m_rcStatus = a_rcStatus; + if (a_rcStatus >= 0) + m_rcHttp = a_rcStatus; + + int rc = RTHttpSetHeaderCallback(a_hHttp, NULL, NULL); + AssertRC(rc); +} + + +int RTCRestClientResponseBase::consumeHeader(uint32_t a_uMatchWord, const char *a_pchField, size_t a_cchField, + const char *a_pchValue, size_t a_cchValue) RT_NOEXCEPT +{ + if ( a_uMatchWord == RTHTTP_MAKE_HDR_MATCH_WORD(sizeof("Content-Type") - 1, 'c', 'o', 'n') + && RTStrNICmpAscii(a_pchField, RT_STR_TUPLE("Content-Type")) == 0) + { + int rc = RTStrValidateEncodingEx(a_pchValue, a_cchValue, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH); + AssertRC(rc); + if (RT_SUCCESS(rc)) + return m_strContentType.assignNoThrow(a_pchValue, a_cchValue); + } + RT_NOREF(a_cchField); + return VINF_SUCCESS; +} + + +/*static*/ DECLCALLBACK(int) +RTCRestClientResponseBase::receiveHttpHeaderCallback(RTHTTP hHttp, uint32_t uMatchWord, const char *pchField, size_t cchField, + const char *pchValue, size_t cchValue, void *pvUser) RT_NOEXCEPT +{ + RTCRestClientResponseBase *pThis = (RTCRestClientResponseBase *)pvUser; + RT_NOREF(hHttp); + return pThis->consumeHeader(uMatchWord, pchField, cchField, pchValue, cchValue); +} + + +void RTCRestClientResponseBase::consumeBody(const char *a_pchData, size_t a_cbData) RT_NOEXCEPT +{ + RT_NOREF(a_pchData, a_cbData); +} + + +void RTCRestClientResponseBase::receiveFinal() RT_NOEXCEPT +{ +} + + +PRTERRINFO RTCRestClientResponseBase::getErrInfoInternal(void) RT_NOEXCEPT +{ + if (m_pErrInfo) + return m_pErrInfo; + size_t cbMsg = _4K; + m_pErrInfo = (PRTERRINFO)RTMemAllocZ(sizeof(*m_pErrInfo) + cbMsg); + if (m_pErrInfo) + return RTErrInfoInit(m_pErrInfo, (char *)(m_pErrInfo + 1), cbMsg); + return NULL; +} + + +void RTCRestClientResponseBase::deleteErrInfo(void) RT_NOEXCEPT +{ + if (m_pErrInfo) + { + RTMemFree(m_pErrInfo); + m_pErrInfo = NULL; + } +} + + +void RTCRestClientResponseBase::copyErrInfo(PCRTERRINFO pErrInfo) RT_NOEXCEPT +{ + deleteErrInfo(); + m_pErrInfo = (PRTERRINFO)RTMemDup(pErrInfo, pErrInfo->cbMsg + sizeof(*pErrInfo)); + if (m_pErrInfo) + { + m_pErrInfo->pszMsg = (char *)(m_pErrInfo + 1); + m_pErrInfo->apvReserved[0] = NULL; + m_pErrInfo->apvReserved[1] = NULL; + } +} + + +int RTCRestClientResponseBase::addError(int rc, const char *pszFormat, ...) RT_NOEXCEPT +{ + PRTERRINFO pErrInfo = getErrInfoInternal(); + 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; +} + + +RTCRestClientResponseBase::PrimaryJsonCursorForBody::PrimaryJsonCursorForBody(RTJSONVAL hValue, const char *pszName, + RTCRestClientResponseBase *a_pThat) RT_NOEXCEPT + : RTCRestJsonPrimaryCursor(hValue, pszName, a_pThat->getErrInfoInternal()) + , m_pThat(a_pThat) +{ +} + + +int RTCRestClientResponseBase::PrimaryJsonCursorForBody::addError(RTCRestJsonCursor const &a_rCursor, int a_rc, + const char *a_pszFormat, ...) RT_NOEXCEPT +{ + 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) RT_NOEXCEPT +{ + 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; +} + + +int RTCRestClientResponseBase::deserializeHeader(RTCRestObjectBase *a_pObj, const char *a_pchValue, size_t a_cchValue, + uint32_t a_fFlags, const char *a_pszErrorTag) RT_NOEXCEPT +{ + /* + * Start by checking the encoding and transfering the value to a RTCString object. + */ + int rc = RTStrValidateEncodingEx(a_pchValue, a_cchValue, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH); + if (RT_SUCCESS(rc)) + { + RTCString strValue; + rc = strValue.assignNoThrow(a_pchValue, a_cchValue); + if (RT_SUCCESS(rc)) + { + /* + * Try deserialize it. + */ + RTERRINFOSTATIC ErrInfo; + rc = a_pObj->fromString(strValue, a_pszErrorTag, RTErrInfoInitStatic(&ErrInfo), a_fFlags); + if (RT_SUCCESS(rc)) + { /* likely */ } + else if (RTErrInfoIsSet(&ErrInfo.Core)) + addError(rc, "Error %Rrc parsing header field '%s': %s", rc, a_pszErrorTag, ErrInfo.Core.pszMsg); + else + addError(rc, "Error %Rrc parsing header field '%s'", rc, a_pszErrorTag); + } + } + else + { + addError(rc, "Error %Rrc validating value necoding of header field '%s': %.*Rhxs", + rc, a_pszErrorTag, a_cchValue, a_pchValue); + rc = VINF_SUCCESS; /* ignore */ + } + return rc; +} + + +int RTCRestClientResponseBase::deserializeHeaderIntoMap(RTCRestStringMapBase *a_pMap, const char *a_pchField, size_t a_cchField, + const char *a_pchValue, size_t a_cchValue, uint32_t a_fFlags, + const char *a_pszErrorTag) RT_NOEXCEPT +{ + /* + * Start by checking the encoding of both the field and value, + * then transfering the value to a RTCString object. + */ + int rc = RTStrValidateEncodingEx(a_pchField, a_cchField, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH); + if (RT_SUCCESS(rc)) + { + rc = RTStrValidateEncodingEx(a_pchValue, a_cchValue, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH); + if (RT_SUCCESS(rc)) + { + RTCString strValue; + rc = strValue.assignNoThrow(a_pchValue, a_cchValue); + if (RT_SUCCESS(rc)) + { + /* + * Create a value object and put it into the map. + */ + RTCRestObjectBase *pValue; + rc = a_pMap->putNewValue(&pValue, a_pchField, a_cchField); + if (RT_SUCCESS(rc)) + { + /* + * Try deserialize the value. + */ + RTERRINFOSTATIC ErrInfo; + rc = pValue->fromString(strValue, a_pszErrorTag, RTErrInfoInitStatic(&ErrInfo), a_fFlags); + if (RT_SUCCESS(rc)) + { /* likely */ } + else if (RTErrInfoIsSet(&ErrInfo.Core)) + addError(rc, "Error %Rrc parsing header field '%s' subfield '%.*s': %s", + rc, a_pszErrorTag, a_cchField, a_pchField, ErrInfo.Core.pszMsg); + else + addError(rc, "Error %Rrc parsing header field '%s' subfield '%.*s'", + rc, a_pszErrorTag, a_cchField, a_pchField); + } + } + } + else + { + addError(rc, "Error %Rrc validating value encoding of header field '%s': %.*Rhxs", + rc, a_pszErrorTag, a_cchValue, a_pchValue); + rc = VINF_SUCCESS; /* ignore */ + } + } + else + { + addError(rc, "Error %Rrc validating sub-field encoding of header field '%s*': %.*Rhxs", + rc, a_pszErrorTag, a_cchField, a_pchField); + rc = VINF_SUCCESS; /* ignore */ + } + return rc; +} + + +void RTCRestClientResponseBase::deserializeBody(const char *a_pchData, size_t a_cbData, const char *a_pszBodyName) RT_NOEXCEPT +{ + 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_pszBodyName, this); /* note: consumes hValue */ + deserializeBodyFromJsonCursor(PrimaryCursor.m_Cursor); + } + else if (RTErrInfoIsSet(&ErrInfo.Core)) + addError(rc, "Error %Rrc parsing server response as JSON (type %s): %s", + rc, a_pszBodyName, ErrInfo.Core.pszMsg); + else + addError(rc, "Error %Rrc parsing server response as JSON (type %s)", rc, a_pszBodyName); + } + 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_pszBodyName, 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_pszBodyName, m_strContentType.c_str()); + else + addError(rc, "Unexpected body validation error (object type %s; Content-Type: %s): %Rrc", + a_pszBodyName, m_strContentType.c_str(), rc); + } + else + addError(VERR_REST_RESPONSE_CONTENT_TYPE_NOT_SUPPORTED, "Unsupported content type for '%s': %s", + a_pszBodyName, m_strContentType.c_str()); +} + + +void RTCRestClientResponseBase::deserializeBodyFromJsonCursor(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_INTERNAL_ERROR_8, "deserializeBodyFromJsonCursor must be overridden!"); + AssertFailed(); +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestJsonPrimaryCursor.cpp b/src/VBox/Runtime/common/rest/RTCRestJsonPrimaryCursor.cpp new file mode 100644 index 00000000..e29457ad --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestJsonPrimaryCursor.cpp @@ -0,0 +1,110 @@ +/* $Id: RTCRestJsonPrimaryCursor.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestJsonPrimaryCursor implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restbase.h> + +#include <iprt/errcore.h> +#include <iprt/string.h> + + +char *RTCRestJsonPrimaryCursor::getPath(RTCRestJsonCursor const &a_rCursor, char *pszDst, size_t cbDst) const RT_NOEXCEPT +{ + AssertReturn(cbDst > 0, NULL); + + /* + * To avoid using recursion, we need to first do a pass to figure sizes + * and depth. To keep things simple, with the exception of the top name + * we only copy out full names. + */ + /* Special case: Insufficient space for the top name. */ + size_t const cchTopName = strlen(a_rCursor.m_pszName); + if (cchTopName >= cbDst) + { + memcpy(pszDst, a_rCursor.m_pszName, cbDst - 1); + pszDst[cbDst - 1] = '\0'; + } + else + { + /* Determin how deep we should go and the resulting length. */ + size_t iMaxDepth = 0; + size_t cchTotal = cchTopName; + for (RTCRestJsonCursor const *pCur = a_rCursor.m_pParent; pCur; pCur = pCur->m_pParent) + { + size_t const cchName = strlen(pCur->m_pszName); + size_t cchNewTotal = cchName + 1 + cchTotal; + if (cchNewTotal < cbDst) + cchTotal = cchNewTotal; + else + break; + iMaxDepth++; + } + + /* Produce the string, in reverse. */ + char *psz = &pszDst[cchTotal]; + *psz = '\0'; + psz -= cchTopName; + memcpy(psz, a_rCursor.m_pszName, cchTopName); + for (RTCRestJsonCursor const *pCur = a_rCursor.m_pParent; pCur && iMaxDepth > 0; pCur = pCur->m_pParent) + { + psz -= 1; + *psz = '.'; + + size_t const cchName = strlen(pCur->m_pszName); + psz -= cchName; + memcpy(psz, pCur->m_pszName, cchName); + + iMaxDepth--; + } + Assert(psz == pszDst); + } + return pszDst; +} + + +int RTCRestJsonPrimaryCursor::addError(RTCRestJsonCursor const &a_rCursor, int a_rc, const char *a_pszFormat, ...) RT_NOEXCEPT +{ + va_list va; + va_start(va, a_pszFormat); + char szPath[128]; + a_rc = RTErrInfoAddF(m_pErrInfo, a_rc, "%s: %N\n", getPath(a_rCursor, szPath, sizeof(szPath)), a_pszFormat, &va); + va_end(va); + return a_rc; +} + + +int RTCRestJsonPrimaryCursor::unknownField(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + char szPath[128]; + return RTErrInfoAddF(m_pErrInfo, VWRN_NOT_FOUND, "%s: unknown field (type %s)\n", + getPath(a_rCursor, szPath, sizeof(szPath)), + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestOutputBase.cpp b/src/VBox/Runtime/common/rest/RTCRestOutputBase.cpp new file mode 100644 index 00000000..4bc2fb92 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestOutputBase.cpp @@ -0,0 +1,119 @@ +/* $Id: RTCRestOutputBase.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestOutputBase implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restoutput.h> + +#include <iprt/errcore.h> +#include <iprt/string.h> + + +RTCRestOutputBase::RTCRestOutputBase() RT_NOEXCEPT + : m_uState(0) +{ +} + + +RTCRestOutputBase::~RTCRestOutputBase() +{ +} + + +size_t RTCRestOutputBase::vprintf(const char *pszFormat, va_list va) RT_NOEXCEPT +{ + return RTStrFormatV(printfOutputCallback, this, NULL, NULL, pszFormat, va); +} + + +/*static*/ DECLCALLBACK(size_t) RTCRestOutputBase::printfOutputCallback(void *pvArg, const char *pachChars, size_t cbChars) RT_NOEXCEPT +{ + return ((RTCRestOutputBase *)pvArg)->output(pachChars, cbChars); +} + + +uint32_t RTCRestOutputBase::beginArray() RT_NOEXCEPT +{ + output(RT_STR_TUPLE("[")); + uint32_t const uOldState = m_uState; + m_uState = (uOldState & 0xffff) + 1; + return uOldState; +} + + +void RTCRestOutputBase::endArray(uint32_t a_uOldState) RT_NOEXCEPT +{ + m_uState = a_uOldState; + output(RT_STR_TUPLE("]")); +} + + +uint32_t RTCRestOutputBase::beginObject() RT_NOEXCEPT +{ + output(RT_STR_TUPLE("{")); + uint32_t const uOldState = m_uState; + m_uState = (uOldState & 0xffff) + 1; + return uOldState; +} + + +void RTCRestOutputBase::endObject(uint32_t a_uOldState) RT_NOEXCEPT +{ + m_uState = a_uOldState; + output(RT_STR_TUPLE("}")); +} + + +void RTCRestOutputBase::valueSeparator() RT_NOEXCEPT +{ + if (m_uState & RT_BIT_32(31)) + output(RT_STR_TUPLE(",")); + else + m_uState |= RT_BIT_32(31); +} + + +void RTCRestOutputBase::valueSeparatorAndName(const char *a_pszName, size_t a_cchName) RT_NOEXCEPT +{ + RT_NOREF(a_cchName); + if (m_uState & RT_BIT_32(31)) + printf(",%RMjs:", a_pszName); + else + { + m_uState |= RT_BIT_32(31); + printf("%RMjs:", a_pszName); + } +} + + +void RTCRestOutputBase::nullValue() RT_NOEXCEPT +{ + output(RT_STR_TUPLE("null")); +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestOutputPrettyBase.cpp b/src/VBox/Runtime/common/rest/RTCRestOutputPrettyBase.cpp new file mode 100644 index 00000000..04624676 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestOutputPrettyBase.cpp @@ -0,0 +1,124 @@ +/* $Id: RTCRestOutputPrettyBase.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestOutputPrettyBase implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restoutput.h> + +#include <iprt/errcore.h> +#include <iprt/string.h> + + +RTCRestOutputPrettyBase::RTCRestOutputPrettyBase() RT_NOEXCEPT + : RTCRestOutputBase() +{ +} + + +RTCRestOutputPrettyBase::~RTCRestOutputPrettyBase() +{ +} + + +uint32_t RTCRestOutputPrettyBase::beginArray() RT_NOEXCEPT +{ + output(RT_STR_TUPLE("[")); + uint32_t const uOldState = m_uState; + m_uState = (uOldState & 0xffff) + 1; + return uOldState; +} + + +void RTCRestOutputPrettyBase::endArray(uint32_t a_uOldState) RT_NOEXCEPT +{ + m_uState = a_uOldState; + output(RT_STR_TUPLE("\n")); + outputIndentation(); + output(RT_STR_TUPLE("]")); +} + + +uint32_t RTCRestOutputPrettyBase::beginObject() RT_NOEXCEPT +{ + output(RT_STR_TUPLE("{")); + uint32_t const uOldState = m_uState; + m_uState = (uOldState & 0xffff) + 1; + return uOldState; +} + + +void RTCRestOutputPrettyBase::endObject(uint32_t a_uOldState) RT_NOEXCEPT +{ + m_uState = a_uOldState; + output(RT_STR_TUPLE("\n")); + outputIndentation(); + output(RT_STR_TUPLE("}")); +} + + +void RTCRestOutputPrettyBase::valueSeparator() RT_NOEXCEPT +{ + if (m_uState & RT_BIT_32(31)) + output(RT_STR_TUPLE(",\n")); + else + { + m_uState |= RT_BIT_32(31); + output(RT_STR_TUPLE("\n")); + } + outputIndentation(); +} + + +void RTCRestOutputPrettyBase::valueSeparatorAndName(const char *a_pszName, size_t a_cchName) RT_NOEXCEPT +{ + RT_NOREF(a_cchName); + if (m_uState & RT_BIT_32(31)) + output(RT_STR_TUPLE(",\n")); + else + { + m_uState |= RT_BIT_32(31); + output(RT_STR_TUPLE("\n")); + } + outputIndentation(); + printf("%RMjs: ", a_pszName); +} + + +void RTCRestOutputPrettyBase::outputIndentation() RT_NOEXCEPT +{ + static char const s_szSpaces[] = " "; + size_t cchIndent = (m_uState & 0xffff) << 1; + while (cchIndent > 0) + { + size_t cbToWrite = RT_MIN(cchIndent, sizeof(s_szSpaces) - 1); + output(s_szSpaces, cbToWrite); + cchIndent -= cbToWrite; + } +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestOutputPrettyToString.cpp b/src/VBox/Runtime/common/rest/RTCRestOutputPrettyToString.cpp new file mode 100644 index 00000000..a130d333 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestOutputPrettyToString.cpp @@ -0,0 +1,120 @@ +/* $Id: RTCRestOutputPrettyToString.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestOutputPrettyToString implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restoutput.h> + +#include <iprt/errcore.h> +#include <iprt/string.h> + + +RTCRestOutputPrettyToString::RTCRestOutputPrettyToString(RTCString *a_pDst, bool a_fAppend /*= false*/) RT_NOEXCEPT + : RTCRestOutputPrettyBase() + , m_pDst(a_pDst) + , m_fOutOfMemory(false) +{ + if (!a_fAppend) + m_pDst->setNull(); +} + + +RTCRestOutputPrettyToString::~RTCRestOutputPrettyToString() +{ + /* We don't own the string, so we don't delete it! */ + m_pDst = NULL; +} + + +size_t RTCRestOutputPrettyToString::output(const char *a_pchString, size_t a_cchToWrite) RT_NOEXCEPT +{ + if (a_cchToWrite) + { + RTCString *pDst = m_pDst; + if (pDst && !m_fOutOfMemory) + { + /* + * Make sure we've got sufficient space available before we append. + */ + size_t cchCurrent = pDst->length(); + size_t cbCapacity = pDst->capacity(); + size_t cbNeeded = cchCurrent + a_cchToWrite + 1; + if (cbNeeded <= cbCapacity) + { /* likely */ } + else + { + /* Grow it. */ + if (cbNeeded < _16M) + { + if (cbCapacity <= _1K) + cbCapacity = _1K; + else + cbCapacity = RT_ALIGN_Z(cbCapacity, _1K); + while (cbCapacity < cbNeeded) + cbCapacity <<= 1; + } + else + { + cbCapacity = RT_ALIGN_Z(cbCapacity, _2M); + while (cbCapacity < cbNeeded) + cbCapacity += _2M; + } + int rc = pDst->reserveNoThrow(cbCapacity); + if (RT_SUCCESS(rc)) + { + rc = pDst->reserveNoThrow(cbNeeded); + if (RT_FAILURE(rc)) + { + m_fOutOfMemory = true; + return a_cchToWrite; + } + } + } + + /* + * Do the appending. + */ + pDst->append(a_pchString, a_cchToWrite); + } + } + return a_cchToWrite; +} + + +RTCString *RTCRestOutputPrettyToString::finalize() RT_NOEXCEPT +{ + RTCString *pRet; + if (!m_fOutOfMemory) + pRet = m_pDst; + else + pRet = NULL; + m_pDst = NULL; + return pRet; +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestOutputToString.cpp b/src/VBox/Runtime/common/rest/RTCRestOutputToString.cpp new file mode 100644 index 00000000..0dac0a48 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestOutputToString.cpp @@ -0,0 +1,120 @@ +/* $Id: RTCRestOutputToString.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestOutputToString implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restoutput.h> + +#include <iprt/errcore.h> +#include <iprt/string.h> + + +RTCRestOutputToString::RTCRestOutputToString(RTCString *a_pDst, bool a_fAppend /*= false*/) RT_NOEXCEPT + : RTCRestOutputBase() + , m_pDst(a_pDst) + , m_fOutOfMemory(false) +{ + if (!a_fAppend) + m_pDst->setNull(); +} + + +RTCRestOutputToString::~RTCRestOutputToString() +{ + /* We don't own the string, so we don't delete it! */ + m_pDst = NULL; +} + + +size_t RTCRestOutputToString::output(const char *a_pchString, size_t a_cchToWrite) RT_NOEXCEPT +{ + if (a_cchToWrite) + { + RTCString *pDst = m_pDst; + if (pDst && !m_fOutOfMemory) + { + /* + * Make sure we've got sufficient space available before we append. + */ + size_t cchCurrent = pDst->length(); + size_t cbCapacity = pDst->capacity(); + size_t cbNeeded = cchCurrent + a_cchToWrite + 1; + if (cbNeeded <= cbCapacity) + { /* likely */ } + else + { + /* Grow it. */ + if (cbNeeded < _16M) + { + if (cbCapacity <= _1K) + cbCapacity = _1K; + else + cbCapacity = RT_ALIGN_Z(cbCapacity, _1K); + while (cbCapacity < cbNeeded) + cbCapacity <<= 1; + } + else + { + cbCapacity = RT_ALIGN_Z(cbCapacity, _2M); + while (cbCapacity < cbNeeded) + cbCapacity += _2M; + } + int rc = pDst->reserveNoThrow(cbCapacity); + if (RT_SUCCESS(rc)) + { + rc = pDst->reserveNoThrow(cbNeeded); + if (RT_FAILURE(rc)) + { + m_fOutOfMemory = true; + return a_cchToWrite; + } + } + } + + /* + * Do the appending. + */ + pDst->append(a_pchString, a_cchToWrite); + } + } + return a_cchToWrite; +} + + +RTCString *RTCRestOutputToString::finalize() RT_NOEXCEPT +{ + RTCString *pRet; + if (!m_fOutOfMemory) + pRet = m_pDst; + else + pRet = NULL; + m_pDst = NULL; + return pRet; +} + diff --git a/src/VBox/Runtime/common/rest/RTCRestStringMapBase.cpp b/src/VBox/Runtime/common/rest/RTCRestStringMapBase.cpp new file mode 100644 index 00000000..d0cfb6c5 --- /dev/null +++ b/src/VBox/Runtime/common/rest/RTCRestStringMapBase.cpp @@ -0,0 +1,439 @@ +/* $Id: RTCRestStringMapBase.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestStringMapBase implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/reststringmap.h> + +#include <iprt/err.h> +#include <iprt/string.h> +#include <iprt/cpp/restoutput.h> + + +/** + * Default destructor. + */ +RTCRestStringMapBase::RTCRestStringMapBase() RT_NOEXCEPT + : RTCRestObjectBase() + , m_Map(NULL) + , m_cEntries(0) +{ + RTListInit(&m_ListHead); +} + + +#if 0 /* trigger link error for now. */ +/** Copy constructor. */ +RTCRestStringMapBase::RTCRestStringMapBase(RTCRestStringMapBase const &a_rThat); +#endif + + +/** + * Destructor. + */ +RTCRestStringMapBase::~RTCRestStringMapBase() +{ + clear(); +} + + + +#if 0 /* trigger link error for now. */ +/** Copy assignment operator. */ +RTCRestStringMapBase &RTCRestStringMapBase::operator=(RTCRestStringMapBase const &a_rThat); +#endif + + +/********************************************************************************************************************************* +* Overridden base object methods * +*********************************************************************************************************************************/ + +RTCRestObjectBase *RTCRestStringMapBase::baseClone() const RT_NOEXCEPT +{ + RTCRestStringMapBase *pClone = createClone(); + if (pClone) + { + int rc = pClone->copyMapWorkerNoThrow(*this); + if (RT_SUCCESS(rc)) + return pClone; + delete pClone; + } + return NULL; +} + + +int RTCRestStringMapBase::resetToDefault() RT_NOEXCEPT +{ + /* Default is an empty map. */ + clear(); + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestStringMapBase::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + { + uint32_t const uOldState = a_rDst.beginObject(); + MapEntry const *pCur; + RTListForEachCpp(&m_ListHead, pCur, MapEntry, ListEntry) + { + a_rDst.valueSeparatorAndName(pCur->strKey.c_str(), pCur->strKey.length()); + pCur->pValue->serializeAsJson(a_rDst); + } + a_rDst.endObject(uOldState); + } + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestStringMapBase::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + /* + * Make sure the object starts out with an empty map. + */ + if (m_cEntries > 0) + clear(); + m_fNullIndicator = false; + + /* + * Iterate the object values. + */ + RTJSONIT hIterator; + int rcRet = RTJsonIteratorBeginObject(a_rCursor.m_hValue, &hIterator); + if (RT_SUCCESS(rcRet)) + { + for (;;) + { + /* Set up the sub-cursor. */ + RTCRestJsonCursor SubCursor(a_rCursor); + int rc = RTJsonIteratorQueryValue(hIterator, &SubCursor.m_hValue, &SubCursor.m_pszName); + if (RT_SUCCESS(rc)) + { + /* Call the static deserializeInstanceFromJson method of the value class. */ + RTCRestObjectBase *pObj = NULL; + rc = deserializeValueInstanceFromJson(SubCursor, &pObj); + if (RT_SUCCESS(rc)) + Assert(pObj); + else if (RT_SUCCESS(rcRet)) + rcRet = rc; + if (pObj) + { + /* Insert the value. */ + rc = putWorker(SubCursor.m_pszName, pObj, true /*a_fReplace*/); + if (rc == VINF_SUCCESS) + { /* likely */ } + else if (RT_SUCCESS(rc)) + { + a_rCursor.m_pPrimary->addError(a_rCursor, rc, "warning %Rrc inserting '%s' into map", + rc, SubCursor.m_pszName); + if (rcRet == VINF_SUCCESS) + rcRet = rc; + } + else + { + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rc, "Failed to insert '%s' into map: %Rrc", + SubCursor.m_pszName, rc); + delete pObj; + } + } + } + else + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonIteratorQueryValue failed: %Rrc", rc); + + /* + * Advance. + */ + rc = RTJsonIteratorNext(hIterator); + if (RT_SUCCESS(rc)) + { /* likely */ } + else if (rc == VERR_JSON_ITERATOR_END) + break; + else + { + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonIteratorNext failed: %Rrc", rc); + break; + } + } + + RTJsonIteratorFree(hIterator); + } + else if (rcRet == VERR_JSON_IS_EMPTY) + rcRet = VINF_SUCCESS; + else if ( rcRet == VERR_JSON_VALUE_INVALID_TYPE + && RTJsonValueGetType(a_rCursor.m_hValue) == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + rcRet = VINF_SUCCESS; + } + else + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rcRet, "RTJsonIteratorBegin failed: %Rrc (type %s)", + rcRet, RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); + return rcRet; +} + +// later? +// virtual int RTCRestStringMapBase::toString(RTCString *a_pDst, uint32_t a_fFlags = kCollectionFormat_Unspecified) const ; +// virtual int RTCRestStringMapBase::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo = NULL, +// uint32_t a_fFlags = kCollectionFormat_Unspecified) ; +// + + +RTCRestObjectBase::kTypeClass RTCRestStringMapBase::typeClass(void) const RT_NOEXCEPT +{ + return kTypeClass_StringMap; +} + + +const char *RTCRestStringMapBase::typeName(void) const RT_NOEXCEPT +{ + return "RTCRestStringMap<ValueType>"; +} + + +/********************************************************************************************************************************* +* Generic map methods * +*********************************************************************************************************************************/ + +/** + * @callback_method_impl{FNRTSTRSPACECALLBACK} + */ +/*static*/ DECLCALLBACK(int) RTCRestStringMapBase::stringSpaceDestructorCallback(PRTSTRSPACECORE pStr, void *pvUser) RT_NOEXCEPT +{ + MapEntry *pNode = (MapEntry *)pStr; + if (pNode->pValue) + { + delete pNode->pValue; + pNode->pValue = NULL; + } + pNode->strKey.setNull(); + delete pNode; + + RT_NOREF(pvUser); + return VINF_SUCCESS; +} + + +void RTCRestStringMapBase::clear() RT_NOEXCEPT +{ + RTStrSpaceDestroy(&m_Map, stringSpaceDestructorCallback, NULL); + RTListInit(&m_ListHead); + m_cEntries = 0; + m_fNullIndicator = false; +} + + +size_t RTCRestStringMapBase::size() const RT_NOEXCEPT +{ + return m_cEntries; +} + + +bool RTCRestStringMapBase::containsKey(const char *a_pszKey) const RT_NOEXCEPT +{ + return RTStrSpaceGet((PRTSTRSPACE)&m_Map, a_pszKey) != NULL; +} + + +bool RTCRestStringMapBase::containsKey(RTCString const &a_rStrKey) const RT_NOEXCEPT +{ + return containsKey(a_rStrKey.c_str()); +} + + +bool RTCRestStringMapBase::remove(const char *a_pszKey) RT_NOEXCEPT +{ + MapEntry *pRemoved = (MapEntry *)RTStrSpaceRemove(&m_Map, a_pszKey); + if (pRemoved) + { + m_cEntries--; + RTListNodeRemove(&pRemoved->ListEntry); + stringSpaceDestructorCallback(&pRemoved->Core, NULL); + return true; + } + return false; +} + + +bool RTCRestStringMapBase::remove(RTCString const &a_rStrKey) RT_NOEXCEPT +{ + return remove(a_rStrKey.c_str()); +} + + +int RTCRestStringMapBase::putNewValue(RTCRestObjectBase **a_ppValue, const char *a_pszKey, size_t a_cchKey /*= RTSTR_MAX*/, + bool a_fReplace /*= false*/) RT_NOEXCEPT +{ + RTCRestObjectBase *pValue = createValue(); + if (pValue) + { + int rc = putWorker(a_pszKey, pValue, a_fReplace, a_cchKey); + if (RT_SUCCESS(rc)) + *a_ppValue = pValue; + else + { + delete pValue; + *a_ppValue = NULL; + } + return rc; + } + *a_ppValue = NULL; + return VERR_NO_MEMORY; +} + + +int RTCRestStringMapBase::putNewValue(RTCRestObjectBase **a_ppValue, RTCString const &a_rStrKey, bool a_fReplace /*= false*/) RT_NOEXCEPT +{ + return putNewValue(a_ppValue, a_rStrKey.c_str(), a_rStrKey.length(), a_fReplace); +} + + +/********************************************************************************************************************************* +* Protected methods * +*********************************************************************************************************************************/ + +int RTCRestStringMapBase::copyMapWorkerNoThrow(RTCRestStringMapBase const &a_rThat) RT_NOEXCEPT +{ + Assert(this != &a_rThat); + clear(); + m_fNullIndicator = a_rThat.m_fNullIndicator; + + if (!a_rThat.m_fNullIndicator) + { + MapEntry const *pCur; + RTListForEachCpp(&a_rThat.m_ListHead, pCur, MapEntry, ListEntry) + { + int rc = putCopyWorker(pCur->strKey.c_str(), *pCur->pValue, true /*a_fReplace*/); + if (RT_SUCCESS(rc)) + { /* likely */ } + else + return rc; + } + } + + return VINF_SUCCESS; +} + + +void RTCRestStringMapBase::copyMapWorkerMayThrow(RTCRestStringMapBase const &a_rThat) +{ + int rc = copyMapWorkerNoThrow(a_rThat); + if (RT_SUCCESS(rc)) + return; + throw std::bad_alloc(); +} + + +int RTCRestStringMapBase::putWorker(const char *a_pszKey, RTCRestObjectBase *a_pValue, bool a_fReplace, + size_t a_cchKey /*= RTSTR_MAX*/) RT_NOEXCEPT +{ + int rc; + MapEntry *pEntry = new (std::nothrow) MapEntry; + if (pEntry) + { + rc = pEntry->strKey.assignNoThrow(a_pszKey, a_cchKey); + if (RT_SUCCESS(rc)) + { + pEntry->Core.pszString = pEntry->strKey.c_str(); + pEntry->Core.cchString = pEntry->strKey.length(); + pEntry->pValue = a_pValue; + if (RTStrSpaceInsert(&m_Map, &pEntry->Core)) + { + RTListAppend(&m_ListHead, &pEntry->ListEntry); + m_cEntries++; + m_fNullIndicator = false; + return VINF_SUCCESS; + } + + Assert(!m_fNullIndicator); + if (!a_fReplace) + rc = VERR_ALREADY_EXISTS; + else + { + /* Just replace the pValue in the existing entry. */ + MapEntry *pCollision = (MapEntry *)RTStrSpaceGet(&m_Map, a_pszKey); + if (pCollision) + { + if (pCollision->pValue) + delete pCollision->pValue; + pCollision->pValue = a_pValue; + pEntry->pValue = NULL; /* paranoia */ + rc = VWRN_ALREADY_EXISTS; + } + else + rc = VERR_INTERNAL_ERROR; + } + } + delete pEntry; + } + else + rc = VERR_NO_MEMORY; + return rc; +} + + +int RTCRestStringMapBase::putCopyWorker(const char *a_pszKey, RTCRestObjectBase const &a_rValue, bool a_fReplace, + size_t a_cchKey /*= RTSTR_MAX*/) RT_NOEXCEPT +{ + int rc; + RTCRestObjectBase *pValueCopy = a_rValue.baseClone(); + if (pValueCopy) + { + rc = putWorker(a_pszKey, pValueCopy, a_fReplace, a_cchKey); + if (RT_SUCCESS(rc)) + { /* likely */ } + else + delete pValueCopy; + } + else + rc = VERR_NO_MEMORY; + return rc; +} + + +RTCRestObjectBase *RTCRestStringMapBase::getWorker(const char *a_pszKey) RT_NOEXCEPT +{ + MapEntry *pHit = (MapEntry *)RTStrSpaceGet(&m_Map, a_pszKey); + if (pHit) + return pHit->pValue; + return NULL; +} + + +RTCRestObjectBase const *RTCRestStringMapBase::getWorker(const char *a_pszKey) const RT_NOEXCEPT +{ + MapEntry const *pHit = (MapEntry const *)RTStrSpaceGet((PRTSTRSPACE)&m_Map, a_pszKey); + if (pHit) + return pHit->pValue; + return NULL; +} + diff --git a/src/VBox/Runtime/common/rest/rest-binary.cpp b/src/VBox/Runtime/common/rest/rest-binary.cpp new file mode 100644 index 00000000..b8eb22dc --- /dev/null +++ b/src/VBox/Runtime/common/rest/rest-binary.cpp @@ -0,0 +1,698 @@ +/* $Id: rest-binary.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestBinary and Descendants. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restbase.h> +#include <iprt/cpp/restclient.h> + +#include <iprt/assert.h> +#include <iprt/errcore.h> +#include <iprt/cpp/restoutput.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The default maximum download size. */ +#if ARCH_BITS == 32 +# define RTCREST_MAX_DOWNLOAD_SIZE_DEFAULT _32M +#else +# define RTCREST_MAX_DOWNLOAD_SIZE_DEFAULT _128M +#endif + + + +/********************************************************************************************************************************* +* RTCRestBinary Implementation. * +*********************************************************************************************************************************/ +/** + * Default constructor. + */ +RTCRestBinary::RTCRestBinary() RT_NOEXCEPT + : m_pbData(NULL) + , m_cbData(0) + , m_cbAllocated(0) + , m_fFreeable(true) + , m_fReadOnly(false) +{ +} + + +/** + * Destructor. + */ +RTCRestBinary::~RTCRestBinary() +{ + freeData(); +} + +/** + * Safe copy assignment method. + */ +int RTCRestBinary::assignCopy(RTCRestBinary const &a_rThat) RT_NOEXCEPT +{ + freeData(); + if (a_rThat.m_pbData) + { + m_pbData = (uint8_t *)RTMemDup(a_rThat.m_pbData, a_rThat.m_cbAllocated); + AssertReturn(m_pbData, VERR_NO_MEMORY); + m_cbData = a_rThat.m_cbData; + m_cbAllocated = a_rThat.m_cbAllocated; + m_fFreeable = true; + m_fReadOnly = false; + m_fNullIndicator = false; + } + else + m_fNullIndicator = a_rThat.m_fNullIndicator; + return VINF_SUCCESS; +} + + +/** + * Safe buffer copy method. + */ +int RTCRestBinary::assignCopy(void const *a_pvData, size_t a_cbData) RT_NOEXCEPT +{ + if ( m_pbData == NULL + || m_fReadOnly + || a_cbData > m_cbAllocated) + { + freeData(); + m_pbData = (uint8_t *)RTMemDup(a_pvData, a_cbData); + AssertReturn(m_pbData, VERR_NO_MEMORY); + m_cbData = a_cbData; + m_cbAllocated = a_cbData; + m_fFreeable = true; + m_fReadOnly = false; + } + else + { + m_cbData = a_cbData; + memcpy(m_pbData, a_pvData, a_cbData); + } + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +/** + * Use the specified data buffer directly. + */ +int RTCRestBinary::assignReadOnly(void const *a_pvData, size_t a_cbData) RT_NOEXCEPT +{ + freeData(); + if (a_pvData) + { + m_pbData = (uint8_t *)a_pvData; + m_cbData = a_cbData; + m_cbAllocated = 0; + m_fFreeable = false; + m_fReadOnly = true; + m_fNullIndicator = false; + } + return VINF_SUCCESS; +} + + +/** + * Use the specified data buffer directly. + */ +int RTCRestBinary::assignWriteable(void *a_pvBuf, size_t a_cbBuf) RT_NOEXCEPT +{ + freeData(); + if (a_pvBuf) + { + m_pbData = (uint8_t *)a_pvBuf; + m_cbData = a_cbBuf; + m_cbAllocated = a_cbBuf; + m_fFreeable = false; + m_fReadOnly = false; + m_fNullIndicator = false; + } + return VINF_SUCCESS; +} + + +/** + * Frees the data held by the object and resets it default state. + */ +void RTCRestBinary::freeData() RT_NOEXCEPT +{ + if (m_fFreeable) + RTMemFree(m_pbData); + m_pbData = NULL; + m_cbData = 0; + m_cbAllocated = 0; + m_fFreeable = true; + m_fReadOnly = false; +} + + +/* Overridden methods: */ + +RTCRestObjectBase *RTCRestBinary::baseClone() const RT_NOEXCEPT +{ + RTCRestBinary *pClone = new (std::nothrow) RTCRestBinary(); + if (pClone) + { + int rc = pClone->assignCopy(*this); + if (RT_SUCCESS(rc)) + return pClone; + delete pClone; + } + return NULL; +} + + +int RTCRestBinary::setNull(void) RT_NOEXCEPT +{ + freeData(); + m_fNullIndicator = true; + return VINF_SUCCESS; +} + + +int RTCRestBinary::resetToDefault(void) RT_NOEXCEPT +{ + freeData(); + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestBinary::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + AssertMsgFailed(("We should never get here!\n")); + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestBinary::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NOT_SUPPORTED, "RTCRestBinary does not support deserialization!"); +} + + +int RTCRestBinary::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + RT_NOREF(a_pDst, a_fFlags); + AssertFailedReturn(VERR_NOT_SUPPORTED); +} + + +int RTCRestBinary::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo/*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + RT_NOREF(a_rValue, a_pszName, a_fFlags); + AssertFailedReturn(RTErrInfoSet(a_pErrInfo, VERR_NOT_SUPPORTED, "RTCRestBinary does not support fromString()!")); +} + + +RTCRestObjectBase::kTypeClass RTCRestBinary::typeClass(void) const RT_NOEXCEPT +{ + return kTypeClass_Binary; +} + + +const char *RTCRestBinary::typeName(void) const RT_NOEXCEPT +{ + return "RTCRestBinary"; +} + + +/** Factory method. */ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestBinary::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestBinary(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestBinary::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) RT_NOEXCEPT +{ + RTCRestObjectBase *pObj; + *a_ppInstance = pObj = createInstance(); + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + + + +/********************************************************************************************************************************* +* RTCRestBinaryParameter Implementation. * +*********************************************************************************************************************************/ + +/** + * Default constructor. + */ +RTCRestBinaryParameter::RTCRestBinaryParameter() RT_NOEXCEPT + : RTCRestBinary() + , m_cbContentLength(UINT64_MAX) + , m_strContentType() + , m_pfnProducer(NULL) + , m_pvCallbackData(NULL) +{ +} + + +int RTCRestBinaryParameter::assignCopy(RTCRestBinaryParameter const &a_rThat) RT_NOEXCEPT +{ + AssertReturn(a_rThat.m_pfnProducer, VERR_INVALID_STATE); + int rc = assignCopy(*(RTCRestBinary const *)&a_rThat); + if (RT_SUCCESS(rc)) + rc = m_strContentType.assignNoThrow(a_rThat.m_strContentType); + m_cbContentLength = a_rThat.m_cbContentLength; + m_pfnProducer = a_rThat.m_pfnProducer; + m_pvCallbackData = a_rThat.m_pvCallbackData; + return VINF_SUCCESS; +} + + +int RTCRestBinaryParameter::assignCopy(RTCRestBinary const &a_rThat) RT_NOEXCEPT +{ + m_cbContentLength = a_rThat.getSize(); + m_strContentType.setNull(); + m_pfnProducer = NULL; + m_pvCallbackData = NULL; + return RTCRestBinary::assignCopy(a_rThat); +} + + +int RTCRestBinaryParameter::assignCopy(void const *a_pvData, size_t a_cbData) RT_NOEXCEPT +{ + m_cbContentLength = a_cbData; + m_pfnProducer = NULL; + m_pvCallbackData = NULL; + return RTCRestBinary::assignCopy(a_pvData, a_cbData); +} + + +int RTCRestBinaryParameter::assignReadOnly(void const *a_pvData, size_t a_cbData) RT_NOEXCEPT +{ + m_cbContentLength = a_cbData; + m_pfnProducer = NULL; + m_pvCallbackData = NULL; + return RTCRestBinary::assignReadOnly(a_pvData, a_cbData); +} + + +int RTCRestBinaryParameter::assignWriteable(void *a_pvBuf, size_t a_cbBuf) RT_NOEXCEPT +{ + AssertMsgFailed(("Please use assignReadOnly!\n")); + return assignReadOnly(a_pvBuf, a_cbBuf); +} + + +RTCRestObjectBase *RTCRestBinaryParameter::baseClone() const RT_NOEXCEPT +{ + RTCRestBinaryParameter *pClone = new (std::nothrow) RTCRestBinaryParameter(); + if (pClone) + { + int rc = pClone->assignCopy(*this); + if (RT_SUCCESS(rc)) + return pClone; + delete pClone; + } + return NULL; +} + + +int RTCRestBinaryParameter::resetToDefault() RT_NOEXCEPT +{ + m_cbContentLength = UINT64_MAX; + m_pfnProducer = NULL; + m_pvCallbackData = NULL; + return RTCRestBinary::resetToDefault(); +} + + +const char *RTCRestBinaryParameter::typeName(void) const RT_NOEXCEPT +{ + return "RTCRestBinaryParameter"; +} + + +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestBinaryParameter::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestBinaryParameter(); +} + + +int RTCRestBinaryParameter::setContentType(const char *a_pszContentType) RT_NOEXCEPT +{ + return m_strContentType.assignNoThrow(a_pszContentType); +} + + +void RTCRestBinaryParameter::setProducerCallback(PFNPRODUCER a_pfnProducer, void *a_pvCallbackData /*= NULL*/, + uint64_t a_cbContentLength /*= UINT64_MAX*/) RT_NOEXCEPT +{ + freeData(); + + m_pfnProducer = a_pfnProducer; + m_pvCallbackData = a_pvCallbackData; + m_cbContentLength = a_cbContentLength; +} + + +int RTCRestBinaryParameter::xmitPrepare(RTHTTP a_hHttp) const RT_NOEXCEPT +{ + AssertReturn(m_pbData != NULL || m_pfnProducer != NULL || m_cbContentLength == 0, VERR_INVALID_STATE); + + + /* + * Set the content type if given. + */ + if (m_strContentType.isNotEmpty()) + { + Assert(!RTHttpGetHeader(a_hHttp, RT_STR_TUPLE("Content-Type"))); + int rc = RTHttpAddHeader(a_hHttp, "Content-Type", m_strContentType.c_str(), m_strContentType.length(), + RTHTTPADDHDR_F_BACK); + AssertRCReturn(rc, rc); + } + + /* + * Set the content length if given. + */ + if (m_cbContentLength != UINT64_MAX) + { + const char *pszContentLength = RTHttpGetHeader(a_hHttp, RT_STR_TUPLE("Content-Length")); + AssertMsgReturn(!pszContentLength || RTStrToUInt64(pszContentLength) == m_cbContentLength, + ("pszContentLength=%s does not match m_cbContentLength=%RU64\n", pszContentLength, m_cbContentLength), + VERR_MISMATCH); + if (!pszContentLength) + { + char szValue[64]; + ssize_t cchValue = RTStrFormatU64(szValue, sizeof(szValue), m_cbContentLength, 10, 0, 0, 0); + int rc = RTHttpAddHeader(a_hHttp, "Content-Length", szValue, cchValue, RTHTTPADDHDR_F_BACK); + AssertRCReturn(rc, rc); + } + } + + /* + * Register an upload callback. + */ + int rc = RTHttpSetUploadCallback(a_hHttp, m_cbContentLength, xmitHttpCallback, (RTCRestBinaryParameter *)this); + AssertRCReturn(rc, rc); + + return VINF_SUCCESS; + +} + + +/*static*/ DECLCALLBACK(int) +RTCRestBinaryParameter::xmitHttpCallback(RTHTTP hHttp, void *pvBuf, size_t cbBuf, + uint64_t offContent, size_t *pcbActual, void *pvUser) RT_NOEXCEPT +{ + RTCRestBinaryParameter *pThis = (RTCRestBinaryParameter *)pvUser; + + /* + * Call the user upload callback if we've got one. + */ + if (pThis->m_pfnProducer) + return pThis->m_pfnProducer(pThis, pvBuf, cbBuf, offContent, pcbActual); + + /* + * Feed from the memory buffer. + */ + if (offContent < pThis->m_cbContentLength) + { + uint64_t const cbLeft = pThis->m_cbContentLength - offContent; + size_t const cbToCopy = cbLeft >= cbBuf ? cbBuf : (size_t)cbLeft; + memcpy(pvBuf, &pThis->m_pbData[(size_t)offContent], cbToCopy); + *pcbActual = cbToCopy; + } + else + *pcbActual = 0; + + RT_NOREF(hHttp); + return VINF_SUCCESS; +} + + +void RTCRestBinaryParameter::xmitComplete(RTHTTP a_hHttp) const RT_NOEXCEPT +{ + /* Unset the callback. */ + int rc = RTHttpSetUploadCallback(a_hHttp, UINT64_MAX, NULL, NULL); + AssertRC(rc); +} + + +/********************************************************************************************************************************* +* RTCRestBinaryResponse Implementation. * +*********************************************************************************************************************************/ + +/** + * Default constructor. + */ +RTCRestBinaryResponse::RTCRestBinaryResponse() RT_NOEXCEPT + : RTCRestBinary() + , m_cbContentLength(UINT64_MAX) + , m_cbDownloaded(0) + , m_pfnConsumer(NULL) + , m_pvCallbackData(NULL) + , m_cbMaxDownload(RTCREST_MAX_DOWNLOAD_SIZE_DEFAULT) +{ +} + + +int RTCRestBinaryResponse::assignCopy(RTCRestBinaryResponse const &a_rThat) RT_NOEXCEPT +{ + AssertReturn(a_rThat.m_pfnConsumer, VERR_INVALID_STATE); + int rc = assignCopy(*(RTCRestBinary const *)&a_rThat); + m_cbContentLength = a_rThat.m_cbContentLength; + m_cbDownloaded = a_rThat.m_cbDownloaded; + m_cbMaxDownload = a_rThat.m_cbMaxDownload; + return rc; +} + + +int RTCRestBinaryResponse::assignCopy(RTCRestBinary const &a_rThat) RT_NOEXCEPT +{ + m_cbContentLength = UINT64_MAX; + m_cbDownloaded = 0; + m_pfnConsumer = NULL; + m_pvCallbackData = NULL; + return RTCRestBinary::assignCopy(a_rThat); +} + + +int RTCRestBinaryResponse::assignCopy(void const *a_pvData, size_t a_cbData) RT_NOEXCEPT +{ + RT_NOREF(a_pvData, a_cbData); + AssertMsgFailedReturn(("Makes no sense for downloads.\n"), VERR_INVALID_STATE); +} + + +int RTCRestBinaryResponse::assignReadOnly(void const *a_pvData, size_t a_cbData) RT_NOEXCEPT +{ + RT_NOREF(a_pvData, a_cbData); + AssertMsgFailedReturn(("Makes no sense for downloads.\n"), VERR_INVALID_STATE); +} + + +int RTCRestBinaryResponse::assignWriteable(void *a_pvBuf, size_t a_cbBuf) RT_NOEXCEPT +{ + m_cbContentLength = UINT64_MAX; + m_cbDownloaded = 0; + m_pfnConsumer = NULL; + m_pvCallbackData = NULL; + AssertStmt(a_cbBuf <= m_cbMaxDownload, m_cbMaxDownload = a_cbBuf); + return RTCRestBinary::assignWriteable(a_pvBuf, a_cbBuf); +} + + +RTCRestObjectBase *RTCRestBinaryResponse::baseClone() const RT_NOEXCEPT +{ + RTCRestBinaryResponse *pClone = new (std::nothrow) RTCRestBinaryResponse(); + if (pClone) + { + int rc = pClone->assignCopy(*this); + if (RT_SUCCESS(rc)) + return pClone; + delete pClone; + } + return NULL; +} + + +int RTCRestBinaryResponse::resetToDefault() RT_NOEXCEPT +{ + m_cbContentLength = UINT64_MAX; + m_cbDownloaded = 0; + m_pfnConsumer = NULL; + m_pvCallbackData = NULL; + m_cbMaxDownload = RTCREST_MAX_DOWNLOAD_SIZE_DEFAULT; + return RTCRestBinary::resetToDefault(); +} + + +const char *RTCRestBinaryResponse::typeName(void) const RT_NOEXCEPT +{ + return "RTCRestBinaryResponse"; +} + + +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestBinaryResponse::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestBinaryResponse(); +} + + +void RTCRestBinaryResponse::setMaxDownloadSize(size_t a_cbMaxDownload) RT_NOEXCEPT +{ + if (a_cbMaxDownload == 0) + m_cbMaxDownload = RTCREST_MAX_DOWNLOAD_SIZE_DEFAULT; + else + m_cbMaxDownload = a_cbMaxDownload; +} + + +void RTCRestBinaryResponse::setConsumerCallback(PFNCONSUMER a_pfnConsumer, void *a_pvCallbackData /*= NULL*/) RT_NOEXCEPT +{ + freeData(); + + m_pfnConsumer = a_pfnConsumer; + m_pvCallbackData = a_pvCallbackData; + m_cbDownloaded = 0; + m_cbContentLength = UINT64_MAX; +} + + +int RTCRestBinaryResponse::receivePrepare(RTHTTP a_hHttp, uint32_t a_fCallbackFlags) RT_NOEXCEPT +{ + AssertReturn(!m_fReadOnly, VERR_INVALID_STATE); + + /* + * Register the download callback. + */ + int rc = RTHttpSetDownloadCallback(a_hHttp, a_fCallbackFlags, receiveHttpCallback, this); + AssertRC(rc); + return rc; +} + + +/*static*/ DECLCALLBACK(int) +RTCRestBinaryResponse::receiveHttpCallback(RTHTTP hHttp, void const *pvBuf, size_t cbBuf, uint32_t uHttpStatus, + uint64_t offContent, uint64_t cbContent, void *pvUser) RT_NOEXCEPT +{ + RTCRestBinaryResponse *pThis = (RTCRestBinaryResponse *)pvUser; + Assert(offContent == pThis->m_cbDownloaded); + pThis->m_cbContentLength = cbContent; + + /* + * Call the user download callback if we've got one. + */ + if (pThis->m_pfnConsumer) + { + int rc = pThis->m_pfnConsumer(pThis, pvBuf, cbBuf, uHttpStatus, offContent, cbContent); + if (RT_SUCCESS(rc)) + pThis->m_cbDownloaded = offContent + cbBuf; + return rc; + } + + /* + * Check download limit before adding more data. + */ + AssertMsgReturn(offContent + cbBuf <= pThis->m_cbMaxDownload, + ("%RU64 + %zu = %RU64; max=%RU64", offContent, cbBuf, offContent + cbBuf, pThis->m_cbMaxDownload), + VERR_TOO_MUCH_DATA); + + /* + * Make sure we've got sufficient writable buffer space before we copy in the data. + */ + AssertReturn(!pThis->m_fReadOnly, VERR_INVALID_STATE); + if (offContent + cbBuf <= pThis->m_cbAllocated) + { /* likely, except for the first time. */ } + else + { + AssertMsgReturn(pThis->m_fFreeable, + ("offContent=%RU64 cbBuf=%zu m_cbAllocated=%zu", offContent, cbBuf, pThis->m_cbAllocated), + VERR_TOO_MUCH_DATA); + AssertMsgReturn(cbContent <= pThis->m_cbMaxDownload || cbContent == UINT64_MAX, + ("cbContent: %RU64; max=%RU64", cbContent, pThis->m_cbMaxDownload), + VERR_TOO_MUCH_DATA); + + if (offContent == 0 && cbContent != UINT64_MAX) + { + void *pvNew = RTMemRealloc(pThis->m_pbData, (size_t)cbContent); + if (!pvNew) + return VERR_NO_MEMORY; + pThis->m_pbData = (uint8_t *)pvNew; + pThis->m_cbAllocated = (size_t)cbContent; + } + else + { + size_t cbNeeded = offContent + cbBuf; + size_t cbNew; + if (pThis->m_cbAllocated == 0) + cbNew = RT_MAX(_64K, RT_ALIGN_Z(cbNeeded, _64K)); + else if (pThis->m_cbAllocated < _64M && cbNeeded <= _64M) + { + cbNew = pThis->m_cbAllocated * 2; + while (cbNew < cbNeeded) + cbNew *= 2; + } + else + cbNew = RT_ALIGN_Z(cbNeeded, _32M); + + void *pvNew = RTMemRealloc(pThis->m_pbData, cbNew); + if (!pvNew) + return VERR_NO_MEMORY; + pThis->m_pbData = (uint8_t *)pvNew; + pThis->m_cbAllocated = cbNew; + } + } + + /* + * Do the copying. + */ + memcpy(&pThis->m_pbData[(size_t)offContent], pvBuf, cbBuf); + pThis->m_cbDownloaded = offContent + cbBuf; + + /* we cap it at m_cbMaxDownload which is size_t so this cast is safe */ + pThis->m_cbData = (size_t)pThis->m_cbDownloaded; + + RT_NOREF(hHttp); + return VINF_SUCCESS; +} + + +void RTCRestBinaryResponse::receiveComplete(RTHTTP a_hHttp) RT_NOEXCEPT +{ + /* Unset the callback. */ + int rc = RTHttpSetDownloadCallback(a_hHttp, RTHTTPDOWNLOAD_F_ANY_STATUS, NULL, NULL); + AssertRC(rc); +} + diff --git a/src/VBox/Runtime/common/rest/rest-primary-object-types.cpp b/src/VBox/Runtime/common/rest/rest-primary-object-types.cpp new file mode 100644 index 00000000..abc4c23d --- /dev/null +++ b/src/VBox/Runtime/common/rest/rest-primary-object-types.cpp @@ -0,0 +1,2387 @@ +/* $Id: rest-primary-object-types.cpp $ */ +/** @file + * IPRT - C++ REST, RTCRestObjectBase implementation. + */ + +/* + * Copyright (C) 2018-2020 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_REST +#include <iprt/cpp/restbase.h> + +#include <iprt/ctype.h> +#include <iprt/err.h> +#include <iprt/string.h> +#include <iprt/cpp/restoutput.h> + +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> + + + +/********************************************************************************************************************************* +* RTCRestObjectBase implementation * +*********************************************************************************************************************************/ + +/** Default constructor. */ +RTCRestObjectBase::RTCRestObjectBase() RT_NOEXCEPT + : m_fNullIndicator(false) +{ +} + + +/** Copy constructor. */ +RTCRestObjectBase::RTCRestObjectBase(RTCRestObjectBase const &a_rThat) RT_NOEXCEPT + : m_fNullIndicator(a_rThat.m_fNullIndicator) +{ +} + + +/** Destructor. */ +RTCRestObjectBase::~RTCRestObjectBase() +{ + /* nothing to do */ +} + + +/** Copy assignment operator. */ +RTCRestObjectBase &RTCRestObjectBase::operator=(RTCRestObjectBase const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + return *this; +} + + +int RTCRestObjectBase::setNull() RT_NOEXCEPT +{ + int rc = resetToDefault(); + m_fNullIndicator = true; + return rc; +} + + +void RTCRestObjectBase::setNotNull() RT_NOEXCEPT +{ + m_fNullIndicator = false; +} + + +int RTCRestObjectBase::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + /* + * Just wrap the JSON serialization method. + */ + RTCRestOutputToString Tmp(a_pDst, RT_BOOL(a_fFlags & kToString_Append)); + serializeAsJson(Tmp); + return Tmp.finalize() ? VINF_SUCCESS : VERR_NO_MEMORY; +} + + +RTCString RTCRestObjectBase::toString() const +{ + RTCString strRet; + toString(&strRet, 0); + return strRet; +} + + +int RTCRestObjectBase::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + RT_NOREF(a_fFlags); + + /* + * Just wrap the JSON serialization method. + */ + RTJSONVAL hValue = NIL_RTJSONVAL; + int rc = RTJsonParseFromString(&hValue, a_rValue.c_str(), a_pErrInfo); + if (RT_SUCCESS(rc)) + { + RTCRestJsonPrimaryCursor PrimaryCursor(hValue, a_pszName, a_pErrInfo); + rc = deserializeFromJson(PrimaryCursor.m_Cursor); + } + return rc; +} + + + +/********************************************************************************************************************************* +* RTCRestBool implementation * +*********************************************************************************************************************************/ + +/** Factory method. */ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestBool::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestBool(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestBool::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) RT_NOEXCEPT +{ + RTCRestObjectBase *pObj = createInstance(); + *a_ppInstance = pObj; + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + + +/** Default constructor. */ +RTCRestBool::RTCRestBool() RT_NOEXCEPT + : RTCRestObjectBase() + , m_fValue(false) +{ +} + + +/** Copy constructor. */ +RTCRestBool::RTCRestBool(RTCRestBool const &a_rThat) RT_NOEXCEPT + : RTCRestObjectBase(a_rThat) + , m_fValue(a_rThat.m_fValue) +{ +} + + +/** From value constructor. */ +RTCRestBool::RTCRestBool(bool fValue) RT_NOEXCEPT + : m_fValue(fValue) +{ +} + + +/** Destructor. */ +RTCRestBool::~RTCRestBool() +{ + /* nothing to do */ +} + + +/** Copy assignment operator. */ +RTCRestBool &RTCRestBool::operator=(RTCRestBool const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_fValue = a_rThat.m_fValue; + return *this; +} + + +int RTCRestBool::assignCopy(RTCRestBool const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_fValue = a_rThat.m_fValue; + return VINF_SUCCESS; +} + + +void RTCRestBool::assignValue(bool a_fValue) RT_NOEXCEPT +{ + m_fValue = a_fValue; + m_fNullIndicator = false; +} + + +RTCRestObjectBase *RTCRestBool::baseClone() const RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestBool(*this); +} + + +int RTCRestBool::resetToDefault() RT_NOEXCEPT +{ + m_fValue = false; + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestBool::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + a_rDst.printf(!m_fNullIndicator ? m_fValue ? "true" : "false" : "null"); + return a_rDst; +} + + +int RTCRestBool::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + m_fValue = false; + m_fNullIndicator = false; + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + + if (enmType == RTJSONVALTYPE_TRUE) + { + m_fValue = true; + return VINF_SUCCESS; + } + + if (enmType == RTJSONVALTYPE_FALSE) + return VINF_SUCCESS; + + if (enmType == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_WRONG_JSON_TYPE_FOR_BOOL, "wrong JSON type %s for boolean", + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + + +int RTCRestBool::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + if (!(a_fFlags & kToString_Append)) + { + if (!m_fNullIndicator) + { + if (m_fValue) + return a_pDst->assignNoThrow(RT_STR_TUPLE("true")); + return a_pDst->assignNoThrow(RT_STR_TUPLE("false")); + } + return a_pDst->assignNoThrow(RT_STR_TUPLE("null")); + } + + if (!m_fNullIndicator) + { + if (m_fValue) + return a_pDst->appendNoThrow(RT_STR_TUPLE("true")); + return a_pDst->appendNoThrow(RT_STR_TUPLE("false")); + } + return a_pDst->appendNoThrow(RT_STR_TUPLE("null")); +} + + +int RTCRestBool::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + RT_NOREF(a_fFlags); + + if (a_rValue.startsWithWord("true", RTCString::CaseInsensitive)) + { + m_fValue = true; + m_fNullIndicator = false; + } + else if (a_rValue.startsWithWord("false", RTCString::CaseInsensitive)) + { + m_fValue = false; + m_fNullIndicator = false; + } + else if (a_rValue.startsWithWord("null", RTCString::CaseInsensitive)) + { + m_fValue = false; + m_fNullIndicator = true; + } + else + return RTErrInfoSetF(a_pErrInfo, VERR_REST_UNABLE_TO_PARSE_STRING_AS_BOOL, + "%s: unable to parse '%s' as bool", a_pszName, a_rValue.c_str()); + return VINF_SUCCESS; +} + + +RTCRestObjectBase::kTypeClass RTCRestBool::typeClass() const RT_NOEXCEPT +{ + return kTypeClass_Bool; +} + + +const char *RTCRestBool::typeName() const RT_NOEXCEPT +{ + return "bool"; +} + + + +/********************************************************************************************************************************* +* RTCRestInt64 implementation * +*********************************************************************************************************************************/ + +/** Factory method. */ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestInt64::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestInt64(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestInt64::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) RT_NOEXCEPT +{ + RTCRestObjectBase *pObj = createInstance(); + *a_ppInstance = pObj; + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + + +/** Default constructor. */ +RTCRestInt64::RTCRestInt64() RT_NOEXCEPT + : RTCRestObjectBase() + , m_iValue(0) +{ +} + + +/** Copy constructor. */ +RTCRestInt64::RTCRestInt64(RTCRestInt64 const &a_rThat) RT_NOEXCEPT + : RTCRestObjectBase(a_rThat) + , m_iValue(a_rThat.m_iValue) +{ +} + + +/** From value constructor. */ +RTCRestInt64::RTCRestInt64(int64_t iValue) RT_NOEXCEPT + : RTCRestObjectBase() + , m_iValue(iValue) +{ +} + + +/** Destructor. */ +RTCRestInt64::~RTCRestInt64() +{ + /* nothing to do */ +} + + +/** Copy assignment operator. */ +RTCRestInt64 &RTCRestInt64::operator=(RTCRestInt64 const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_iValue = a_rThat.m_iValue; + return *this; +} + + +int RTCRestInt64::assignCopy(RTCRestInt64 const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_iValue = a_rThat.m_iValue; + return VINF_SUCCESS; +} + + +void RTCRestInt64::assignValue(int64_t a_iValue) RT_NOEXCEPT +{ + m_iValue = a_iValue; + m_fNullIndicator = false; +} + + +RTCRestObjectBase *RTCRestInt64::baseClone() const RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestInt64(*this); +} + + +int RTCRestInt64::resetToDefault() RT_NOEXCEPT +{ + m_iValue = 0; + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestInt64::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + a_rDst.printf("%RI64", m_iValue); + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestInt64::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + m_iValue = 0; + m_fNullIndicator = false; + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + if (enmType == RTJSONVALTYPE_INTEGER) + { + int rc = RTJsonValueQueryInteger(a_rCursor.m_hValue, &m_iValue); + if (RT_SUCCESS(rc)) + return rc; + return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonValueQueryInteger failed with %Rrc", rc); + } + + if (enmType == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + /* This is probably non-sense... */ + if (enmType == RTJSONVALTYPE_TRUE) + m_iValue = 1; + + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_WRONG_JSON_TYPE_FOR_INTEGER, "wrong JSON type %s for 64-bit integer", + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + + +int RTCRestInt64::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + if (!(a_fFlags & kToString_Append)) + { + if (!m_fNullIndicator) + return a_pDst->printfNoThrow("%RI64", m_iValue); + return a_pDst->assignNoThrow(RT_STR_TUPLE("null")); + } + if (!m_fNullIndicator) + return a_pDst->appendPrintfNoThrow("%RI64", m_iValue); + return a_pDst->appendNoThrow(RT_STR_TUPLE("null")); +} + + +int RTCRestInt64::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + RT_NOREF(a_fFlags); + + m_iValue = 0; + m_fNullIndicator = false; + +/** @todo RTStrStripL and RTStrToInt64Full has a different idea what consitutes spaces... */ + int rc = RTStrToInt64Full(RTStrStripL(a_rValue.c_str()), 0, &m_iValue); + if (rc == VINF_SUCCESS || rc == VERR_TRAILING_SPACES) + return VINF_SUCCESS; + + if (a_rValue.startsWithWord("null", RTCString::CaseInsensitive)) + { + m_iValue = 0; + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + return RTErrInfoSetF(a_pErrInfo, rc, "%s: error %Rrc parsing '%s' as int64_t", a_pszName, rc, a_rValue.c_str()); +} + + +RTCRestObjectBase::kTypeClass RTCRestInt64::typeClass() const RT_NOEXCEPT +{ + return kTypeClass_Int64; +} + + +const char *RTCRestInt64::typeName() const RT_NOEXCEPT +{ + return "int64_t"; +} + + + +/********************************************************************************************************************************* +* RTCRestInt32 implementation * +*********************************************************************************************************************************/ + +/** Factory method. */ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestInt32::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestInt32(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestInt32::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) RT_NOEXCEPT +{ + RTCRestObjectBase *pObj = createInstance(); + *a_ppInstance = pObj; + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + + +/** Default constructor. */ +RTCRestInt32::RTCRestInt32() RT_NOEXCEPT + : RTCRestObjectBase() + , m_iValue(0) +{ +} + + +/** Copy constructor. */ +RTCRestInt32::RTCRestInt32(RTCRestInt32 const &a_rThat) RT_NOEXCEPT + : RTCRestObjectBase(a_rThat) + , m_iValue(a_rThat.m_iValue) +{ +} + + +/** From value constructor. */ +RTCRestInt32::RTCRestInt32(int32_t iValue) RT_NOEXCEPT + : RTCRestObjectBase() + , m_iValue(iValue) +{ +} + + +/** Destructor. */ +RTCRestInt32::~RTCRestInt32() +{ + /* nothing to do */ +} + + +/** Copy assignment operator. */ +RTCRestInt32 &RTCRestInt32::operator=(RTCRestInt32 const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_iValue = a_rThat.m_iValue; + return *this; +} + + +int RTCRestInt32::assignCopy(RTCRestInt32 const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_iValue = a_rThat.m_iValue; + return VINF_SUCCESS; +} + + +RTCRestObjectBase *RTCRestInt32::baseClone() const RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestInt32(*this); +} + + +int RTCRestInt32::resetToDefault() RT_NOEXCEPT +{ + m_iValue = 0; + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +void RTCRestInt32::assignValue(int32_t a_iValue) RT_NOEXCEPT +{ + m_iValue = a_iValue; + m_fNullIndicator = false; +} + + +RTCRestOutputBase &RTCRestInt32::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + a_rDst.printf("%RI32", m_iValue); + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestInt32::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + m_iValue = 0; + m_fNullIndicator = false; + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + if (enmType == RTJSONVALTYPE_INTEGER) + { + int64_t iTmp = m_iValue; + int rc = RTJsonValueQueryInteger(a_rCursor.m_hValue, &iTmp); + if (RT_SUCCESS(rc)) + { + m_iValue = (int32_t)iTmp; + if (m_iValue == iTmp) + return rc; + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_OUT_OF_RANGE, "value %RI64 does not fit in 32 bits", iTmp); + } + return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonValueQueryInteger failed with %Rrc", rc); + } + + if (enmType == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + /* This is probably non-sense... */ + if (enmType == RTJSONVALTYPE_TRUE) + m_iValue = 1; + + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_WRONG_JSON_TYPE_FOR_INTEGER, "wrong JSON type %s for 32-bit integer", + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + + +int RTCRestInt32::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + if (!(a_fFlags & kToString_Append)) + { + if (!m_fNullIndicator) + return a_pDst->printfNoThrow("%RI32", m_iValue); + return a_pDst->assignNoThrow(RT_STR_TUPLE("null")); + } + if (!m_fNullIndicator) + return a_pDst->appendPrintfNoThrow("%RI32", m_iValue); + return a_pDst->appendNoThrow(RT_STR_TUPLE("null")); +} + + +int RTCRestInt32::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + RT_NOREF(a_fFlags); + + m_iValue = 0; + m_fNullIndicator = false; + +/** @todo RTStrStripL and RTStrToInt32Full has a different idea what consitutes spaces... */ + int rc = RTStrToInt32Full(RTStrStripL(a_rValue.c_str()), 0, &m_iValue); + if (rc == VINF_SUCCESS || rc == VERR_TRAILING_SPACES) + return VINF_SUCCESS; + + if (a_rValue.startsWithWord("null", RTCString::CaseInsensitive)) + { + m_iValue = 0; + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + return RTErrInfoSetF(a_pErrInfo, rc, "%s: error %Rrc parsing '%s' as int32_t", a_pszName, rc, a_rValue.c_str()); +} + + +RTCRestObjectBase::kTypeClass RTCRestInt32::typeClass() const RT_NOEXCEPT +{ + return kTypeClass_Int32; +} + + +const char *RTCRestInt32::typeName() const RT_NOEXCEPT +{ + return "int32_t"; +} + + + +/********************************************************************************************************************************* +* RTCRestInt16 implementation * +*********************************************************************************************************************************/ + +/** Factory method. */ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestInt16::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestInt16(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestInt16::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) RT_NOEXCEPT +{ + RTCRestObjectBase *pObj = createInstance(); + *a_ppInstance = pObj; + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + + +/** Default constructor. */ +RTCRestInt16::RTCRestInt16() RT_NOEXCEPT + : RTCRestObjectBase() + , m_iValue(0) +{ +} + + +/** Copy constructor. */ +RTCRestInt16::RTCRestInt16(RTCRestInt16 const &a_rThat) RT_NOEXCEPT + : RTCRestObjectBase(a_rThat) + , m_iValue(a_rThat.m_iValue) +{ +} + + +/** From value constructor. */ +RTCRestInt16::RTCRestInt16(int16_t iValue) RT_NOEXCEPT + : RTCRestObjectBase() + , m_iValue(iValue) +{ +} + + +/** Destructor. */ +RTCRestInt16::~RTCRestInt16() +{ + /* nothing to do */ +} + + +/** Copy assignment operator. */ +RTCRestInt16 &RTCRestInt16::operator=(RTCRestInt16 const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_iValue = a_rThat.m_iValue; + return *this; +} + + +int RTCRestInt16::assignCopy(RTCRestInt16 const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_iValue = a_rThat.m_iValue; + return VINF_SUCCESS; +} + + +void RTCRestInt16::assignValue(int16_t a_iValue) RT_NOEXCEPT +{ + m_iValue = a_iValue; + m_fNullIndicator = false; +} + + +RTCRestObjectBase *RTCRestInt16::baseClone() const RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestInt16(*this); +} + + +int RTCRestInt16::resetToDefault() RT_NOEXCEPT +{ + m_iValue = 0; + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestInt16::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + a_rDst.printf("%RI16", m_iValue); + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestInt16::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + m_iValue = 0; + m_fNullIndicator = false; + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + if (enmType == RTJSONVALTYPE_INTEGER) + { + int64_t iTmp = m_iValue; + int rc = RTJsonValueQueryInteger(a_rCursor.m_hValue, &iTmp); + if (RT_SUCCESS(rc)) + { + m_iValue = (int16_t)iTmp; + if (m_iValue == iTmp) + return rc; + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_OUT_OF_RANGE, "value %RI64 does not fit in 16 bits", iTmp); + } + return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonValueQueryInteger failed with %Rrc", rc); + } + + if (enmType == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + /* This is probably non-sense... */ + if (enmType == RTJSONVALTYPE_TRUE) + m_iValue = 1; + + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_WRONG_JSON_TYPE_FOR_INTEGER, "wrong JSON type %s for 16-bit integer", + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + + +int RTCRestInt16::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + if (!(a_fFlags & kToString_Append)) + { + if (!m_fNullIndicator) + return a_pDst->printfNoThrow("%RI16", m_iValue); + return a_pDst->assignNoThrow(RT_STR_TUPLE("null")); + } + if (!m_fNullIndicator) + return a_pDst->appendPrintfNoThrow("%RI16", m_iValue); + return a_pDst->appendNoThrow(RT_STR_TUPLE("null")); +} + + +int RTCRestInt16::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + RT_NOREF(a_fFlags); + + m_iValue = 0; + m_fNullIndicator = false; + +/** @todo RTStrStripL and RTStrToInt16Full has a different idea what consitutes spaces... */ + int rc = RTStrToInt16Full(RTStrStripL(a_rValue.c_str()), 0, &m_iValue); + if (rc == VINF_SUCCESS || rc == VERR_TRAILING_SPACES) + return VINF_SUCCESS; + + if (a_rValue.startsWithWord("null", RTCString::CaseInsensitive)) + { + m_iValue = 0; + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + return RTErrInfoSetF(a_pErrInfo, rc, "%s: error %Rrc parsing '%s' as int16_t", a_pszName, rc, a_rValue.c_str()); +} + + +RTCRestObjectBase::kTypeClass RTCRestInt16::typeClass() const RT_NOEXCEPT +{ + return kTypeClass_Int16; +} + + +const char *RTCRestInt16::typeName() const RT_NOEXCEPT +{ + return "int16_t"; +} + + + +/********************************************************************************************************************************* +* RTCRestDouble implementation * +*********************************************************************************************************************************/ + +/** Factory method. */ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestDouble::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestDouble(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestDouble::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) RT_NOEXCEPT +{ + RTCRestObjectBase *pObj = createInstance(); + *a_ppInstance = pObj; + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + + +/** Default constructor. */ +RTCRestDouble::RTCRestDouble() RT_NOEXCEPT + : RTCRestObjectBase() + , m_rdValue(0.0) +{ +} + + +/** Copy constructor. */ +RTCRestDouble::RTCRestDouble(RTCRestDouble const &a_rThat) RT_NOEXCEPT + : RTCRestObjectBase(a_rThat) + , m_rdValue(a_rThat.m_rdValue) +{ +} + + +/** From value constructor. */ +RTCRestDouble::RTCRestDouble(double rdValue) RT_NOEXCEPT + : RTCRestObjectBase() + , m_rdValue(rdValue) +{ +} + + +/** Destructor. */ +RTCRestDouble::~RTCRestDouble() +{ + /* nothing to do */ +} + + +/** Copy assignment operator. */ +RTCRestDouble &RTCRestDouble::operator=(RTCRestDouble const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_rdValue = a_rThat.m_rdValue; + return *this; +} + + +int RTCRestDouble::assignCopy(RTCRestDouble const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_rdValue = a_rThat.m_rdValue; + return VINF_SUCCESS; +} + + +void RTCRestDouble::assignValue(double a_rdValue) RT_NOEXCEPT +{ + m_rdValue = a_rdValue; + m_fNullIndicator = false; +} + + +RTCRestObjectBase *RTCRestDouble::baseClone() const RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestDouble(*this); +} + + +int RTCRestDouble::resetToDefault() RT_NOEXCEPT +{ + m_rdValue = 0.0; + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestDouble::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + { + + /* Just a simple approximation here. */ + /** @todo Not 100% sure printf %g produces the right result for JSON floating point, but it'll have to do for now... */ + char szValue[128]; +#ifdef _MSC_VER + _snprintf(szValue, sizeof(szValue), "%.18g", m_rdValue); +#else + snprintf(szValue, sizeof(szValue), "%.18g", m_rdValue); +#endif + size_t cchValue = strlen(szValue); + while (cchValue > 0 && szValue[cchValue - 1] == '0') + cchValue--; + szValue[cchValue] = '\0'; + + a_rDst.printf("%s", szValue); + } + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestDouble::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + m_rdValue = 0.0; + m_fNullIndicator = false; + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + if (enmType == RTJSONVALTYPE_NUMBER) + { + int rc = RTJsonValueQueryNumber(a_rCursor.m_hValue, &m_rdValue); + if (RT_SUCCESS(rc)) + return rc; + return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonValueQueryNumber failed with %Rrc", rc); + } + + if (enmType == RTJSONVALTYPE_INTEGER) + { + int64_t iTmp = 0; + int rc = RTJsonValueQueryInteger(a_rCursor.m_hValue, &iTmp); + if (RT_SUCCESS(rc)) + { + m_rdValue = iTmp; + if (m_rdValue == iTmp) + return rc; + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_OUT_OF_RANGE, "value %RI64 does not fit in a double", iTmp); + } + return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonValueQueryInteger failed with %Rrc", rc); + } + + if (enmType == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + /* This is probably non-sense... */ + if (enmType == RTJSONVALTYPE_TRUE) + m_rdValue = 1.0; + + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_WRONG_JSON_TYPE_FOR_DOUBLE, "wrong JSON type %s for a double", + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + + +int RTCRestDouble::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + { + /* Just a simple approximation here. */ + /** @todo Not 100% sure printf %g produces the right result for JSON floating point, but it'll have to do for now... */ + char szValue[128]; +#ifdef _MSC_VER + _snprintf(szValue, sizeof(szValue), "%.18g", m_rdValue); +#else + snprintf(szValue, sizeof(szValue), "%.18g", m_rdValue); +#endif + size_t cchValue = strlen(szValue); + while (cchValue > 0 && szValue[cchValue - 1] == '0') + cchValue--; + szValue[cchValue] = '\0'; + + if (!(a_fFlags & kToString_Append)) + return a_pDst->assignNoThrow(szValue, cchValue); + return a_pDst->appendNoThrow(szValue, cchValue); + } + + if (!(a_fFlags & kToString_Append)) + return a_pDst->assignNoThrow(RT_STR_TUPLE("null")); + return a_pDst->appendNoThrow(RT_STR_TUPLE("null")); +} + + +int RTCRestDouble::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + RT_NOREF(a_fFlags); + + if (a_rValue.startsWithWord("null", RTCString::CaseInsensitive)) + { + m_rdValue = 0.0; + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + m_fNullIndicator = false; + + const char *pszValue = RTStrStripL(a_rValue.c_str()); + errno = 0; + char *pszNext = NULL; + m_rdValue = strtod(pszValue, &pszNext); + if (errno == 0 && pszNext != pszValue) + { + if (!pszNext || *pszNext == '\0') + return VINF_SUCCESS; + + while (RT_C_IS_SPACE(*pszNext)) + pszNext++; + if (*pszNext == '\0') + return VINF_SUCCESS; + + return RTErrInfoSetF(a_pErrInfo, VERR_TRAILING_CHARS, "%s: error VERR_TRAILING_CHARS parsing '%s' as double", + a_pszName, a_rValue.c_str()); + } + + if (!RT_C_IS_DIGIT(*pszValue) && *pszValue != '.') + return RTErrInfoSetF(a_pErrInfo, VERR_NO_DIGITS, "%s: error VERR_NO_DIGITS parsing '%s' as double", + a_pszName, a_rValue.c_str()); + int rc = RTErrConvertFromErrno(errno); + return RTErrInfoSetF(a_pErrInfo, rc, "%s: error %Rrc parsing '%s' as double", a_pszName, rc, a_rValue.c_str()); +} + + +RTCRestObjectBase::kTypeClass RTCRestDouble::typeClass() const RT_NOEXCEPT +{ + return kTypeClass_Double; +} + + +const char *RTCRestDouble::typeName() const RT_NOEXCEPT +{ + return "double"; +} + + + +/********************************************************************************************************************************* +* RTCRestString implementation * +*********************************************************************************************************************************/ + +/** Factory method. */ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestString::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestString(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestString::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) RT_NOEXCEPT +{ + RTCRestObjectBase *pObj = createInstance(); + *a_ppInstance = pObj; + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + + +/** Default constructor. */ +RTCRestString::RTCRestString() RT_NOEXCEPT + : RTCRestObjectBase() + , RTCString() +{ +} + + +/** Copy constructor. */ +RTCRestString::RTCRestString(RTCRestString const &a_rThat) + : RTCRestObjectBase(a_rThat) + , RTCString(a_rThat) +{ +} + + +/** From value constructor. */ +RTCRestString::RTCRestString(RTCString const &a_rThat) + : RTCString(a_rThat) +{ +} + + +/** From value constructor. */ +RTCRestString::RTCRestString(const char *a_pszSrc) + : RTCRestObjectBase() + , RTCString(a_pszSrc) +{ +} + + +/** Destructor. */ +RTCRestString::~RTCRestString() +{ + /* nothing to do */ +} + + +int RTCRestString::assignCopy(RTCRestString const &a_rThat) RT_NOEXCEPT +{ + int rc = assignNoThrow(a_rThat); + m_fNullIndicator = a_rThat.m_fNullIndicator; + return rc; +} + + +int RTCRestString::assignCopy(RTCString const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = false; + return assignNoThrow(a_rThat); +} + + +int RTCRestString::assignCopy(const char *a_pszThat) RT_NOEXCEPT +{ + m_fNullIndicator = false; + return assignNoThrow(a_pszThat); +} + + +int RTCRestString::setNull() RT_NOEXCEPT +{ + RTCString::setNull(); + m_fNullIndicator = true; + return VINF_SUCCESS; +} + + +RTCRestObjectBase *RTCRestString::baseClone() const RT_NOEXCEPT +{ + RTCRestString *pClone = new (std::nothrow) RTCRestString(); + if (pClone) + { + int rc = pClone->assignCopy(*this); + if (RT_SUCCESS(rc)) + return pClone; + delete pClone; + } + return NULL; +} + + +int RTCRestString::resetToDefault() RT_NOEXCEPT +{ + RTCString::setNull(); + m_fNullIndicator = false; + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestString::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + a_rDst.printf("%RMjs", m_psz ? m_psz : ""); + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestString::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + m_fNullIndicator = false; + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + if (enmType == RTJSONVALTYPE_STRING) + { + const char *pszValue = RTJsonValueGetString(a_rCursor.m_hValue); + const size_t cchValue = strlen(pszValue); + int rc = assignNoThrow(pszValue, cchValue); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "no memory for %zu char long string", cchValue); + } + + RTCString::setNull(); + + if (enmType == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_WRONG_JSON_TYPE_FOR_STRING, "wrong JSON type %s for string", + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + + +int RTCRestString::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + /* Note! m_fNullIndicator == true: empty string. */ + if (!(a_fFlags & kToString_Append)) + return a_pDst->assignNoThrow(*this); + return a_pDst->appendNoThrow(*this); +} + + +int RTCRestString::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + RT_NOREF(a_fFlags); RT_NOREF(a_pszName); RT_NOREF(a_pErrInfo); + + /* Note! Unable to set m_fNullIndicator = true here. */ + m_fNullIndicator = false; + return assignNoThrow(a_rValue); +} + + +RTCRestObjectBase::kTypeClass RTCRestString::typeClass() const RT_NOEXCEPT +{ + return kTypeClass_String; +} + + +const char *RTCRestString::typeName() const RT_NOEXCEPT +{ + return "RTCString"; +} + + +int RTCRestString::assignNoThrow(const RTCString &a_rSrc) RT_NOEXCEPT +{ + m_fNullIndicator = false; + return RTCString::assignNoThrow(a_rSrc); +} + + +int RTCRestString::assignNoThrow(const char *a_pszSrc) RT_NOEXCEPT +{ + m_fNullIndicator = false; + return RTCString::assignNoThrow(a_pszSrc); +} + + +int RTCRestString::assignNoThrow(const RTCString &a_rSrc, size_t a_offSrc, size_t a_cchSrc /*= npos*/) RT_NOEXCEPT +{ + m_fNullIndicator = false; + return RTCString::assignNoThrow(a_rSrc, a_offSrc, a_cchSrc); +} + + +int RTCRestString::assignNoThrow(const char *a_pszSrc, size_t a_cchSrc) RT_NOEXCEPT +{ + m_fNullIndicator = false; + return RTCString::assignNoThrow(a_pszSrc, a_cchSrc); +} + + +int RTCRestString::assignNoThrow(size_t a_cTimes, char a_ch) RT_NOEXCEPT +{ + m_fNullIndicator = false; + return RTCString::assignNoThrow(a_cTimes, a_ch); +} + + +int RTCRestString::printfNoThrow(const char *pszFormat, ...) RT_NOEXCEPT +{ + m_fNullIndicator = false; + va_list va; + va_start(va, pszFormat); + int rc = RTCString::printfVNoThrow(pszFormat, va); + va_end(va); + return rc; +} + + +int RTCRestString::printfVNoThrow(const char *pszFormat, va_list va) RT_NOEXCEPT +{ + m_fNullIndicator = false; + return RTCString::printfVNoThrow(pszFormat, va); +} + + +RTCRestString &RTCRestString::operator=(const char *a_pcsz) +{ + m_fNullIndicator = false; + RTCString::operator=(a_pcsz); + return *this; +} + + +RTCRestString &RTCRestString::operator=(const RTCString &a_rThat) +{ + m_fNullIndicator = false; + RTCString::operator=(a_rThat); + return *this; +} + + +RTCRestString &RTCRestString::operator=(const RTCRestString &a_rThat) +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + RTCString::operator=(a_rThat); + return *this; +} + + +RTCRestString &RTCRestString::assign(const RTCString &a_rSrc) +{ + m_fNullIndicator = false; + RTCString::assign(a_rSrc); + return *this; +} + + +RTCRestString &RTCRestString::assign(const char *a_pszSrc) +{ + m_fNullIndicator = false; + RTCString::assign(a_pszSrc); + return *this; +} + + +RTCRestString &RTCRestString::assign(const RTCString &a_rSrc, size_t a_offSrc, size_t a_cchSrc /*= npos*/) +{ + m_fNullIndicator = false; + RTCString::assign(a_rSrc, a_offSrc, a_cchSrc); + return *this; +} + + +RTCRestString &RTCRestString::assign(const char *a_pszSrc, size_t a_cchSrc) +{ + m_fNullIndicator = false; + RTCString::assign(a_pszSrc, a_cchSrc); + return *this; +} + + +RTCRestString &RTCRestString::assign(size_t a_cTimes, char a_ch) +{ + m_fNullIndicator = false; + RTCString::assign(a_cTimes, a_ch); + return *this; +} + + +RTCRestString &RTCRestString::printf(const char *pszFormat, ...) +{ + m_fNullIndicator = false; + va_list va; + va_start(va, pszFormat); + RTCString::printfV(pszFormat, va); + va_end(va); + return *this; +} + + +RTCRestString &RTCRestString::printfV(const char *pszFormat, va_list va) +{ + m_fNullIndicator = false; + RTCString::printfV(pszFormat, va); + return *this; +} + + + +/********************************************************************************************************************************* +* RTCRestDate implementation * +*********************************************************************************************************************************/ +/*static*/ DECLCALLBACK(RTCRestObjectBase *) RTCRestDate::createInstance(void) RT_NOEXCEPT +{ + return new (std::nothrow) RTCRestDate(); +} + + +/** + * @copydoc RTCRestObjectBase::FNDESERIALIZEINSTANCEFROMJSON + */ +/*static*/ DECLCALLBACK(int) +RTCRestDate::deserializeInstanceFromJson(RTCRestJsonCursor const &a_rCursor, RTCRestObjectBase **a_ppInstance) RT_NOEXCEPT +{ + RTCRestObjectBase *pObj = createInstance(); + *a_ppInstance = pObj; + if (pObj) + return pObj->deserializeFromJson(a_rCursor); + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_NO_MEMORY, "Out of memory"); +} + + +RTCRestDate::RTCRestDate() RT_NOEXCEPT + : RTCRestObjectBase() + , m_fTimeSpecOkay(false) + , m_enmFormat(kFormat_Invalid) + , m_strFormatted() +{ + RTTimeSpecSetNano(&m_TimeSpec, 0); + RT_ZERO(m_Exploded); + + /* Since we need to know the format, all date-time values default to 'null'. */ + m_fNullIndicator = true; +} + + +RTCRestDate::RTCRestDate(RTCRestDate const &a_rThat) + : RTCRestObjectBase(a_rThat) + , m_fTimeSpecOkay(a_rThat.m_fTimeSpecOkay) + , m_enmFormat(a_rThat.m_enmFormat) + , m_strFormatted(a_rThat.m_strFormatted) +{ + m_TimeSpec = a_rThat.m_TimeSpec; + m_Exploded = a_rThat.m_Exploded; +} + + +RTCRestDate::~RTCRestDate() +{ + /* nothing to do */ +} + + +RTCRestDate &RTCRestDate::operator=(RTCRestDate const &a_rThat) +{ + RTCRestObjectBase::operator=(a_rThat); + m_TimeSpec = a_rThat.m_TimeSpec; + m_Exploded = a_rThat.m_Exploded; + m_fTimeSpecOkay = a_rThat.m_fTimeSpecOkay; + m_enmFormat = a_rThat.m_enmFormat; + m_strFormatted = a_rThat.m_strFormatted; + return *this; +} + + +int RTCRestDate::assignCopy(RTCRestDate const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_TimeSpec = a_rThat.m_TimeSpec; + m_Exploded = a_rThat.m_Exploded; + m_fTimeSpecOkay = a_rThat.m_fTimeSpecOkay; + m_enmFormat = a_rThat.m_enmFormat; + return m_strFormatted.assignNoThrow(a_rThat.m_strFormatted); +} + + +RTCRestObjectBase *RTCRestDate::baseClone() const RT_NOEXCEPT +{ + RTCRestDate *pClone = new (std::nothrow) RTCRestDate(); + if (pClone) + { + int rc = pClone->assignCopy(*this); + if (RT_SUCCESS(rc)) + return pClone; + delete pClone; + } + return NULL; +} + + +int RTCRestDate::resetToDefault() RT_NOEXCEPT +{ + m_fNullIndicator = true; + RTTimeSpecSetNano(&m_TimeSpec, 0); + RT_ZERO(m_Exploded); + m_fTimeSpecOkay = false; + m_strFormatted.setNull(); + /*m_enmFormat - leave as hint. */ + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestDate::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (m_fNullIndicator) + a_rDst.nullValue(); + else + a_rDst.printf("%RMjs", m_strFormatted.c_str()); + return a_rDst; +} + + +int RTCRestDate::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + setNull(); + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + if (enmType == RTJSONVALTYPE_STRING) + { + int rc = m_strFormatted.assignNoThrow(RTJsonValueGetString(a_rCursor.m_hValue)); + AssertRCReturn(rc, rc); + + m_fNullIndicator = false; + rc = decodeFormattedString(m_enmFormat); + if (RT_SUCCESS(rc)) + return rc; + if (m_enmFormat != kFormat_Invalid) + { + rc = decodeFormattedString(); + if (RT_SUCCESS(rc)) + return rc; + } + return a_rCursor.m_pPrimary->addError(a_rCursor, VWRN_REST_UNABLE_TO_DECODE_DATE, + "Unable to decode date value: %s", m_strFormatted.c_str()); + } + + if (enmType == RTJSONVALTYPE_NULL) + return VINF_SUCCESS; + + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_WRONG_JSON_TYPE_FOR_DATE, "wrong JSON type for date: %s", + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + + +int RTCRestDate::toString(RTCString *a_pDst, uint32_t a_fFlags /*= 0*/) const RT_NOEXCEPT +{ + if (m_fNullIndicator) + { + if (a_fFlags & kToString_Append) + return a_pDst->appendNoThrow(RT_STR_TUPLE("null")); + return a_pDst->assignNoThrow(RT_STR_TUPLE("null")); + } + if (a_fFlags & kToString_Append) + return a_pDst->appendNoThrow(m_strFormatted); + return a_pDst->assignNoThrow(m_strFormatted); +} + + +int RTCRestDate::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + setNull(); + if (a_rValue.startsWithWord("null", RTCString::CaseInsensitive)) + return VINF_SUCCESS; + + int rc = m_strFormatted.assignNoThrow(a_rValue); + AssertRCReturn(rc, rc); + + m_fNullIndicator = false; + rc = decodeFormattedString(m_enmFormat); + if (RT_SUCCESS(rc)) + return rc; + if (m_enmFormat != kFormat_Invalid) + { + rc = decodeFormattedString(); + if (RT_SUCCESS(rc)) + return rc; + } + RT_NOREF(a_fFlags); + return RTErrInfoSetF(a_pErrInfo, VERR_REST_UNABLE_TO_DECODE_DATE, + "Unable to decode date value (%s): %s", a_pszName, m_strFormatted.c_str()); +} + + +RTCRestObjectBase::kTypeClass RTCRestDate::typeClass(void) const RT_NOEXCEPT +{ + return kTypeClass_Date; +} + + +const char *RTCRestDate::typeName(void) const RT_NOEXCEPT +{ + return "RTCRestDate"; +} + + +int RTCRestDate::assignValue(PCRTTIMESPEC a_pTimeSpec, kFormat a_enmFormat) RT_NOEXCEPT +{ + AssertPtrReturn(a_pTimeSpec, VERR_INVALID_PARAMETER); + AssertReturn(a_enmFormat > kFormat_Invalid && a_enmFormat < kFormat_End, VERR_INVALID_PARAMETER); + + m_TimeSpec = *a_pTimeSpec; + return explodeAndFormat(a_enmFormat); +} + + +int RTCRestDate::assignValueRfc2822(PCRTTIMESPEC a_pTimeSpec) RT_NOEXCEPT +{ + AssertPtrReturn(a_pTimeSpec, VERR_INVALID_PARAMETER); + m_TimeSpec = *a_pTimeSpec; + return explodeAndFormat(kFormat_Rfc2822); +} + + +int RTCRestDate::assignValueRfc7131(PCRTTIMESPEC a_pTimeSpec) RT_NOEXCEPT +{ + AssertPtrReturn(a_pTimeSpec, VERR_INVALID_PARAMETER); + m_TimeSpec = *a_pTimeSpec; + return explodeAndFormat(kFormat_Rfc7131); +} + + +int RTCRestDate::assignValueRfc3339(PCRTTIMESPEC a_pTimeSpec) RT_NOEXCEPT +{ + AssertPtrReturn(a_pTimeSpec, VERR_INVALID_PARAMETER); + m_TimeSpec = *a_pTimeSpec; + return explodeAndFormat(kFormat_Rfc3339); +} + + +int RTCRestDate::assignNow(kFormat a_enmFormat) RT_NOEXCEPT +{ + RTTIMESPEC Now; + return assignValue(RTTimeNow(&Now), a_enmFormat); +} + + +int RTCRestDate::assignNowRfc2822() RT_NOEXCEPT +{ + RTTIMESPEC Now; + return assignValueRfc2822(RTTimeNow(&Now)); +} + + +int RTCRestDate::assignNowRfc7131() RT_NOEXCEPT +{ + RTTIMESPEC Now; + return assignValueRfc7131(RTTimeNow(&Now)); +} + + +int RTCRestDate::assignNowRfc3339() RT_NOEXCEPT +{ + RTTIMESPEC Now; + return assignValueRfc3339(RTTimeNow(&Now)); +} + + +int RTCRestDate::setFormat(kFormat a_enmFormat) RT_NOEXCEPT +{ + /* + * If this is a null object, just set the format as a hint for upcoming deserialization. + */ + if (m_fNullIndicator) + { + AssertReturn(a_enmFormat >= kFormat_Invalid && a_enmFormat < kFormat_End, VERR_INVALID_PARAMETER); + m_enmFormat = a_enmFormat; + return VINF_SUCCESS; + } + + /* + * If the tiem spec is okay, just reformat the string value accordingly. + */ + if (m_fTimeSpecOkay) + { + AssertReturn(a_enmFormat > kFormat_Invalid && a_enmFormat < kFormat_End, VERR_INVALID_PARAMETER); + if (a_enmFormat == m_enmFormat) + return VINF_SUCCESS; + return format(a_enmFormat); + } + + /* + * Try decode + */ + AssertReturn(a_enmFormat > kFormat_Invalid && a_enmFormat < kFormat_End, VERR_INVALID_PARAMETER); + return decodeFormattedString(a_enmFormat); +} + + +int RTCRestDate::explodeAndFormat(kFormat a_enmFormat) RT_NOEXCEPT +{ + RTTimeExplode(&m_Exploded, &m_TimeSpec); + return format(a_enmFormat); +} + + +/** + * Formats the m_Exploded value. + * + * Sets m_strFormatted, m_fTimeSpecOkay, and m_enmFormat, clears m_fNullIndicator. + * + * @returns VINF_SUCCESS or VERR_NO_STR_MEMORY. + * @param a_enmFormat The format to use. + */ +int RTCRestDate::format(kFormat a_enmFormat) RT_NOEXCEPT +{ + m_fNullIndicator = false; + m_fTimeSpecOkay = true; + m_enmFormat = a_enmFormat; + int rc; + switch (a_enmFormat) + { + case kFormat_Rfc2822: + case kFormat_Rfc7131: + rc = m_strFormatted.reserveNoThrow(RTTIME_RFC2822_LEN); + AssertRCReturn(rc, rc); + RTTimeToRfc2822(&m_Exploded, m_strFormatted.mutableRaw(), m_strFormatted.capacity(), + a_enmFormat == kFormat_Rfc7131 ? RTTIME_RFC2822_F_GMT : 0); + m_strFormatted.jolt(); + return VINF_SUCCESS; + + case kFormat_Rfc3339: + case kFormat_Rfc3339_Fraction_2: + case kFormat_Rfc3339_Fraction_3: + case kFormat_Rfc3339_Fraction_6: + case kFormat_Rfc3339_Fraction_9: + rc = m_strFormatted.reserveNoThrow(RTTIME_STR_LEN); + AssertRCReturn(rc, rc); + RTTimeToStringEx(&m_Exploded, m_strFormatted.mutableRaw(), m_strFormatted.capacity(), + a_enmFormat == kFormat_Rfc3339 ? 0 + : a_enmFormat == kFormat_Rfc3339_Fraction_2 ? 2 + : a_enmFormat == kFormat_Rfc3339_Fraction_3 ? 3 + : a_enmFormat == kFormat_Rfc3339_Fraction_6 ? 6 : 9); + m_strFormatted.jolt(); + return VINF_SUCCESS; + + /* no default */ + case kFormat_Invalid: + case kFormat_End: + break; + } + AssertFailedReturn(VERR_REST_INTERNAL_ERROR_7); +} + + +/** + * Internal worker that attempts to decode m_strFormatted. + * + * Sets m_fTimeSpecOkay. + * + * @returns IPRT status code. + * @param enmFormat Specific format to try, kFormat_Invalid (default) to try guess it. + */ +int RTCRestDate::decodeFormattedString(kFormat enmFormat /*= kFormat_Invalid*/) RT_NOEXCEPT +{ + /* + * Take empty string to mean null. + */ + const char *pszTmp = RTStrStripL(m_strFormatted.c_str()); + if (*pszTmp == '\0') + { + setNull(); + return VINF_SUCCESS; + } + + switch (enmFormat) + { + case kFormat_Invalid: + { + size_t cch = strlen(pszTmp); + if (cch >= 6) + { + if ( !RT_C_IS_DIGIT(pszTmp[0]) + || RT_C_IS_SPACE(pszTmp[5]) + || RT_C_IS_SPACE(pszTmp[2]) + || RT_C_IS_SPACE(pszTmp[1]) + || RT_C_IS_SPACE(pszTmp[3]) + || RT_C_IS_SPACE(pszTmp[4])) + return decodeFormattedString(kFormat_Rfc2822); + return decodeFormattedString(kFormat_Rfc3339); + } + return VERR_REST_UNABLE_TO_DECODE_DATE; + } + + /* + * Examples: + * Fri, 31 Aug 2018 00:00:00 +0200 + * Mon, 3 Sep 2018 00:00:00 GMT + * Mon, 3 Sep 2018 00:00:00 -0000 + * 3 Sep 2018 00:00:00 -0000 (?) + * 3 Sep 2018 00:00:00 GMT (?) + */ + case kFormat_Rfc2822: + case kFormat_Rfc7131: + if (RTTimeFromRfc2822(&m_Exploded, pszTmp)) + { + RTTimeImplode(&m_TimeSpec, &m_Exploded); + + pszTmp = strchr(pszTmp, '\0'); + if (pszTmp[-1] == 'T' || pszTmp[-1] == 't') + m_enmFormat = kFormat_Rfc7131; + else + m_enmFormat = kFormat_Rfc2822; + m_fTimeSpecOkay = true; + return VINF_SUCCESS; + } + return VERR_REST_UNABLE_TO_DECODE_DATE; + + /* + * Examples: + * 2018-08-31T00:00:00+0200 + * 2018-09-03T00:00:00Z + * 2018-09-03T00:00:00+0000 + * 2018-09-03T00:00:00.123456789Z + */ + case kFormat_Rfc3339: + case kFormat_Rfc3339_Fraction_2: + case kFormat_Rfc3339_Fraction_3: + case kFormat_Rfc3339_Fraction_6: + case kFormat_Rfc3339_Fraction_9: + if (RTTimeFromString(&m_Exploded, pszTmp)) + { + RTTimeImplode(&m_TimeSpec, &m_Exploded); + + pszTmp = strchr(pszTmp, '.'); + if (!pszTmp) + m_enmFormat = kFormat_Rfc3339; + else + { + size_t cchFraction = 0; + pszTmp++; + while (RT_C_IS_DIGIT(pszTmp[cchFraction])) + cchFraction++; + if (cchFraction == 0) + m_enmFormat = kFormat_Rfc3339; + else if (cchFraction <= 2) + m_enmFormat = kFormat_Rfc3339_Fraction_2; + else if (cchFraction <= 3) + m_enmFormat = kFormat_Rfc3339_Fraction_3; + else if (cchFraction <= 6) + m_enmFormat = kFormat_Rfc3339_Fraction_6; + else + m_enmFormat = kFormat_Rfc3339_Fraction_9; + } + m_fTimeSpecOkay = true; + return VINF_SUCCESS; + } + return VERR_REST_UNABLE_TO_DECODE_DATE; + + /* no default */ + case kFormat_End: + break; + } + AssertFailedReturn(VERR_INVALID_PARAMETER); +} + + +/********************************************************************************************************************************* +* RTCRestStringEnumBase implementation * +*********************************************************************************************************************************/ + +/** Default constructor. */ +RTCRestStringEnumBase::RTCRestStringEnumBase() RT_NOEXCEPT + : RTCRestObjectBase() + , m_iEnumValue(0 /*invalid*/) + , m_strValue() +{ +} + + +/** Destructor. */ +RTCRestStringEnumBase::~RTCRestStringEnumBase() +{ + /* nothing to do */ +} + + +/** Copy constructor. */ +RTCRestStringEnumBase::RTCRestStringEnumBase(RTCRestStringEnumBase const &a_rThat) + : RTCRestObjectBase(a_rThat) + , m_iEnumValue(a_rThat.m_iEnumValue) + , m_strValue(a_rThat.m_strValue) +{ +} + + +/** Copy assignment operator. */ +RTCRestStringEnumBase &RTCRestStringEnumBase::operator=(RTCRestStringEnumBase const &a_rThat) +{ + RTCRestObjectBase::operator=(a_rThat); + m_iEnumValue = a_rThat.m_iEnumValue; + m_strValue = a_rThat.m_strValue; + return *this; +} + + +int RTCRestStringEnumBase::assignCopy(RTCRestStringEnumBase const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_iEnumValue = a_rThat.m_iEnumValue; + return m_strValue.assignNoThrow(a_rThat.m_strValue); +} + + +int RTCRestStringEnumBase::resetToDefault() RT_NOEXCEPT +{ + m_iEnumValue = 0; /*invalid*/ + m_strValue.setNull(); + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestStringEnumBase::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + a_rDst.printf("%RMjs", getString()); + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestStringEnumBase::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + m_fNullIndicator = false; + m_iEnumValue = 0; + + RTJSONVALTYPE enmType = RTJsonValueGetType(a_rCursor.m_hValue); + if (enmType == RTJSONVALTYPE_STRING) + { + const char *pszValue = RTJsonValueGetString(a_rCursor.m_hValue); + const size_t cchValue = strlen(pszValue); + int rc = setByString(pszValue, cchValue); + if (RT_SUCCESS(rc)) + return rc; + return a_rCursor.m_pPrimary->addError(a_rCursor, rc, "no memory for %zu char long string", cchValue); + } + + m_strValue.setNull(); + if (enmType == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + return VINF_SUCCESS; + } + + return a_rCursor.m_pPrimary->addError(a_rCursor, VERR_REST_WRONG_JSON_TYPE_FOR_STRING, "wrong JSON type %s for string/enum", + RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); +} + + +int RTCRestStringEnumBase::toString(RTCString *a_pDst, uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + { + if (m_iEnumValue > 0) + { + size_t cEntries = 0; + ENUMMAPENTRY const *paEntries = getMappingTable(&cEntries); + AssertReturn((unsigned)(m_iEnumValue - 1) < cEntries, VERR_REST_INTERNAL_ERROR_3); + Assert(paEntries[m_iEnumValue - 1].iValue == m_iEnumValue); + + if (a_fFlags & kToString_Append) + return a_pDst->appendNoThrow(paEntries[m_iEnumValue - 1].pszName, paEntries[m_iEnumValue - 1].cchName); + return a_pDst->assignNoThrow(paEntries[m_iEnumValue - 1].pszName, paEntries[m_iEnumValue - 1].cchName); + } + if (a_fFlags & kToString_Append) + return a_pDst->appendNoThrow(m_strValue); + return a_pDst->assignNoThrow(m_strValue); + } + if (a_fFlags & kToString_Append) + return a_pDst->appendNoThrow(RT_STR_TUPLE("null")); + return a_pDst->assignNoThrow(RT_STR_TUPLE("null")); +} + + +int RTCRestStringEnumBase::fromString(RTCString const &a_rValue, const char *a_pszName, PRTERRINFO a_pErrInfo /*= NULL*/, + uint32_t a_fFlags /*= kCollectionFormat_Unspecified*/) RT_NOEXCEPT +{ + int iEnumValue = stringToEnum(a_rValue); + if (iEnumValue > 0) + { + m_iEnumValue = iEnumValue; + m_strValue.setNull(); + return VINF_SUCCESS; + } + + /* No translation. Check for null... */ + m_iEnumValue = 0; + if (a_rValue.startsWithWord("null", RTCString::CaseInsensitive)) + { + m_strValue.setNull(); + setNull(); + return VINF_SUCCESS; + } + + /* Try copy the string. */ + int rc = m_strValue.assignNoThrow(a_rValue); + if (RT_SUCCESS(rc)) + return VWRN_NOT_FOUND; + + RT_NOREF(a_pszName, a_pErrInfo, a_fFlags); + return rc; +} + + +RTCRestObjectBase::kTypeClass RTCRestStringEnumBase::typeClass(void) const RT_NOEXCEPT +{ + return kTypeClass_StringEnum; +} + + +int RTCRestStringEnumBase::setByString(const char *a_pszValue, size_t a_cchValue /*= RTSTR_MAX*/) RT_NOEXCEPT +{ + if (a_cchValue == RTSTR_MAX) + a_cchValue = strlen(a_pszValue); + int iEnumValue = stringToEnum(a_pszValue, a_cchValue); + if (iEnumValue > 0) + { + m_iEnumValue = iEnumValue; + m_strValue.setNull(); + return VINF_SUCCESS; + } + + /* No translation. */ + m_iEnumValue = 0; + int rc = m_strValue.assignNoThrow(a_pszValue, a_cchValue); + if (RT_SUCCESS(rc)) + return VWRN_NOT_FOUND; + return rc; +} + + +int RTCRestStringEnumBase::setByString(RTCString const &a_rValue) RT_NOEXCEPT +{ + return setByString(a_rValue.c_str(), a_rValue.length()); +} + + +const char *RTCRestStringEnumBase::getString() const RT_NOEXCEPT +{ + /* We ASSUME a certain mapping table layout here. */ + if (m_iEnumValue > 0) + { + size_t cEntries = 0; + ENUMMAPENTRY const *paEntries = getMappingTable(&cEntries); + AssertReturn((unsigned)(m_iEnumValue - 1) < cEntries, "<internal-error-#1>"); + Assert(paEntries[m_iEnumValue - 1].iValue == m_iEnumValue); + return paEntries[m_iEnumValue - 1].pszName; + } + + AssertReturn(m_iEnumValue == 0, "<internal-error-#2>"); + if (m_strValue.isEmpty()) + return "invalid"; + + return m_strValue.c_str(); +} + + +int RTCRestStringEnumBase::stringToEnum(const char *a_pszValue, size_t a_cchValue) RT_NOEXCEPT +{ + if (a_cchValue == RTSTR_MAX) + a_cchValue = strlen(a_pszValue); + + size_t cEntries = 0; + ENUMMAPENTRY const *paEntries = getMappingTable(&cEntries); + for (size_t i = 0; i < cEntries; i++) + if ( paEntries[i].cchName == a_cchValue + && memcmp(paEntries[i].pszName, a_pszValue, a_cchValue) == 0) + return paEntries[i].iValue; + return 0; +} + + +int RTCRestStringEnumBase::stringToEnum(RTCString const &a_rStrValue) RT_NOEXCEPT +{ + return stringToEnum(a_rStrValue.c_str(), a_rStrValue.length()); +} + + +const char *RTCRestStringEnumBase::enumToString(int a_iEnumValue, size_t *a_pcchString) RT_NOEXCEPT +{ + /* We ASSUME a certain mapping table layout here. */ + if (a_iEnumValue > 0) + { + size_t cEntries = 0; + ENUMMAPENTRY const *paEntries = getMappingTable(&cEntries); + if ((unsigned)(a_iEnumValue - 1) < cEntries) + { + Assert(paEntries[a_iEnumValue - 1].iValue == a_iEnumValue); + if (a_pcchString) + *a_pcchString = paEntries[a_iEnumValue - 1].cchName; + return paEntries[a_iEnumValue - 1].pszName; + } + } + /* Zero is the special invalid value. */ + else if (a_iEnumValue == 0) + { + if (a_pcchString) + *a_pcchString = 7; + return "invalid"; + } + return NULL; +} + + +bool RTCRestStringEnumBase::setWorker(int a_iEnumValue) RT_NOEXCEPT +{ + /* We ASSUME a certain mapping table layout here. */ + if (a_iEnumValue > 0) + { + size_t cEntries = 0; + ENUMMAPENTRY const *paEntries = getMappingTable(&cEntries); + AssertReturn((unsigned)(a_iEnumValue - 1) < cEntries, false); + Assert(paEntries[a_iEnumValue - 1].iValue == a_iEnumValue); + RT_NOREF(paEntries); + } + /* Zero is the special invalid value. */ + else if (a_iEnumValue != 0) + AssertFailedReturn(false); + + m_iEnumValue = a_iEnumValue; + m_strValue.setNull(); + return true; +} + + +RTCRestObjectBase *RTCRestStringEnumBase::cloneWorker(RTCRestStringEnumBase *a_pDst) const RT_NOEXCEPT +{ + if (a_pDst) + { + int rc = a_pDst->assignCopy(*this); + if (RT_SUCCESS(rc)) + return a_pDst; + delete a_pDst; + } + return NULL; +} + + + +/********************************************************************************************************************************* +* RTCRestDataObject * +*********************************************************************************************************************************/ + +RTCRestDataObject::RTCRestDataObject() RT_NOEXCEPT + : RTCRestObjectBase() + , m_fIsSet(0) +{ +} + + +RTCRestDataObject::~RTCRestDataObject() +{ +} + + +RTCRestDataObject::RTCRestDataObject(RTCRestDataObject const &a_rThat) RT_NOEXCEPT + : RTCRestObjectBase(a_rThat) + , m_fIsSet(a_rThat.m_fIsSet) +{ +} + + +RTCRestDataObject &RTCRestDataObject::operator=(RTCRestDataObject const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_fIsSet = a_rThat.m_fIsSet; + return *this; +} + + +int RTCRestDataObject::assignCopy(RTCRestDataObject const &a_rThat) RT_NOEXCEPT +{ + m_fNullIndicator = a_rThat.m_fNullIndicator; + m_fIsSet = a_rThat.m_fIsSet; + return VINF_SUCCESS; +} + + +int RTCRestDataObject::resetToDefault() RT_NOEXCEPT +{ + m_fNullIndicator = false; + m_fIsSet = 0; + return VINF_SUCCESS; +} + + +RTCRestOutputBase &RTCRestDataObject::serializeMembersAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + RT_NOREF(a_rDst); + return a_rDst; +} + + +RTCRestOutputBase &RTCRestDataObject::serializeAsJson(RTCRestOutputBase &a_rDst) const RT_NOEXCEPT +{ + if (!m_fNullIndicator) + { + uint32_t const uOldState = a_rDst.beginObject(); + serializeMembersAsJson(a_rDst); + a_rDst.endObject(uOldState); + } + else + a_rDst.nullValue(); + return a_rDst; +} + + +int RTCRestDataObject::deserializeMemberFromJson(RTCRestJsonCursor const &a_rCursor, size_t a_cchName) RT_NOEXCEPT +{ + RT_NOREF(a_rCursor, a_cchName); + return VERR_NOT_FOUND; +} + + +int RTCRestDataObject::deserializeFromJson(RTCRestJsonCursor const &a_rCursor) RT_NOEXCEPT +{ + /* + * Make sure the object starts out with default values. + */ + if (m_fIsSet == 0) + m_fNullIndicator = false; + else + resetToDefault(); + + /* + * Iterate the object values. + */ + RTJSONIT hIterator; + int rcRet = RTJsonIteratorBeginObject(a_rCursor.m_hValue, &hIterator); + if (RT_SUCCESS(rcRet)) + { + for (;;) + { + RTCRestJsonCursor SubCursor(a_rCursor); + int rc = RTJsonIteratorQueryValue(hIterator, &SubCursor.m_hValue, &SubCursor.m_pszName); + if (RT_SUCCESS(rc)) + { + size_t const cchName = strlen(SubCursor.m_pszName); + + rc = deserializeMemberFromJson(SubCursor, cchName); + if (rc == VINF_SUCCESS) + { /* likely */ } + else if (rc == VERR_NOT_FOUND) + { + rc = SubCursor.m_pPrimary->unknownField(SubCursor); + if (rcRet == VINF_SUCCESS) + rcRet = rc; + } + else if (RT_SUCCESS(rc)) + { + if (rcRet == VINF_SUCCESS) + rcRet = rc; + } + else if (RT_SUCCESS(rcRet)) + rcRet = rc; + } + else + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonIteratorQueryValue failed: %Rrc", rc); + + /* + * Advance. + */ + rc = RTJsonIteratorNext(hIterator); + if (RT_SUCCESS(rc)) + { /* likely */ } + else if (rc == VERR_JSON_ITERATOR_END) + break; + else + { + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rc, "RTJsonIteratorNext failed: %Rrc", rc); + break; + } + } + + RTJsonIteratorFree(hIterator); + } + else if ( rcRet == VERR_JSON_VALUE_INVALID_TYPE + && RTJsonValueGetType(a_rCursor.m_hValue) == RTJSONVALTYPE_NULL) + { + m_fNullIndicator = true; + rcRet = VINF_SUCCESS; + } + else + rcRet = a_rCursor.m_pPrimary->addError(a_rCursor, rcRet, "RTJsonIteratorBeginObject failed: %Rrc (type %s)", + rcRet, RTJsonValueTypeName(RTJsonValueGetType(a_rCursor.m_hValue))); + return rcRet; +} + + +RTCRestObjectBase::kTypeClass RTCRestDataObject::typeClass(void) const RT_NOEXCEPT +{ + return kTypeClass_DataObject; +} + + + +/********************************************************************************************************************************* +* RTCRestPolyDataObject * +*********************************************************************************************************************************/ + +RTCRestPolyDataObject::RTCRestPolyDataObject() RT_NOEXCEPT + : RTCRestDataObject() +{ +} + + +RTCRestPolyDataObject::RTCRestPolyDataObject(RTCRestPolyDataObject const &a_rThat) RT_NOEXCEPT + : RTCRestDataObject(a_rThat) +{ +} + + +RTCRestPolyDataObject::~RTCRestPolyDataObject() +{ +} + + +int RTCRestPolyDataObject::resetToDefault() RT_NOEXCEPT +{ + return RTCRestDataObject::resetToDefault(); +} + + +bool RTCRestPolyDataObject::isChild() const RT_NOEXCEPT +{ + return false; +} + + +RTCRestPolyDataObject &RTCRestPolyDataObject::operator=(RTCRestPolyDataObject const &a_rThat) RT_NOEXCEPT +{ + RTCRestDataObject::operator=(a_rThat); + return *this; +} + |