Add boost and cpprestsdk

vendor/cpprestsdk/include/cpprest/details/basic_types.h

@@ -0,0 +1,131 @@
+/***
+ * Copyright (C) Microsoft. All rights reserved.
+ * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+ *
+ * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ *
+ * Platform-dependent type definitions
+ *
+ * For the latest on this and related APIs, please see: https://github.com/Microsoft/cpprestsdk
+ *
+ * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+ ****/
+
+#pragma once
+
+#include "cpprest/details/cpprest_compat.h"
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#ifndef _WIN32
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS
+#endif
+#include <stdint.h>
+#else
+#include <cstdint>
+#endif
+
+#include "cpprest/details/SafeInt3.hpp"
+
+namespace utility
+{
+#ifdef _WIN32
+#define _UTF16_STRINGS
+#endif
+
+// We should be using a 64-bit size type for most situations that do
+// not involve specifying the size of a memory allocation or buffer.
+typedef uint64_t size64_t;
+
+#ifndef _WIN32
+typedef uint32_t HRESULT; // Needed for PPLX
+#endif
+
+#ifdef _UTF16_STRINGS
+//
+// On Windows, all strings are wide
+//
+typedef wchar_t char_t;
+typedef std::wstring string_t;
+#define _XPLATSTR(x) L##x
+typedef std::wostringstream ostringstream_t;
+typedef std::wofstream ofstream_t;
+typedef std::wostream ostream_t;
+typedef std::wistream istream_t;
+typedef std::wifstream ifstream_t;
+typedef std::wistringstream istringstream_t;
+typedef std::wstringstream stringstream_t;
+#define ucout std::wcout
+#define ucin std::wcin
+#define ucerr std::wcerr
+#else
+//
+// On POSIX platforms, all strings are narrow
+//
+typedef char char_t;
+typedef std::string string_t;
+#define _XPLATSTR(x) x
+typedef std::ostringstream ostringstream_t;
+typedef std::ofstream ofstream_t;
+typedef std::ostream ostream_t;
+typedef std::istream istream_t;
+typedef std::ifstream ifstream_t;
+typedef std::istringstream istringstream_t;
+typedef std::stringstream stringstream_t;
+#define ucout std::cout
+#define ucin std::cin
+#define ucerr std::cerr
+#endif // endif _UTF16_STRINGS
+
+#ifndef _TURN_OFF_PLATFORM_STRING
+// The 'U' macro can be used to create a string or character literal of the platform type, i.e. utility::char_t.
+// If you are using a library causing conflicts with 'U' macro, it can be turned off by defining the macro
+// '_TURN_OFF_PLATFORM_STRING' before including the C++ REST SDK header files, and e.g. use '_XPLATSTR' instead.
+#define U(x) _XPLATSTR(x)
+#endif // !_TURN_OFF_PLATFORM_STRING
+
+} // namespace utility
+
+typedef char utf8char;
+typedef std::string utf8string;
+typedef std::stringstream utf8stringstream;
+typedef std::ostringstream utf8ostringstream;
+typedef std::ostream utf8ostream;
+typedef std::istream utf8istream;
+typedef std::istringstream utf8istringstream;
+
+#ifdef _UTF16_STRINGS
+typedef wchar_t utf16char;
+typedef std::wstring utf16string;
+typedef std::wstringstream utf16stringstream;
+typedef std::wostringstream utf16ostringstream;
+typedef std::wostream utf16ostream;
+typedef std::wistream utf16istream;
+typedef std::wistringstream utf16istringstream;
+#else
+typedef char16_t utf16char;
+typedef std::u16string utf16string;
+typedef std::basic_stringstream<utf16char> utf16stringstream;
+typedef std::basic_ostringstream<utf16char> utf16ostringstream;
+typedef std::basic_ostream<utf16char> utf16ostream;
+typedef std::basic_istream<utf16char> utf16istream;
+typedef std::basic_istringstream<utf16char> utf16istringstream;
+#endif
+
+#if defined(_WIN32)
+// Include on everything except Windows Desktop ARM, unless explicitly excluded.
+#if !defined(CPPREST_EXCLUDE_WEBSOCKETS)
+#if defined(WINAPI_FAMILY)
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && defined(_M_ARM)
+#define CPPREST_EXCLUDE_WEBSOCKETS
+#endif
+#else
+#if defined(_M_ARM)
+#define CPPREST_EXCLUDE_WEBSOCKETS
+#endif
+#endif
+#endif
+#endif

vendor/cpprestsdk/include/cpprest/details/cpprest_compat.h

@@ -0,0 +1,101 @@
+/***
+ * Copyright (C) Microsoft. All rights reserved.
+ * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+ *
+ * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ *
+ * Standard macros and definitions.
+ * This header has minimal dependency on windows headers and is safe for use in the public API
+ *
+ * For the latest on this and related APIs, please see: https://github.com/Microsoft/cpprestsdk
+ *
+ * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+ ****/
+
+#pragma once
+
+#if defined(_WIN32)
+
+#if _MSC_VER >= 1900
+#define CPPREST_NOEXCEPT noexcept
+#define CPPREST_CONSTEXPR constexpr
+#else
+#define CPPREST_NOEXCEPT
+#define CPPREST_CONSTEXPR const
+#endif // _MSC_VER >= 1900
+
+#include <sal.h>
+
+#else // ^^^ _WIN32 ^^^ // vvv !_WIN32 vvv
+
+#define __declspec(x) __attribute__((x))
+#define novtable /* no novtable equivalent */
+#define __assume(x)                                                                                                    \
+    do                                                                                                                 \
+    {                                                                                                                  \
+        if (!(x)) __builtin_unreachable();                                                                             \
+    } while (false)
+#define CPPREST_NOEXCEPT noexcept
+#define CPPREST_CONSTEXPR constexpr
+
+#include <assert.h>
+#define _ASSERTE(x) assert(x)
+
+// No SAL on non Windows platforms
+#include "cpprest/details/nosal.h"
+
+#if !defined(__cdecl)
+#if defined(cdecl)
+#define __cdecl __attribute__((cdecl))
+#else // ^^^ defined cdecl ^^^ // vvv !defined cdecl vvv
+#define __cdecl
+#endif // defined cdecl
+#endif // not defined __cdecl
+
+#if defined(__ANDROID__)
+// This is needed to disable the use of __thread inside the boost library.
+// Android does not support thread local storage -- if boost is included
+// without this macro defined, it will create references to __tls_get_addr
+// which (while able to link) will not be available at runtime and prevent
+// the .so from loading.
+#if not defined BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION
+#define BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION
+#endif // not defined BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION
+#endif // defined(__ANDROID__)
+
+#ifdef __clang__
+#include <cstdio>
+#endif // __clang__
+#endif // _WIN32
+
+#ifdef _NO_ASYNCRTIMP
+#define _ASYNCRTIMP
+#define _ASYNCRTIMP_TYPEINFO
+#else // ^^^ _NO_ASYNCRTIMP ^^^ // vvv !_NO_ASYNCRTIMP vvv
+#ifdef _ASYNCRT_EXPORT
+#ifdef _WIN32
+#define _ASYNCRTIMP __declspec(dllexport)
+#else
+#define _ASYNCRTIMP __attribute__((visibility("default")))
+#endif
+#else // ^^^ _ASYNCRT_EXPORT ^^^ // vvv !_ASYNCRT_EXPORT vvv
+#ifdef _WIN32
+#define _ASYNCRTIMP __declspec(dllimport)
+#else
+#define _ASYNCRTIMP
+#endif
+#endif // _ASYNCRT_EXPORT
+
+#if defined(_WIN32)
+#define _ASYNCRTIMP_TYPEINFO
+#else // ^^^ _WIN32 ^^^ // vvv !_WIN32 vvv
+#define _ASYNCRTIMP_TYPEINFO __attribute__((visibility("default")))
+#endif // _WIN32
+
+#endif // _NO_ASYNCRTIMP
+
+#ifdef CASABLANCA_DEPRECATION_NO_WARNINGS
+#define CASABLANCA_DEPRECATED(x)
+#else
+#define CASABLANCA_DEPRECATED(x) __declspec(deprecated(x))
+#endif // CASABLANCA_DEPRECATION_NO_WARNINGS

vendor/cpprestsdk/include/cpprest/details/fileio.h

@@ -0,0 +1,220 @@
+/***
+ * Copyright (C) Microsoft. All rights reserved.
+ * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+ *
+ * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ *
+ * fileio.h
+ *
+ * Asynchronous I/O: stream buffer implementation details
+ *
+ * We're going to some lengths to avoid exporting C++ class member functions and implementation details across
+ * module boundaries, and the factoring requires that we keep the implementation details away from the main header
+ * files. The supporting functions, which are in this file, use C-like signatures to avoid as many issues as
+ * possible.
+ *
+ * For the latest on this and related APIs, please see: https://github.com/Microsoft/cpprestsdk
+ *
+ * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+ ****/
+#pragma once
+
+#ifdef _WIN32
+#include <cstdint>
+#endif
+
+#include "cpprest/details/basic_types.h"
+#include "pplx/pplxtasks.h"
+
+namespace Concurrency
+{
+namespace streams
+{
+namespace details
+{
+/// <summary>
+/// A record containing the essential private data members of a file stream,
+/// in particular the parts that need to be shared between the public header
+/// file and the implementation in the implementation file.
+/// </summary>
+struct _file_info
+{
+    _ASYNCRTIMP _file_info(std::ios_base::openmode mode, size_t buffer_size)
+        : m_rdpos(0)
+        , m_wrpos(0)
+        , m_atend(false)
+        , m_buffer_size(buffer_size)
+        , m_buffer(nullptr)
+        , m_bufoff(0)
+        , m_bufsize(0)
+        , m_buffill(0)
+        , m_mode(mode)
+    {
+    }
+
+    // Positional data
+
+    size_t m_rdpos;
+    size_t m_wrpos;
+    bool m_atend;
+
+    // Input buffer
+
+    size_t m_buffer_size; // The intended size of the buffer to read into.
+    char* m_buffer;
+
+    size_t m_bufoff;                          // File position that the start of the buffer represents.
+    msl::safeint3::SafeInt<size_t> m_bufsize; // Buffer allocated size, as actually allocated.
+    size_t m_buffill;                         // Amount of file data actually in the buffer
+
+    std::ios_base::openmode m_mode;
+
+    pplx::extensibility::recursive_lock_t m_lock;
+};
+
+/// <summary>
+/// This interface provides the necessary callbacks for completion events.
+/// </summary>
+class _filestream_callback
+{
+public:
+    virtual void on_opened(_In_ details::_file_info*) {}
+    virtual void on_closed() {}
+    virtual void on_error(const std::exception_ptr&) {}
+    virtual void on_completed(size_t) {}
+
+protected:
+    virtual ~_filestream_callback() {}
+};
+
+} // namespace details
+} // namespace streams
+} // namespace Concurrency
+
+extern "C"
+{
+/// <summary>
+/// Open a file and create a streambuf instance to represent it.
+/// </summary>
+/// <param name="callback">A pointer to the callback interface to invoke when the file has been opened.</param>
+/// <param name="filename">The name of the file to open</param>
+/// <param name="mode">A creation mode for the stream buffer</param>
+/// <param name="prot">A file protection mode to use for the file stream (not supported on Linux)</param>
+/// <returns><c>true</c> if the opening operation could be initiated, <c>false</c> otherwise.</returns>
+/// <remarks>
+/// True does not signal that the file will eventually be successfully opened, just that the process was started.
+/// </remarks>
+#if !defined(__cplusplus_winrt)
+    _ASYNCRTIMP bool __cdecl _open_fsb_str(_In_ concurrency::streams::details::_filestream_callback* callback,
+                                           const utility::char_t* filename,
+                                           std::ios_base::openmode mode,
+                                           int prot);
+#endif
+
+/// <summary>
+/// Create a streambuf instance to represent a WinRT file.
+/// </summary>
+/// <param name="callback">A pointer to the callback interface to invoke when the file has been opened.</param>
+/// <param name="file">The file object</param>
+/// <param name="mode">A creation mode for the stream buffer</param>
+/// <returns><c>true</c> if the opening operation could be initiated, <c>false</c> otherwise.</returns>
+/// <remarks>
+/// True does not signal that the file will eventually be successfully opened, just that the process was started.
+/// This is only available for WinRT.
+/// </remarks>
+#if defined(__cplusplus_winrt)
+    _ASYNCRTIMP bool __cdecl _open_fsb_stf_str(_In_ concurrency::streams::details::_filestream_callback* callback,
+                                               ::Windows::Storage::StorageFile ^ file,
+                                               std::ios_base::openmode mode,
+                                               int prot);
+#endif
+
+    /// <summary>
+    /// Close a file stream buffer.
+    /// </summary>
+    /// <param name="info">The file info record of the file</param>
+    /// <param name="callback">A pointer to the callback interface to invoke when the file has been opened.</param>
+    /// <returns><c>true</c> if the closing operation could be initiated, <c>false</c> otherwise.</returns>
+    /// <remarks>
+    /// True does not signal that the file will eventually be successfully closed, just that the process was started.
+    /// </remarks>
+    _ASYNCRTIMP bool __cdecl _close_fsb_nolock(_In_ concurrency::streams::details::_file_info** info,
+                                               _In_ concurrency::streams::details::_filestream_callback* callback);
+    _ASYNCRTIMP bool __cdecl _close_fsb(_In_ concurrency::streams::details::_file_info** info,
+                                        _In_ concurrency::streams::details::_filestream_callback* callback);
+
+    /// <summary>
+    /// Write data from a buffer into the file stream.
+    /// </summary>
+    /// <param name="info">The file info record of the file</param>
+    /// <param name="callback">A pointer to the callback interface to invoke when the write request is
+    /// completed.</param> <param name="ptr">A pointer to a buffer where the data should be placed</param> <param
+    /// name="count">The size (in characters) of the buffer</param> <returns>0 if the read request is still outstanding,
+    /// -1 if the request failed, otherwise the size of the data read into the buffer</returns>
+    _ASYNCRTIMP size_t __cdecl _putn_fsb(_In_ concurrency::streams::details::_file_info* info,
+                                         _In_ concurrency::streams::details::_filestream_callback* callback,
+                                         const void* ptr,
+                                         size_t count,
+                                         size_t char_size);
+
+    /// <summary>
+    /// Read data from a file stream into a buffer
+    /// </summary>
+    /// <param name="info">The file info record of the file</param>
+    /// <param name="callback">A pointer to the callback interface to invoke when the write request is
+    /// completed.</param> <param name="ptr">A pointer to a buffer where the data should be placed</param> <param
+    /// name="count">The size (in characters) of the buffer</param> <returns>0 if the read request is still outstanding,
+    /// -1 if the request failed, otherwise the size of the data read into the buffer</returns>
+    _ASYNCRTIMP size_t __cdecl _getn_fsb(_In_ concurrency::streams::details::_file_info* info,
+                                         _In_ concurrency::streams::details::_filestream_callback* callback,
+                                         _Out_writes_(count) void* ptr,
+                                         _In_ size_t count,
+                                         size_t char_size);
+
+    /// <summary>
+    /// Flush all buffered data to the underlying file.
+    /// </summary>
+    /// <param name="info">The file info record of the file</param>
+    /// <param name="callback">A pointer to the callback interface to invoke when the write request is
+    /// completed.</param> <returns><c>true</c> if the request was initiated</returns>
+    _ASYNCRTIMP bool __cdecl _sync_fsb(_In_ concurrency::streams::details::_file_info* info,
+                                       _In_ concurrency::streams::details::_filestream_callback* callback);
+
+    /// <summary>
+    /// Get the size of the underlying file.
+    /// </summary>
+    /// <param name="info">The file info record of the file</param>
+    /// <returns>The file size</returns>
+    _ASYNCRTIMP utility::size64_t __cdecl _get_size(_In_ concurrency::streams::details::_file_info* info,
+                                                    size_t char_size);
+
+    /// <summary>
+    /// Adjust the internal buffers and pointers when the application seeks to a new read location in the stream.
+    /// </summary>
+    /// <param name="info">The file info record of the file</param>
+    /// <param name="pos">The new position (offset from the start) in the file stream</param>
+    /// <returns><c>true</c> if the request was initiated</returns>
+    _ASYNCRTIMP size_t __cdecl _seekrdpos_fsb(_In_ concurrency::streams::details::_file_info* info,
+                                              size_t pos,
+                                              size_t char_size);
+
+    /// <summary>
+    /// Adjust the internal buffers and pointers when the application seeks to a new read location in the stream.
+    /// </summary>
+    /// <param name="info">The file info record of the file</param>
+    /// <param name="pos">The new position (offset from the start) in the file stream</param>
+    /// <returns><c>true</c> if the request was initiated</returns>
+    _ASYNCRTIMP size_t __cdecl _seekrdtoend_fsb(_In_ concurrency::streams::details::_file_info* info,
+                                                int64_t offset,
+                                                size_t char_size);
+
+    /// <summary>
+    /// Adjust the internal buffers and pointers when the application seeks to a new write location in the stream.
+    /// </summary>
+    /// <param name="info">The file info record of the file</param>
+    /// <param name="pos">The new position (offset from the start) in the file stream</param>
+    /// <returns><c>true</c> if the request was initiated</returns>
+    _ASYNCRTIMP size_t __cdecl _seekwrpos_fsb(_In_ concurrency::streams::details::_file_info* info,
+                                              size_t pos,
+                                              size_t char_size);
+}

vendor/cpprestsdk/include/cpprest/details/http_constants.dat

@@ -0,0 +1,199 @@
+#ifdef _METHODS
+DAT(GET,              _XPLATSTR("GET"))
+DAT(POST,             _XPLATSTR("POST"))
+DAT(PUT,              _XPLATSTR("PUT"))
+DAT(DEL,              _XPLATSTR("DELETE"))
+DAT(HEAD,             _XPLATSTR("HEAD"))
+DAT(OPTIONS,          _XPLATSTR("OPTIONS"))
+DAT(TRCE,             _XPLATSTR("TRACE"))
+DAT(CONNECT,          _XPLATSTR("CONNECT"))
+DAT(MERGE,            _XPLATSTR("MERGE"))
+DAT(PATCH,            _XPLATSTR("PATCH"))
+#endif
+
+#ifdef _PHRASES
+DAT(Continue,              100, _XPLATSTR("Continue"))
+DAT(SwitchingProtocols,    101, _XPLATSTR("Switching Protocols"))
+DAT(OK,                    200, _XPLATSTR("OK"))
+DAT(Created,               201, _XPLATSTR("Created"))
+DAT(Accepted,              202, _XPLATSTR("Accepted"))
+DAT(NonAuthInfo,           203, _XPLATSTR("Non-Authoritative Information"))
+DAT(NoContent,             204, _XPLATSTR("No Content"))
+DAT(ResetContent,          205, _XPLATSTR("Reset Content"))
+DAT(PartialContent,        206, _XPLATSTR("Partial Content"))
+DAT(MultiStatus,           207, _XPLATSTR("Multi-Status"))
+DAT(AlreadyReported,       208, _XPLATSTR("Already Reported"))
+DAT(IMUsed,                226, _XPLATSTR("IM Used"))
+DAT(MultipleChoices,       300, _XPLATSTR("Multiple Choices"))
+DAT(MovedPermanently,      301, _XPLATSTR("Moved Permanently"))
+DAT(Found,                 302, _XPLATSTR("Found"))
+DAT(SeeOther,              303, _XPLATSTR("See Other"))
+DAT(NotModified,           304, _XPLATSTR("Not Modified"))
+DAT(UseProxy,              305, _XPLATSTR("Use Proxy"))
+DAT(TemporaryRedirect,     307, _XPLATSTR("Temporary Redirect"))
+DAT(PermanentRedirect,     308, _XPLATSTR("Permanent Redirect"))
+DAT(BadRequest,            400, _XPLATSTR("Bad Request"))
+DAT(Unauthorized,          401, _XPLATSTR("Unauthorized"))
+DAT(PaymentRequired,       402, _XPLATSTR("Payment Required"))
+DAT(Forbidden,             403, _XPLATSTR("Forbidden"))
+DAT(NotFound,              404, _XPLATSTR("Not Found"))
+DAT(MethodNotAllowed,      405, _XPLATSTR("Method Not Allowed"))
+DAT(NotAcceptable,         406, _XPLATSTR("Not Acceptable"))
+DAT(ProxyAuthRequired,     407, _XPLATSTR("Proxy Authentication Required"))
+DAT(RequestTimeout,        408, _XPLATSTR("Request Time-out"))
+DAT(Conflict,              409, _XPLATSTR("Conflict"))
+DAT(Gone,                  410, _XPLATSTR("Gone"))
+DAT(LengthRequired,        411, _XPLATSTR("Length Required"))
+DAT(PreconditionFailed,    412, _XPLATSTR("Precondition Failed"))
+DAT(RequestEntityTooLarge, 413, _XPLATSTR("Request Entity Too Large"))
+DAT(RequestUriTooLarge,    414, _XPLATSTR("Request Uri Too Large"))
+DAT(UnsupportedMediaType,  415, _XPLATSTR("Unsupported Media Type"))
+DAT(RangeNotSatisfiable,   416, _XPLATSTR("Requested range not satisfiable"))
+DAT(ExpectationFailed,     417, _XPLATSTR("Expectation Failed"))
+DAT(MisdirectedRequest,    421, _XPLATSTR("Misdirected Request"))
+DAT(UnprocessableEntity,   422, _XPLATSTR("Unprocessable Entity"))
+DAT(Locked,                423, _XPLATSTR("Locked"))
+DAT(FailedDependency,      424, _XPLATSTR("Failed Dependency"))
+DAT(UpgradeRequired,       426, _XPLATSTR("Upgrade Required"))
+DAT(PreconditionRequired,  428, _XPLATSTR("Precondition Required"))
+DAT(TooManyRequests,       429, _XPLATSTR("Too Many Requests"))
+DAT(RequestHeaderFieldsTooLarge,  431, _XPLATSTR("Request Header Fields Too Large"))
+DAT(UnavailableForLegalReasons,   451, _XPLATSTR("Unavailable For Legal Reasons"))
+DAT(InternalError,         500, _XPLATSTR("Internal Error"))
+DAT(NotImplemented,        501, _XPLATSTR("Not Implemented"))
+DAT(BadGateway,            502, _XPLATSTR("Bad Gateway"))
+DAT(ServiceUnavailable,    503, _XPLATSTR("Service Unavailable"))
+DAT(GatewayTimeout,        504, _XPLATSTR("Gateway Time-out"))
+DAT(HttpVersionNotSupported, 505, _XPLATSTR("HTTP Version not supported"))
+DAT(VariantAlsoNegotiates, 506, _XPLATSTR("Variant Also Negotiates"))
+DAT(InsufficientStorage,   507, _XPLATSTR("Insufficient Storage"))
+DAT(LoopDetected,          508, _XPLATSTR("Loop Detected"))
+DAT(NotExtended,           510, _XPLATSTR("Not Extended"))
+DAT(NetworkAuthenticationRequired, 511, _XPLATSTR("Network Authentication Required"))
+#endif // _PHRASES
+
+#ifdef _HEADER_NAMES
+DAT(accept,                 "Accept")
+DAT(accept_charset,         "Accept-Charset")
+DAT(accept_encoding,        "Accept-Encoding")
+DAT(accept_language,        "Accept-Language")
+DAT(accept_ranges,          "Accept-Ranges")
+DAT(access_control_allow_origin,  "Access-Control-Allow-Origin")
+DAT(age,                    "Age")
+DAT(allow,                  "Allow")
+DAT(authorization,          "Authorization")
+DAT(cache_control,          "Cache-Control")
+DAT(connection,             "Connection")
+DAT(content_encoding,       "Content-Encoding")
+DAT(content_language,       "Content-Language")
+DAT(content_length,         "Content-Length")
+DAT(content_location,       "Content-Location")
+DAT(content_md5,            "Content-MD5")
+DAT(content_range,          "Content-Range")
+DAT(content_type,           "Content-Type")
+DAT(content_disposition,    "Content-Disposition")
+DAT(date,                   "Date")
+DAT(etag,                   "ETag")
+DAT(expect,                 "Expect")
+DAT(expires,                "Expires")
+DAT(from,                   "From")
+DAT(host,                   "Host")
+DAT(if_match,               "If-Match")
+DAT(if_modified_since,      "If-Modified-Since")
+DAT(if_none_match,          "If-None-Match")
+DAT(if_range,               "If-Range")
+DAT(if_unmodified_since,    "If-Unmodified-Since")
+DAT(last_modified,          "Last-Modified")
+DAT(location,               "Location")
+DAT(max_forwards,           "Max-Forwards")
+DAT(pragma,                 "Pragma")
+DAT(proxy_authenticate,     "Proxy-Authenticate")
+DAT(proxy_authorization,    "Proxy-Authorization")
+DAT(range,                  "Range")
+DAT(referer,                "Referer")
+DAT(retry_after,            "Retry-After")
+DAT(server,                 "Server")
+DAT(te,                     "TE")
+DAT(trailer,                "Trailer")
+DAT(transfer_encoding,      "Transfer-Encoding")
+DAT(upgrade,                "Upgrade")
+DAT(user_agent,             "User-Agent")
+DAT(vary,                   "Vary")
+DAT(via,                    "Via")
+DAT(warning,                "Warning")
+DAT(www_authenticate,       "WWW-Authenticate")
+#endif // _HEADER_NAMES
+
+#ifdef _MIME_TYPES
+DAT(application_atom_xml,                  "application/atom+xml")
+DAT(application_http,                      "application/http")
+DAT(application_javascript,                "application/javascript")
+DAT(application_json,                      "application/json")
+DAT(application_xjson,                     "application/x-json")
+DAT(application_octetstream,               "application/octet-stream")
+DAT(application_x_www_form_urlencoded,     "application/x-www-form-urlencoded")
+DAT(multipart_form_data,                   "multipart/form-data")
+DAT(boundary,                              "boundary")
+DAT(form_data,                             "form-data")
+DAT(application_xjavascript,               "application/x-javascript")
+DAT(application_xml,                       "application/xml")
+DAT(message_http,                          "message/http")
+DAT(text,                                  "text")
+DAT(text_javascript,                       "text/javascript")
+DAT(text_json,                             "text/json")
+DAT(text_plain,                            "text/plain")
+DAT(text_plain_utf16,                      "text/plain; charset=utf-16")
+DAT(text_plain_utf16le,                    "text/plain; charset=utf-16le")
+DAT(text_plain_utf8,                       "text/plain; charset=utf-8")
+DAT(text_xjavascript,                      "text/x-javascript")
+DAT(text_xjson,                            "text/x-json")
+#endif // _MIME_TYPES
+
+#ifdef _CHARSET_TYPES
+DAT(ascii,                          "ascii")
+DAT(usascii,                        "us-ascii")
+DAT(latin1,                         "iso-8859-1")
+DAT(utf8,                           "utf-8")
+DAT(utf16,                          "utf-16")
+DAT(utf16le,                        "utf-16le")
+DAT(utf16be,                        "utf-16be")
+#endif // _CHARSET_TYPES
+
+#ifdef _OAUTH1_METHODS
+DAT(hmac_sha1,                      _XPLATSTR("HMAC-SHA1"))
+DAT(plaintext,                      _XPLATSTR("PLAINTEXT"))
+#endif // _OAUTH1_METHODS
+
+#ifdef _OAUTH1_STRINGS
+DAT(callback,                       "oauth_callback")
+DAT(callback_confirmed,             "oauth_callback_confirmed")
+DAT(consumer_key,                   "oauth_consumer_key")
+DAT(nonce,                          "oauth_nonce")
+DAT(realm,                          "realm") // NOTE: No "oauth_" prefix.
+DAT(signature,                      "oauth_signature")
+DAT(signature_method,               "oauth_signature_method")
+DAT(timestamp,                      "oauth_timestamp")
+DAT(token,                          "oauth_token")
+DAT(token_secret,                   "oauth_token_secret")
+DAT(verifier,                       "oauth_verifier")
+DAT(version,                        "oauth_version")
+#endif // _OAUTH1_STRINGS
+
+#ifdef _OAUTH2_STRINGS
+DAT(access_token,                   "access_token")
+DAT(authorization_code,             "authorization_code")
+DAT(bearer,                         "bearer")
+DAT(client_id,                      "client_id")
+DAT(client_secret,                  "client_secret")
+DAT(code,                           "code")
+DAT(expires_in,                     "expires_in")
+DAT(grant_type,                     "grant_type")
+DAT(redirect_uri,                   "redirect_uri")
+DAT(refresh_token,                  "refresh_token")
+DAT(client_credentials,             "client_credentials")
+DAT(response_type,                  "response_type")
+DAT(scope,                          "scope")
+DAT(state,                          "state")
+DAT(token,                          "token")
+DAT(token_type,                     "token_type")
+#endif // _OAUTH2_STRINGS

vendor/cpprestsdk/include/cpprest/details/http_helpers.h

@@ -0,0 +1,48 @@
+/***
+ * Copyright (C) Microsoft. All rights reserved.
+ * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+ *
+ * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ *
+ * Implementation Details of the http.h layer of messaging
+ *
+ * Functions and types for interoperating with http.h from modern C++
+ *   This file includes windows definitions and should not be included in a public header
+ *
+ * For the latest on this and related APIs, please see: https://github.com/Microsoft/cpprestsdk
+ *
+ * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+ ****/
+#pragma once
+
+#include "cpprest/details/basic_types.h"
+#include "cpprest/http_msg.h"
+
+namespace web
+{
+namespace http
+{
+namespace details
+{
+namespace chunked_encoding
+{
+// Transfer-Encoding: chunked support
+static const size_t additional_encoding_space = 12;
+static const size_t data_offset = additional_encoding_space - 2;
+
+// Add the data necessary for properly sending data with transfer-encoding: chunked.
+//
+// There are up to 12 additional bytes needed for each chunk:
+//
+// The last chunk requires 5 bytes, and is fixed.
+// All other chunks require up to 8 bytes for the length, and four for the two CRLF
+// delimiters.
+//
+_ASYNCRTIMP size_t __cdecl add_chunked_delimiters(_Out_writes_(buffer_size) uint8_t* data,
+                                                  _In_ size_t buffer_size,
+                                                  size_t bytes_read);
+} // namespace chunked_encoding
+
+} // namespace details
+} // namespace http
+} // namespace web

vendor/cpprestsdk/include/cpprest/details/http_server.h

@@ -0,0 +1,72 @@
+/***
+ * Copyright (C) Microsoft. All rights reserved.
+ * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+ *
+ * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ *
+ * HTTP Library: interface to implement HTTP server to service http_listeners.
+ *
+ * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+ ****/
+
+#pragma once
+
+#if _WIN32_WINNT < _WIN32_WINNT_VISTA
+#error "Error: http server APIs are not supported in XP"
+#endif //_WIN32_WINNT < _WIN32_WINNT_VISTA
+
+#include "cpprest/http_listener.h"
+
+namespace web
+{
+namespace http
+{
+namespace experimental
+{
+namespace details
+{
+/// <summary>
+/// Interface http listeners interact with for receiving and responding to http requests.
+/// </summary>
+class http_server
+{
+public:
+    /// <summary>
+    /// Release any held resources.
+    /// </summary>
+    virtual ~http_server() {};
+
+    /// <summary>
+    /// Start listening for incoming requests.
+    /// </summary>
+    virtual pplx::task<void> start() = 0;
+
+    /// <summary>
+    /// Registers an http listener.
+    /// </summary>
+    virtual pplx::task<void> register_listener(
+        _In_ web::http::experimental::listener::details::http_listener_impl* pListener) = 0;
+
+    /// <summary>
+    /// Unregisters an http listener.
+    /// </summary>
+    virtual pplx::task<void> unregister_listener(
+        _In_ web::http::experimental::listener::details::http_listener_impl* pListener) = 0;
+
+    /// <summary>
+    /// Stop processing and listening for incoming requests.
+    /// </summary>
+    virtual pplx::task<void> stop() = 0;
+
+    /// <summary>
+    /// Asynchronously sends the specified http response.
+    /// </summary>
+    /// <param name="response">The http_response to send.</param>
+    /// <returns>A operation which is completed once the response has been sent.</returns>
+    virtual pplx::task<void> respond(http::http_response response) = 0;
+};
+
+} // namespace details
+} // namespace experimental
+} // namespace http
+} // namespace web

vendor/cpprestsdk/include/cpprest/details/http_server_api.h

@@ -0,0 +1,93 @@
+/***
+ * Copyright (C) Microsoft. All rights reserved.
+ * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+ *
+ * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ *
+ * HTTP Library: exposes the entry points to the http server transport apis.
+ *
+ * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+ ****/
+
+#pragma once
+
+#if _WIN32_WINNT < _WIN32_WINNT_VISTA
+#error "Error: http server APIs are not supported in XP"
+#endif //_WIN32_WINNT < _WIN32_WINNT_VISTA
+
+#include "cpprest/http_listener.h"
+#include <memory>
+
+namespace web
+{
+namespace http
+{
+namespace experimental
+{
+namespace details
+{
+class http_server;
+
+/// <summary>
+/// Singleton class used to register for http requests and send responses.
+///
+/// The lifetime is tied to http listener registration. When the first listener registers an instance is created
+/// and when the last one unregisters the receiver stops and is destroyed. It can be started back up again if
+/// listeners are again registered.
+/// </summary>
+class http_server_api
+{
+public:
+    /// <summary>
+    /// Returns whether or not any listeners are registered.
+    /// </summary>
+    static bool __cdecl has_listener();
+
+    /// <summary>
+    /// Registers a HTTP server API.
+    /// </summary>
+    static void __cdecl register_server_api(std::unique_ptr<http_server> server_api);
+
+    /// <summary>
+    /// Clears the http server API.
+    /// </summary>
+    static void __cdecl unregister_server_api();
+
+    /// <summary>
+    /// Registers a listener for HTTP requests and starts receiving.
+    /// </summary>
+    static pplx::task<void> __cdecl register_listener(
+        _In_ web::http::experimental::listener::details::http_listener_impl* pListener);
+
+    /// <summary>
+    /// Unregisters the given listener and stops listening for HTTP requests.
+    /// </summary>
+    static pplx::task<void> __cdecl unregister_listener(
+        _In_ web::http::experimental::listener::details::http_listener_impl* pListener);
+
+    /// <summary>
+    /// Gets static HTTP server API. Could be null if no registered listeners.
+    /// </summary>
+    static http_server* __cdecl server_api();
+
+private:
+    /// Used to lock access to the server api registration
+    static pplx::extensibility::critical_section_t s_lock;
+
+    /// Registers a server API set -- this assumes the lock has already been taken
+    static void unsafe_register_server_api(std::unique_ptr<http_server> server_api);
+
+    // Static instance of the HTTP server API.
+    static std::unique_ptr<http_server> s_server_api;
+
+    /// Number of registered listeners;
+    static pplx::details::atomic_long s_registrations;
+
+    // Static only class. No creation.
+    http_server_api();
+};
+
+} // namespace details
+} // namespace experimental
+} // namespace http
+} // namespace web

vendor/cpprestsdk/include/cpprest/details/nosal.h

@@ -0,0 +1,77 @@
+/***
+ * Copyright (C) Microsoft. All rights reserved.
+ * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+ *
+ *
+ * For the latest on this and related APIs, please see: https://github.com/Microsoft/cpprestsdk
+ *
+ * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ ***/
+
+#pragma once
+// selected MS SAL annotations
+
+#ifdef _In_
+#undef _In_
+#endif
+#define _In_
+
+#ifdef _Inout_
+#undef _Inout_
+#endif
+#define _Inout_
+
+#ifdef _Out_
+#undef _Out_
+#endif
+#define _Out_
+
+#ifdef _In_z_
+#undef _In_z_
+#endif
+#define _In_z_
+
+#ifdef _Out_z_
+#undef _Out_z_
+#endif
+#define _Out_z_
+
+#ifdef _Inout_z_
+#undef _Inout_z_
+#endif
+#define _Inout_z_
+
+#ifdef _In_opt_
+#undef _In_opt_
+#endif
+#define _In_opt_
+
+#ifdef _Out_opt_
+#undef _Out_opt_
+#endif
+#define _Out_opt_
+
+#ifdef _Inout_opt_
+#undef _Inout_opt_
+#endif
+#define _Inout_opt_
+
+#ifdef _Out_writes_
+#undef _Out_writes_
+#endif
+#define _Out_writes_(x)
+
+#ifdef _Out_writes_opt_
+#undef _Out_writes_opt_
+#endif
+#define _Out_writes_opt_(x)
+
+#ifdef _In_reads_
+#undef _In_reads_
+#endif
+#define _In_reads_(x)
+
+#ifdef _Inout_updates_bytes_
+#undef _Inout_updates_bytes_
+#endif
+#define _Inout_updates_bytes_(x)

vendor/cpprestsdk/include/cpprest/details/resource.h

@@ -0,0 +1,14 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by Resource.rc
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE 101
+#define _APS_NEXT_COMMAND_VALUE 40001
+#define _APS_NEXT_CONTROL_VALUE 1001
+#define _APS_NEXT_SYMED_VALUE 101
+#endif
+#endif

vendor/cpprestsdk/include/cpprest/details/web_utilities.h

@@ -0,0 +1,225 @@
+/***
+ * Copyright (C) Microsoft. All rights reserved.
+ * Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+ *
+ * =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
+ *
+ * utility classes used by the different web:: clients
+ *
+ * =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+ ****/
+#pragma once
+
+#include "cpprest/asyncrt_utils.h"
+#include "cpprest/uri.h"
+
+namespace web
+{
+namespace details
+{
+class zero_memory_deleter
+{
+public:
+    _ASYNCRTIMP void operator()(::utility::string_t* data) const;
+};
+typedef std::unique_ptr<::utility::string_t, zero_memory_deleter> plaintext_string;
+
+#ifdef _WIN32
+#if _WIN32_WINNT >= _WIN32_WINNT_VISTA
+#ifdef __cplusplus_winrt
+class winrt_encryption
+{
+public:
+    winrt_encryption() = default;
+    _ASYNCRTIMP winrt_encryption(const std::wstring& data);
+    _ASYNCRTIMP plaintext_string decrypt() const;
+
+private:
+    ::pplx::task<Windows::Storage::Streams::IBuffer ^> m_buffer;
+};
+#else  // ^^^ __cplusplus_winrt ^^^ // vvv !__cplusplus_winrt vvv
+class win32_encryption
+{
+public:
+    win32_encryption() = default;
+    _ASYNCRTIMP win32_encryption(const std::wstring& data);
+    _ASYNCRTIMP ~win32_encryption();
+    _ASYNCRTIMP plaintext_string decrypt() const;
+
+private:
+    std::vector<char> m_buffer;
+    size_t m_numCharacters;
+};
+#endif // __cplusplus_winrt
+#endif // _WIN32_WINNT >= _WIN32_WINNT_VISTA
+#endif // _WIN32
+} // namespace details
+
+/// <summary>
+/// Represents a set of user credentials (user name and password) to be used
+/// for authentication.
+/// </summary>
+class credentials
+{
+public:
+    /// <summary>
+    /// Constructs an empty set of credentials without a user name or password.
+    /// </summary>
+    credentials() {}
+
+    /// <summary>
+    /// Constructs credentials from given user name and password.
+    /// </summary>
+    /// <param name="username">User name as a string.</param>
+    /// <param name="password">Password as a string.</param>
+    credentials(utility::string_t username, const utility::string_t& password)
+        : m_username(std::move(username)), m_password(password)
+    {
+    }
+
+    /// <summary>
+    /// The user name associated with the credentials.
+    /// </summary>
+    /// <returns>A string containing the user name.</returns>
+    const utility::string_t& username() const { return m_username; }
+
+    /// <summary>
+    /// The password for the user name associated with the credentials.
+    /// </summary>
+    /// <returns>A string containing the password.</returns>
+    CASABLANCA_DEPRECATED(
+        "This API is deprecated for security reasons to avoid unnecessary password copies stored in plaintext.")
+    utility::string_t password() const
+    {
+#if defined(_WIN32) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
+        return utility::string_t(*m_password.decrypt());
+#else
+        return m_password;
+#endif
+    }
+
+    /// <summary>
+    /// Checks if credentials have been set
+    /// </summary>
+    /// <returns><c>true</c> if user name and password is set, <c>false</c> otherwise.</returns>
+    bool is_set() const { return !m_username.empty(); }
+
+    details::plaintext_string _internal_decrypt() const
+    {
+        // Encryption APIs not supported on XP
+#if defined(_WIN32) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
+        return m_password.decrypt();
+#else
+        return details::plaintext_string(new ::utility::string_t(m_password));
+#endif
+    }
+
+private:
+    ::utility::string_t m_username;
+
+#if defined(_WIN32) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
+#if defined(__cplusplus_winrt)
+    details::winrt_encryption m_password;
+#else
+    details::win32_encryption m_password;
+#endif
+#else
+    ::utility::string_t m_password;
+#endif
+};
+
+/// <summary>
+/// web_proxy represents the concept of the web proxy, which can be auto-discovered,
+/// disabled, or specified explicitly by the user.
+/// </summary>
+class web_proxy
+{
+    enum web_proxy_mode_internal
+    {
+        use_default_,
+        use_auto_discovery_,
+        disabled_,
+        user_provided_
+    };
+
+public:
+    enum web_proxy_mode
+    {
+        use_default = use_default_,
+        use_auto_discovery = use_auto_discovery_,
+        disabled = disabled_
+    };
+
+    /// <summary>
+    /// Constructs a proxy with the default settings.
+    /// </summary>
+    web_proxy() : m_address(), m_mode(use_default_) {}
+
+    /// <summary>
+    /// Creates a proxy with specified mode.
+    /// </summary>
+    /// <param name="mode">Mode to use.</param>
+    web_proxy(web_proxy_mode mode) : m_address(), m_mode(static_cast<web_proxy_mode_internal>(mode)) {}
+
+    /// <summary>
+    /// Creates a proxy explicitly with provided address.
+    /// </summary>
+    /// <param name="address">Proxy URI to use.</param>
+    web_proxy(uri address) : m_address(address), m_mode(user_provided_) {}
+
+    /// <summary>
+    /// Gets this proxy's URI address. Returns an empty URI if not explicitly set by user.
+    /// </summary>
+    /// <returns>A reference to this proxy's URI.</returns>
+    const uri& address() const { return m_address; }
+
+    /// <summary>
+    /// Gets the credentials used for authentication with this proxy.
+    /// </summary>
+    /// <returns>Credentials to for this proxy.</returns>
+    const web::credentials& credentials() const { return m_credentials; }
+
+    /// <summary>
+    /// Sets the credentials to use for authentication with this proxy.
+    /// </summary>
+    /// <param name="cred">Credentials to use for this proxy.</param>
+    void set_credentials(web::credentials cred)
+    {
+        if (m_mode == disabled_)
+        {
+            throw std::invalid_argument("Cannot attach credentials to a disabled proxy");
+        }
+        m_credentials = std::move(cred);
+    }
+
+    /// <summary>
+    /// Checks if this proxy was constructed with default settings.
+    /// </summary>
+    /// <returns>True if default, false otherwise.</param>
+    bool is_default() const { return m_mode == use_default_; }
+
+    /// <summary>
+    /// Checks if using a proxy is disabled.
+    /// </summary>
+    /// <returns>True if disabled, false otherwise.</returns>
+    bool is_disabled() const { return m_mode == disabled_; }
+
+    /// <summary>
+    /// Checks if the auto discovery protocol, WPAD, is to be used.
+    /// </summary>
+    /// <returns>True if auto discovery enabled, false otherwise.</returns>
+    bool is_auto_discovery() const { return m_mode == use_auto_discovery_; }
+
+    /// <summary>
+    /// Checks if a proxy address is explicitly specified by the user.
+    /// </summary>
+    /// <returns>True if a proxy address was explicitly specified, false otherwise.</returns>
+    bool is_specified() const { return m_mode == user_provided_; }
+
+private:
+    web::uri m_address;
+    web_proxy_mode_internal m_mode;
+    web::credentials m_credentials;
+};
+
+} // namespace web