diff --git a/.dockerignore b/.dockerignore index 14e2d1e..abab690 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1 +1,2 @@ -ggml/build \ No newline at end of file +ggml/build +build diff --git a/.gitmodules b/.gitmodules index cced70c..c51c1f2 100644 --- a/.gitmodules +++ b/.gitmodules @@ -7,6 +7,3 @@ [submodule "extern/sbdlog"] path = extern/spdlog url = https://github.com/gabime/spdlog.git -[submodule "extern/crow"] - path = extern/crow - url = https://github.com/CrowCpp/Crow.git diff --git a/CMakeLists.txt b/CMakeLists.txt index f9ea9ae..06e4caf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,8 +29,8 @@ endif() add_subdirectory(extern/ggml) add_subdirectory(extern/argparse) -#add_subdirectory(extern/spdlog) -add_subdirectory(extern/crow) +add_subdirectory(extern/spdlog) + add_subdirectory(src) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) \ No newline at end of file diff --git a/extern/crow b/extern/crow deleted file mode 160000 index 4f3f5de..0000000 --- a/extern/crow +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 4f3f5deaaa01825c63c83431bfa96ccec195f741 diff --git a/include/turbopilot/crow_all.h b/include/turbopilot/crow_all.h new file mode 100644 index 0000000..4e6f0d5 --- /dev/null +++ b/include/turbopilot/crow_all.h @@ -0,0 +1,12643 @@ +/*BSD 3-Clause License + +Copyright (c) 2014-2017, ipkn + 2020-2022, CrowCpp +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +* Neither the name of the author nor the names of its + contributors may be used to endorse or promote products derived from + this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The Crow logo and other graphic material (excluding third party logos) used are under exclusive Copyright (c) 2021-2022, Farook Al-Sammarraie (The-EDev), All rights reserved. +*/ +#pragma once +// settings for crow +// TODO(ipkn) replace with runtime config. libucl? + +/* #ifdef - enables debug mode */ +//#define CROW_ENABLE_DEBUG + +/* #ifdef - enables logging */ +#define CROW_ENABLE_LOGGING + +/* #ifdef - enables ssl */ +//#define CROW_ENABLE_SSL + +/* #ifdef - enforces section 5.2 and 6.1 of RFC6455 (only accepting masked messages from clients) */ +//#define CROW_ENFORCE_WS_SPEC + +/* #define - specifies log level */ +/* + Debug = 0 + Info = 1 + Warning = 2 + Error = 3 + Critical = 4 + + default to INFO +*/ +#ifndef CROW_LOG_LEVEL +#define CROW_LOG_LEVEL 1 +#endif + +#ifndef CROW_STATIC_DIRECTORY +#define CROW_STATIC_DIRECTORY "static/" +#endif +#ifndef CROW_STATIC_ENDPOINT +#define CROW_STATIC_ENDPOINT "/static/" +#endif + +// compiler flags +#if defined(_MSVC_LANG) && _MSVC_LANG >= 201402L +#define CROW_CAN_USE_CPP14 +#endif +#if __cplusplus >= 201402L +#define CROW_CAN_USE_CPP14 +#endif + +#if defined(_MSVC_LANG) && _MSVC_LANG >= 201703L +#define CROW_CAN_USE_CPP17 +#endif +#if __cplusplus >= 201703L +#define CROW_CAN_USE_CPP17 +#endif + +#if defined(_MSC_VER) +#if _MSC_VER < 1900 +#define CROW_MSVC_WORKAROUND +#define constexpr const +#define noexcept throw() +#endif +#endif + +#if defined(__GNUC__) && __GNUC__ == 8 && __GNUC_MINOR__ < 4 +#if __cplusplus > 201103L +#define CROW_GCC83_WORKAROUND +#else +#error "GCC 8.1 - 8.3 has a bug that prevents Crow from compiling with C++11. Please update GCC to > 8.3 or use C++ > 11." +#endif +#endif + + + +// This file is generated from nginx/conf/mime.types using nginx_mime2cpp.py on 2021-12-03. +#include +#include + +namespace crow +{ + const std::unordered_map mime_types{ + {"shtml", "text/html"}, + {"htm", "text/html"}, + {"html", "text/html"}, + {"css", "text/css"}, + {"xml", "text/xml"}, + {"gif", "image/gif"}, + {"jpg", "image/jpeg"}, + {"jpeg", "image/jpeg"}, + {"js", "application/javascript"}, + {"atom", "application/atom+xml"}, + {"rss", "application/rss+xml"}, + {"mml", "text/mathml"}, + {"txt", "text/plain"}, + {"jad", "text/vnd.sun.j2me.app-descriptor"}, + {"wml", "text/vnd.wap.wml"}, + {"htc", "text/x-component"}, + {"avif", "image/avif"}, + {"png", "image/png"}, + {"svgz", "image/svg+xml"}, + {"svg", "image/svg+xml"}, + {"tiff", "image/tiff"}, + {"tif", "image/tiff"}, + {"wbmp", "image/vnd.wap.wbmp"}, + {"webp", "image/webp"}, + {"ico", "image/x-icon"}, + {"jng", "image/x-jng"}, + {"bmp", "image/x-ms-bmp"}, + {"woff", "font/woff"}, + {"woff2", "font/woff2"}, + {"ear", "application/java-archive"}, + {"war", "application/java-archive"}, + {"jar", "application/java-archive"}, + {"json", "application/json"}, + {"hqx", "application/mac-binhex40"}, + {"doc", "application/msword"}, + {"pdf", "application/pdf"}, + {"ai", "application/postscript"}, + {"eps", "application/postscript"}, + {"ps", "application/postscript"}, + {"rtf", "application/rtf"}, + {"m3u8", "application/vnd.apple.mpegurl"}, + {"kml", "application/vnd.google-earth.kml+xml"}, + {"kmz", "application/vnd.google-earth.kmz"}, + {"xls", "application/vnd.ms-excel"}, + {"eot", "application/vnd.ms-fontobject"}, + {"ppt", "application/vnd.ms-powerpoint"}, + {"odg", "application/vnd.oasis.opendocument.graphics"}, + {"odp", "application/vnd.oasis.opendocument.presentation"}, + {"ods", "application/vnd.oasis.opendocument.spreadsheet"}, + {"odt", "application/vnd.oasis.opendocument.text"}, + {"pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"}, + {"xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"}, + {"docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"}, + {"wmlc", "application/vnd.wap.wmlc"}, + {"wasm", "application/wasm"}, + {"7z", "application/x-7z-compressed"}, + {"cco", "application/x-cocoa"}, + {"jardiff", "application/x-java-archive-diff"}, + {"jnlp", "application/x-java-jnlp-file"}, + {"run", "application/x-makeself"}, + {"pm", "application/x-perl"}, + {"pl", "application/x-perl"}, + {"pdb", "application/x-pilot"}, + {"prc", "application/x-pilot"}, + {"rar", "application/x-rar-compressed"}, + {"rpm", "application/x-redhat-package-manager"}, + {"sea", "application/x-sea"}, + {"swf", "application/x-shockwave-flash"}, + {"sit", "application/x-stuffit"}, + {"tk", "application/x-tcl"}, + {"tcl", "application/x-tcl"}, + {"crt", "application/x-x509-ca-cert"}, + {"pem", "application/x-x509-ca-cert"}, + {"der", "application/x-x509-ca-cert"}, + {"xpi", "application/x-xpinstall"}, + {"xhtml", "application/xhtml+xml"}, + {"xspf", "application/xspf+xml"}, + {"zip", "application/zip"}, + {"dll", "application/octet-stream"}, + {"exe", "application/octet-stream"}, + {"bin", "application/octet-stream"}, + {"deb", "application/octet-stream"}, + {"dmg", "application/octet-stream"}, + {"img", "application/octet-stream"}, + {"iso", "application/octet-stream"}, + {"msm", "application/octet-stream"}, + {"msp", "application/octet-stream"}, + {"msi", "application/octet-stream"}, + {"kar", "audio/midi"}, + {"midi", "audio/midi"}, + {"mid", "audio/midi"}, + {"mp3", "audio/mpeg"}, + {"ogg", "audio/ogg"}, + {"m4a", "audio/x-m4a"}, + {"ra", "audio/x-realaudio"}, + {"3gp", "video/3gpp"}, + {"3gpp", "video/3gpp"}, + {"ts", "video/mp2t"}, + {"mp4", "video/mp4"}, + {"mpg", "video/mpeg"}, + {"mpeg", "video/mpeg"}, + {"mov", "video/quicktime"}, + {"webm", "video/webm"}, + {"flv", "video/x-flv"}, + {"m4v", "video/x-m4v"}, + {"mng", "video/x-mng"}, + {"asf", "video/x-ms-asf"}, + {"asx", "video/x-ms-asf"}, + {"wmv", "video/x-ms-wmv"}, + {"avi", "video/x-msvideo"}}; +} + + + +#pragma once + +#include +#include +#include + +namespace crow +{ + /// Hashing function for ci_map (unordered_multimap). + struct ci_hash + { + size_t operator()(const std::string& key) const + { + std::size_t seed = 0; + std::locale locale; + + for (auto c : key) + { + boost::hash_combine(seed, std::toupper(c, locale)); + } + + return seed; + } + }; + + /// Equals function for ci_map (unordered_multimap). + struct ci_key_eq + { + bool operator()(const std::string& l, const std::string& r) const + { + return boost::iequals(l, r); + } + }; + + using ci_map = std::unordered_multimap; +} // namespace crow + + + +#pragma once + +#include + +namespace crow +{ + /// An abstract class that allows any other class to be returned by a handler. + struct returnable + { + std::string content_type; + virtual std::string dump() const = 0; + + returnable(std::string ctype): + content_type{ctype} + {} + + virtual ~returnable(){}; + }; +} // namespace crow + + + +#pragma once + + + + +#include +#include +#include +#include +#include +#include + +namespace crow +{ + enum class LogLevel + { +#ifndef ERROR +#ifndef DEBUG + DEBUG = 0, + INFO, + WARNING, + ERROR, + CRITICAL, +#endif +#endif + + Debug = 0, + Info, + Warning, + Error, + Critical, + }; + + class ILogHandler + { + public: + virtual void log(std::string message, LogLevel level) = 0; + }; + + class CerrLogHandler : public ILogHandler + { + public: + void log(std::string message, LogLevel level) override + { + std::string prefix; + switch (level) + { + case LogLevel::Debug: + prefix = "DEBUG "; + break; + case LogLevel::Info: + prefix = "INFO "; + break; + case LogLevel::Warning: + prefix = "WARNING "; + break; + case LogLevel::Error: + prefix = "ERROR "; + break; + case LogLevel::Critical: + prefix = "CRITICAL"; + break; + } + std::cerr << std::string("(") + timestamp() + std::string(") [") + prefix + std::string("] ") + message << std::endl; + } + + private: + static std::string timestamp() + { + char date[32]; + time_t t = time(0); + + tm my_tm; + +#if defined(_MSC_VER) || defined(__MINGW32__) +#ifdef CROW_USE_LOCALTIMEZONE + localtime_s(&my_tm, &t); +#else + gmtime_s(&my_tm, &t); +#endif +#else +#ifdef CROW_USE_LOCALTIMEZONE + localtime_r(&t, &my_tm); +#else + gmtime_r(&t, &my_tm); +#endif +#endif + + size_t sz = strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", &my_tm); + return std::string(date, date + sz); + } + }; + + class logger + { + public: + logger(LogLevel level): + level_(level) + {} + ~logger() + { +#ifdef CROW_ENABLE_LOGGING + if (level_ >= get_current_log_level()) + { + get_handler_ref()->log(stringstream_.str(), level_); + } +#endif + } + + // + template + logger& operator<<(T const& value) + { +#ifdef CROW_ENABLE_LOGGING + if (level_ >= get_current_log_level()) + { + stringstream_ << value; + } +#endif + return *this; + } + + // + static void setLogLevel(LogLevel level) { get_log_level_ref() = level; } + + static void setHandler(ILogHandler* handler) { get_handler_ref() = handler; } + + static LogLevel get_current_log_level() { return get_log_level_ref(); } + + private: + // + static LogLevel& get_log_level_ref() + { + static LogLevel current_level = static_cast(CROW_LOG_LEVEL); + return current_level; + } + static ILogHandler*& get_handler_ref() + { + static CerrLogHandler default_handler; + static ILogHandler* current_handler = &default_handler; + return current_handler; + } + + // + std::ostringstream stringstream_; + LogLevel level_; + }; +} // namespace crow + +#define CROW_LOG_CRITICAL \ + if (crow::logger::get_current_log_level() <= crow::LogLevel::Critical) \ + crow::logger(crow::LogLevel::Critical) +#define CROW_LOG_ERROR \ + if (crow::logger::get_current_log_level() <= crow::LogLevel::Error) \ + crow::logger(crow::LogLevel::Error) +#define CROW_LOG_WARNING \ + if (crow::logger::get_current_log_level() <= crow::LogLevel::Warning) \ + crow::logger(crow::LogLevel::Warning) +#define CROW_LOG_INFO \ + if (crow::logger::get_current_log_level() <= crow::LogLevel::Info) \ + crow::logger(crow::LogLevel::Info) +#define CROW_LOG_DEBUG \ + if (crow::logger::get_current_log_level() <= crow::LogLevel::Debug) \ + crow::logger(crow::LogLevel::Debug) + + + +#pragma once + +namespace crow +{ + constexpr const char VERSION[] = "1.0"; +} + + + +/* + * + * TinySHA1 - a header only implementation of the SHA1 algorithm in C++. Based + * on the implementation in boost::uuid::details. + * + * SHA1 Wikipedia Page: http://en.wikipedia.org/wiki/SHA-1 + * + * Copyright (c) 2012-22 SAURAV MOHAPATRA + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ +#ifndef _TINY_SHA1_HPP_ +#define _TINY_SHA1_HPP_ +#include +#include +#include +#include +namespace sha1 +{ + class SHA1 + { + public: + typedef uint32_t digest32_t[5]; + typedef uint8_t digest8_t[20]; + inline static uint32_t LeftRotate(uint32_t value, size_t count) { + return (value << count) ^ (value >> (32-count)); + } + SHA1(){ reset(); } + virtual ~SHA1() {} + SHA1(const SHA1& s) { *this = s; } + const SHA1& operator = (const SHA1& s) { + memcpy(m_digest, s.m_digest, 5 * sizeof(uint32_t)); + memcpy(m_block, s.m_block, 64); + m_blockByteIndex = s.m_blockByteIndex; + m_byteCount = s.m_byteCount; + return *this; + } + SHA1& reset() { + m_digest[0] = 0x67452301; + m_digest[1] = 0xEFCDAB89; + m_digest[2] = 0x98BADCFE; + m_digest[3] = 0x10325476; + m_digest[4] = 0xC3D2E1F0; + m_blockByteIndex = 0; + m_byteCount = 0; + return *this; + } + SHA1& processByte(uint8_t octet) { + this->m_block[this->m_blockByteIndex++] = octet; + ++this->m_byteCount; + if(m_blockByteIndex == 64) { + this->m_blockByteIndex = 0; + processBlock(); + } + return *this; + } + SHA1& processBlock(const void* const start, const void* const end) { + const uint8_t* begin = static_cast(start); + const uint8_t* finish = static_cast(end); + while(begin != finish) { + processByte(*begin); + begin++; + } + return *this; + } + SHA1& processBytes(const void* const data, size_t len) { + const uint8_t* block = static_cast(data); + processBlock(block, block + len); + return *this; + } + const uint32_t* getDigest(digest32_t digest) { + size_t bitCount = this->m_byteCount * 8; + processByte(0x80); + if (this->m_blockByteIndex > 56) { + while (m_blockByteIndex != 0) { + processByte(0); + } + while (m_blockByteIndex < 56) { + processByte(0); + } + } else { + while (m_blockByteIndex < 56) { + processByte(0); + } + } + processByte(0); + processByte(0); + processByte(0); + processByte(0); + processByte( static_cast((bitCount>>24) & 0xFF)); + processByte( static_cast((bitCount>>16) & 0xFF)); + processByte( static_cast((bitCount>>8 ) & 0xFF)); + processByte( static_cast((bitCount) & 0xFF)); + + memcpy(digest, m_digest, 5 * sizeof(uint32_t)); + return digest; + } + const uint8_t* getDigestBytes(digest8_t digest) { + digest32_t d32; + getDigest(d32); + size_t di = 0; + digest[di++] = ((d32[0] >> 24) & 0xFF); + digest[di++] = ((d32[0] >> 16) & 0xFF); + digest[di++] = ((d32[0] >> 8) & 0xFF); + digest[di++] = ((d32[0]) & 0xFF); + + digest[di++] = ((d32[1] >> 24) & 0xFF); + digest[di++] = ((d32[1] >> 16) & 0xFF); + digest[di++] = ((d32[1] >> 8) & 0xFF); + digest[di++] = ((d32[1]) & 0xFF); + + digest[di++] = ((d32[2] >> 24) & 0xFF); + digest[di++] = ((d32[2] >> 16) & 0xFF); + digest[di++] = ((d32[2] >> 8) & 0xFF); + digest[di++] = ((d32[2]) & 0xFF); + + digest[di++] = ((d32[3] >> 24) & 0xFF); + digest[di++] = ((d32[3] >> 16) & 0xFF); + digest[di++] = ((d32[3] >> 8) & 0xFF); + digest[di++] = ((d32[3]) & 0xFF); + + digest[di++] = ((d32[4] >> 24) & 0xFF); + digest[di++] = ((d32[4] >> 16) & 0xFF); + digest[di++] = ((d32[4] >> 8) & 0xFF); + digest[di++] = ((d32[4]) & 0xFF); + return digest; + } + + protected: + void processBlock() { + uint32_t w[80]; + for (size_t i = 0; i < 16; i++) { + w[i] = (m_block[i*4 + 0] << 24); + w[i] |= (m_block[i*4 + 1] << 16); + w[i] |= (m_block[i*4 + 2] << 8); + w[i] |= (m_block[i*4 + 3]); + } + for (size_t i = 16; i < 80; i++) { + w[i] = LeftRotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1); + } + + uint32_t a = m_digest[0]; + uint32_t b = m_digest[1]; + uint32_t c = m_digest[2]; + uint32_t d = m_digest[3]; + uint32_t e = m_digest[4]; + + for (std::size_t i=0; i<80; ++i) { + uint32_t f = 0; + uint32_t k = 0; + + if (i<20) { + f = (b & c) | (~b & d); + k = 0x5A827999; + } else if (i<40) { + f = b ^ c ^ d; + k = 0x6ED9EBA1; + } else if (i<60) { + f = (b & c) | (b & d) | (c & d); + k = 0x8F1BBCDC; + } else { + f = b ^ c ^ d; + k = 0xCA62C1D6; + } + uint32_t temp = LeftRotate(a, 5) + f + e + k + w[i]; + e = d; + d = c; + c = LeftRotate(b, 30); + b = a; + a = temp; + } + + m_digest[0] += a; + m_digest[1] += b; + m_digest[2] += c; + m_digest[3] += d; + m_digest[4] += e; + } + private: + digest32_t m_digest; + uint8_t m_block[64]; + size_t m_blockByteIndex; + size_t m_byteCount; + }; +} +#endif + + + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + +namespace crow +{ +// ---------------------------------------------------------------------------- +// qs_parse (modified) +// https://github.com/bartgrantham/qs_parse +// ---------------------------------------------------------------------------- +/* Similar to strncmp, but handles URL-encoding for either string */ +int qs_strncmp(const char * s, const char * qs, size_t n); + + +/* Finds the beginning of each key/value pair and stores a pointer in qs_kv. + * Also decodes the value portion of the k/v pair *in-place*. In a future + * enhancement it will also have a compile-time option of sorting qs_kv + * alphabetically by key. */ +int qs_parse(char * qs, char * qs_kv[], int qs_kv_size); + + +/* Used by qs_parse to decode the value portion of a k/v pair */ +int qs_decode(char * qs); + + +/* Looks up the value according to the key on a pre-processed query string + * A future enhancement will be a compile-time option to look up the key + * in a pre-sorted qs_kv array via a binary search. */ +//char * qs_k2v(const char * key, char * qs_kv[], int qs_kv_size); + char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth); + + +/* Non-destructive lookup of value, based on key. User provides the + * destinaton string and length. */ +char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len); + +// TODO: implement sorting of the qs_kv array; for now ensure it's not compiled +#undef _qsSORTING + +// isxdigit _is_ available in , but let's avoid another header instead +#define CROW_QS_ISHEX(x) ((((x)>='0'&&(x)<='9') || ((x)>='A'&&(x)<='F') || ((x)>='a'&&(x)<='f')) ? 1 : 0) +#define CROW_QS_HEX2DEC(x) (((x)>='0'&&(x)<='9') ? (x)-48 : ((x)>='A'&&(x)<='F') ? (x)-55 : ((x)>='a'&&(x)<='f') ? (x)-87 : 0) +#define CROW_QS_ISQSCHR(x) ((((x)=='=')||((x)=='#')||((x)=='&')||((x)=='\0')) ? 0 : 1) + +inline int qs_strncmp(const char * s, const char * qs, size_t n) +{ + int i=0; + unsigned char u1, u2, unyb, lnyb; + + while(n-- > 0) + { + u1 = static_cast(*s++); + u2 = static_cast(*qs++); + + if ( ! CROW_QS_ISQSCHR(u1) ) { u1 = '\0'; } + if ( ! CROW_QS_ISQSCHR(u2) ) { u2 = '\0'; } + + if ( u1 == '+' ) { u1 = ' '; } + if ( u1 == '%' ) // easier/safer than scanf + { + unyb = static_cast(*s++); + lnyb = static_cast(*s++); + if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) ) + u1 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb); + else + u1 = '\0'; + } + + if ( u2 == '+' ) { u2 = ' '; } + if ( u2 == '%' ) // easier/safer than scanf + { + unyb = static_cast(*qs++); + lnyb = static_cast(*qs++); + if ( CROW_QS_ISHEX(unyb) && CROW_QS_ISHEX(lnyb) ) + u2 = (CROW_QS_HEX2DEC(unyb) * 16) + CROW_QS_HEX2DEC(lnyb); + else + u2 = '\0'; + } + + if ( u1 != u2 ) + return u1 - u2; + if ( u1 == '\0' ) + return 0; + i++; + } + if ( CROW_QS_ISQSCHR(*qs) ) + return -1; + else + return 0; +} + + +inline int qs_parse(char * qs, char * qs_kv[], int qs_kv_size) +{ + int i, j; + char * substr_ptr; + + for(i=0; i means x iterations of this loop -> means *x+1* k/v pairs + substr_ptr += j + 1; + i++; + } + + // we only decode the values in place, the keys could have '='s in them + // which will hose our ability to distinguish keys from values later + for(j=0; j> qs_dict_name2kv(const char * dict_name, char * const * qs_kv, int qs_kv_size, int nth = 0) +{ + int i; + size_t name_len, skip_to_eq, skip_to_brace_open, skip_to_brace_close; + + name_len = strlen(dict_name); + +#ifdef _qsSORTING +// TODO: binary search for key in the sorted qs_kv +#else // _qsSORTING + for(i=0; i 0 && + skip_to_brace_close > 0 && + nth == 0 ) + { + auto key = std::string(qs_kv[i] + skip_to_brace_open, skip_to_brace_close - skip_to_brace_open); + auto value = std::string(qs_kv[i] + skip_to_eq); + return boost::make_optional(std::make_pair(key, value)); + } + else + { + --nth; + } + } + } +#endif // _qsSORTING + + return boost::none; +} + + +inline char * qs_scanvalue(const char * key, const char * qs, char * val, size_t val_len) +{ + size_t i, key_len; + const char * tmp; + + // find the beginning of the k/v substrings + if ( (tmp = strchr(qs, '?')) != NULL ) + qs = tmp + 1; + + key_len = strlen(key); + while(qs[0] != '#' && qs[0] != '\0') + { + if ( qs_strncmp(key, qs, key_len) == 0 ) + break; + qs += strcspn(qs, "&") + 1; + } + + if ( qs[0] == '\0' ) return NULL; + + qs += strcspn(qs, "=&#"); + if ( qs[0] == '=' ) + { + qs++; + i = strcspn(qs, "&=#"); +#ifdef _MSC_VER + strncpy_s(val, val_len, qs, (val_len - 1)<(i + 1) ? (val_len - 1) : (i + 1)); +#else + strncpy(val, qs, (val_len - 1)<(i + 1) ? (val_len - 1) : (i + 1)); +#endif + qs_decode(val); + } + else + { + if ( val_len > 0 ) + val[0] = '\0'; + } + + return val; +} +} +// ---------------------------------------------------------------------------- + + +namespace crow +{ + /// A class to represent any data coming after the `?` in the request URL into key-value pairs. + class query_string + { + public: + static const int MAX_KEY_VALUE_PAIRS_COUNT = 256; + + query_string() + { + + } + + query_string(const query_string& qs) + : url_(qs.url_) + { + for(auto p:qs.key_value_pairs_) + { + key_value_pairs_.push_back((char*)(p-qs.url_.c_str()+url_.c_str())); + } + } + + query_string& operator = (const query_string& qs) + { + url_ = qs.url_; + key_value_pairs_.clear(); + for(auto p:qs.key_value_pairs_) + { + key_value_pairs_.push_back((char*)(p-qs.url_.c_str()+url_.c_str())); + } + return *this; + } + + query_string& operator = (query_string&& qs) + { + key_value_pairs_ = std::move(qs.key_value_pairs_); + char* old_data = (char*)qs.url_.c_str(); + url_ = std::move(qs.url_); + for(auto& p:key_value_pairs_) + { + p += (char*)url_.c_str() - old_data; + } + return *this; + } + + + query_string(std::string url) + : url_(std::move(url)) + { + if (url_.empty()) + return; + + key_value_pairs_.resize(MAX_KEY_VALUE_PAIRS_COUNT); + + int count = qs_parse(&url_[0], &key_value_pairs_[0], MAX_KEY_VALUE_PAIRS_COUNT); + key_value_pairs_.resize(count); + } + + void clear() + { + key_value_pairs_.clear(); + url_.clear(); + } + + friend std::ostream& operator<<(std::ostream& os, const query_string& qs) + { + os << "[ "; + for(size_t i = 0; i < qs.key_value_pairs_.size(); ++i) { + if (i) + os << ", "; + os << qs.key_value_pairs_[i]; + } + os << " ]"; + return os; + + } + + /// Get a value from a name, used for `?name=value`. + + /// + /// Note: this method returns the value of the first occurrence of the key only, to return all occurrences, see \ref get_list(). + char* get (const std::string& name) const + { + char* ret = qs_k2v(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size()); + return ret; + } + + /// Works similar to \ref get() except it removes the item from the query string. + char* pop (const std::string& name) + { + char* ret = get(name); + if (ret != nullptr) + { + for (unsigned int i = 0; i get_dict (const std::string& name) const + { + std::unordered_map ret; + + int count = 0; + while(1) + { + if (auto element = qs_dict_name2kv(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size(), count++)) + ret.insert(*element); + else + break; + } + return ret; + } + + /// Works the same as \ref get_dict() but removes the values from the query string. + std::unordered_map pop_dict (const std::string& name) + { + std::unordered_map ret = get_dict(name); + if (!ret.empty()) + { + for (unsigned int i = 0; i keys() const + { + std::vector ret; + for (auto element: key_value_pairs_) + { + std::string str_element(element); + ret.emplace_back(str_element.substr(0, str_element.find('='))); + } + return ret; + } + + private: + std::string url_; + std::vector key_value_pairs_; + }; + +} // end namespace + + + +#pragma once + +#include +#include +#include +#include +#include + + + + +namespace crow +{ + namespace detail + { + + /// A class for scheduling functions to be called after a specific amount of ticks. A tick is equal to 1 second. + class task_timer + { + public: + using task_type = std::function; + using identifier_type = size_t; + + private: + using clock_type = std::chrono::steady_clock; + using time_type = clock_type::time_point; + + public: + task_timer(boost::asio::io_service& io_service): + io_service_(io_service), deadline_timer_(io_service_) + { + deadline_timer_.expires_from_now(boost::posix_time::seconds(1)); + deadline_timer_.async_wait( + std::bind(&task_timer::tick_handler, this, std::placeholders::_1)); + } + + ~task_timer() { deadline_timer_.cancel(); } + + void cancel(identifier_type id) + { + tasks_.erase(id); + CROW_LOG_DEBUG << "task_timer cancelled: " << this << ' ' << id; + } + + /// Schedule the given task to be executed after the default amount of ticks. + + /// + /// \return identifier_type Used to cancel the thread. + /// It is not bound to this task_timer instance and in some cases could lead to + /// undefined behavior if used with other task_timer objects or after the task + /// has been successfully executed. + identifier_type schedule(const task_type& task) + { + tasks_.insert( + {++highest_id_, + {clock_type::now() + std::chrono::seconds(get_default_timeout()), + task}}); + CROW_LOG_DEBUG << "task_timer scheduled: " << this << ' ' << highest_id_; + return highest_id_; + } + + /// Schedule the given task to be executed after the given time. + + /// + /// \param timeout The amount of ticks (seconds) to wait before execution. + /// + /// \return identifier_type Used to cancel the thread. + /// It is not bound to this task_timer instance and in some cases could lead to + /// undefined behavior if used with other task_timer objects or after the task + /// has been successfully executed. + identifier_type schedule(const task_type& task, std::uint8_t timeout) + { + tasks_.insert({++highest_id_, + {clock_type::now() + std::chrono::seconds(timeout), task}}); + CROW_LOG_DEBUG << "task_timer scheduled: " << this << ' ' << highest_id_; + return highest_id_; + } + + /// Set the default timeout for this task_timer instance. (Default: 5) + + /// + /// \param timeout The amount of ticks (seconds) to wait before execution. + void set_default_timeout(std::uint8_t timeout) { default_timeout_ = timeout; } + + /// Get the default timeout. (Default: 5) + std::uint8_t get_default_timeout() const { return default_timeout_; } + + private: + void process_tasks() + { + time_type current_time = clock_type::now(); + std::vector finished_tasks; + + for (const auto& task : tasks_) + { + if (task.second.first < current_time) + { + (task.second.second)(); + finished_tasks.push_back(task.first); + CROW_LOG_DEBUG << "task_timer called: " << this << ' ' << task.first; + } + } + + for (const auto& task : finished_tasks) + tasks_.erase(task); + + // If no task is currently scheduled, reset the issued ids back to 0. + if (tasks_.empty()) highest_id_ = 0; + } + + void tick_handler(const boost::system::error_code& ec) + { + if (ec) return; + + process_tasks(); + + deadline_timer_.expires_from_now(boost::posix_time::seconds(1)); + deadline_timer_.async_wait( + std::bind(&task_timer::tick_handler, this, std::placeholders::_1)); + } + + private: + std::uint8_t default_timeout_{5}; + boost::asio::io_service& io_service_; + boost::asio::deadline_timer deadline_timer_; + std::map> tasks_; + + // A continuosly increasing number to be issued to threads to identify them. + // If no tasks are scheduled, it will be reset to 0. + identifier_type highest_id_{0}; + }; + } // namespace detail +} // namespace crow + + + +#pragma once +#include +#ifdef CROW_ENABLE_SSL +#include +#endif + + +#if BOOST_VERSION >= 107000 +#define GET_IO_SERVICE(s) ((boost::asio::io_context&)(s).get_executor().context()) +#else +#define GET_IO_SERVICE(s) ((s).get_io_service()) +#endif +namespace crow +{ + using namespace boost; + using tcp = asio::ip::tcp; + + /// A wrapper for the asio::ip::tcp::socket and asio::ssl::stream + struct SocketAdaptor + { + using context = void; + SocketAdaptor(boost::asio::io_service& io_service, context*): + socket_(io_service) + {} + + boost::asio::io_service& get_io_service() + { + return GET_IO_SERVICE(socket_); + } + + /// Get the TCP socket handling data trasfers, regardless of what layer is handling transfers on top of the socket. + tcp::socket& raw_socket() + { + return socket_; + } + + /// Get the object handling data transfers, this can be either a TCP socket or an SSL stream (if SSL is enabled). + tcp::socket& socket() + { + return socket_; + } + + tcp::endpoint remote_endpoint() + { + return socket_.remote_endpoint(); + } + + bool is_open() + { + return socket_.is_open(); + } + + void close() + { + boost::system::error_code ec; + socket_.close(ec); + } + + void shutdown_readwrite() + { + boost::system::error_code ec; + socket_.shutdown(boost::asio::socket_base::shutdown_type::shutdown_both, ec); + } + + void shutdown_write() + { + boost::system::error_code ec; + socket_.shutdown(boost::asio::socket_base::shutdown_type::shutdown_send, ec); + } + + void shutdown_read() + { + boost::system::error_code ec; + socket_.shutdown(boost::asio::socket_base::shutdown_type::shutdown_receive, ec); + } + + template + void start(F f) + { + f(boost::system::error_code()); + } + + tcp::socket socket_; + }; + +#ifdef CROW_ENABLE_SSL + struct SSLAdaptor + { + using context = boost::asio::ssl::context; + using ssl_socket_t = boost::asio::ssl::stream; + SSLAdaptor(boost::asio::io_service& io_service, context* ctx): + ssl_socket_(new ssl_socket_t(io_service, *ctx)) + {} + + boost::asio::ssl::stream& socket() + { + return *ssl_socket_; + } + + tcp::socket::lowest_layer_type& + raw_socket() + { + return ssl_socket_->lowest_layer(); + } + + tcp::endpoint remote_endpoint() + { + return raw_socket().remote_endpoint(); + } + + bool is_open() + { + return ssl_socket_ ? raw_socket().is_open() : false; + } + + void close() + { + if (is_open()) + { + boost::system::error_code ec; + raw_socket().close(ec); + } + } + + void shutdown_readwrite() + { + if (is_open()) + { + boost::system::error_code ec; + raw_socket().shutdown(boost::asio::socket_base::shutdown_type::shutdown_both, ec); + } + } + + void shutdown_write() + { + if (is_open()) + { + boost::system::error_code ec; + raw_socket().shutdown(boost::asio::socket_base::shutdown_type::shutdown_send, ec); + } + } + + void shutdown_read() + { + if (is_open()) + { + boost::system::error_code ec; + raw_socket().shutdown(boost::asio::socket_base::shutdown_type::shutdown_receive, ec); + } + } + + boost::asio::io_service& get_io_service() + { + return GET_IO_SERVICE(raw_socket()); + } + + template + void start(F f) + { + ssl_socket_->async_handshake(boost::asio::ssl::stream_base::server, + [f](const boost::system::error_code& ec) { + f(ec); + }); + } + + std::unique_ptr> ssl_socket_; + }; +#endif +} // namespace crow + + + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include + + + + +// TODO(EDev): Adding C++20's [[likely]] and [[unlikely]] attributes might be useful +#if defined(__GNUG__) || defined(__clang__) +#define CROW_LIKELY(X) __builtin_expect(!!(X), 1) +#define CROW_UNLIKELY(X) __builtin_expect(!!(X), 0) +#else +#define CROW_LIKELY(X) (X) +#define CROW_UNLIKELY(X) (X) +#endif + +namespace crow +{ + /// @cond SKIP + namespace black_magic + { +#ifndef CROW_MSVC_WORKAROUND + /// Out of Range Exception for const_str + struct OutOfRange + { + OutOfRange(unsigned /*pos*/, unsigned /*length*/) {} + }; + /// Helper function to throw an exception if i is larger than len + constexpr unsigned requires_in_range(unsigned i, unsigned len) + { + return i >= len ? throw OutOfRange(i, len) : i; + } + + /// A constant string implementation. + class const_str + { + const char* const begin_; + unsigned size_; + + public: + template + constexpr const_str(const char (&arr)[N]): + begin_(arr), size_(N - 1) + { + static_assert(N >= 1, "not a string literal"); + } + constexpr char operator[](unsigned i) const + { + return requires_in_range(i, size_), begin_[i]; + } + + constexpr operator const char*() const + { + return begin_; + } + + constexpr const char* begin() const { return begin_; } + constexpr const char* end() const { return begin_ + size_; } + + constexpr unsigned size() const + { + return size_; + } + }; + + constexpr unsigned find_closing_tag(const_str s, unsigned p) + { + return s[p] == '>' ? p : find_closing_tag(s, p + 1); + } + + /// Check that the CROW_ROUTE string is valid + constexpr bool is_valid(const_str s, unsigned i = 0, int f = 0) + { + return i == s.size() ? f == 0 : + f < 0 || f >= 2 ? false : + s[i] == '<' ? is_valid(s, i + 1, f + 1) : + s[i] == '>' ? is_valid(s, i + 1, f - 1) : + is_valid(s, i + 1, f); + } + + constexpr bool is_equ_p(const char* a, const char* b, unsigned n) + { + return *a == 0 && *b == 0 && n == 0 ? true : + (*a == 0 || *b == 0) ? false : + n == 0 ? true : + *a != *b ? false : + is_equ_p(a + 1, b + 1, n - 1); + } + + constexpr bool is_equ_n(const_str a, unsigned ai, const_str b, unsigned bi, unsigned n) + { + return ai + n > a.size() || bi + n > b.size() ? false : + n == 0 ? true : + a[ai] != b[bi] ? false : + is_equ_n(a, ai + 1, b, bi + 1, n - 1); + } + + constexpr bool is_int(const_str s, unsigned i) + { + return is_equ_n(s, i, "", 0, 5); + } + + constexpr bool is_uint(const_str s, unsigned i) + { + return is_equ_n(s, i, "", 0, 6); + } + + constexpr bool is_float(const_str s, unsigned i) + { + return is_equ_n(s, i, "", 0, 7) || + is_equ_n(s, i, "", 0, 8); + } + + constexpr bool is_str(const_str s, unsigned i) + { + return is_equ_n(s, i, "", 0, 5) || + is_equ_n(s, i, "", 0, 8); + } + + constexpr bool is_path(const_str s, unsigned i) + { + return is_equ_n(s, i, "", 0, 6); + } +#endif + template + struct parameter_tag + { + static const int value = 0; + }; +#define CROW_INTERNAL_PARAMETER_TAG(t, i) \ + template<> \ + struct parameter_tag \ + { \ + static const int value = i; \ + } + CROW_INTERNAL_PARAMETER_TAG(int, 1); + CROW_INTERNAL_PARAMETER_TAG(char, 1); + CROW_INTERNAL_PARAMETER_TAG(short, 1); + CROW_INTERNAL_PARAMETER_TAG(long, 1); + CROW_INTERNAL_PARAMETER_TAG(long long, 1); + CROW_INTERNAL_PARAMETER_TAG(unsigned int, 2); + CROW_INTERNAL_PARAMETER_TAG(unsigned char, 2); + CROW_INTERNAL_PARAMETER_TAG(unsigned short, 2); + CROW_INTERNAL_PARAMETER_TAG(unsigned long, 2); + CROW_INTERNAL_PARAMETER_TAG(unsigned long long, 2); + CROW_INTERNAL_PARAMETER_TAG(double, 3); + CROW_INTERNAL_PARAMETER_TAG(std::string, 4); +#undef CROW_INTERNAL_PARAMETER_TAG + template + struct compute_parameter_tag_from_args_list; + + template<> + struct compute_parameter_tag_from_args_list<> + { + static const int value = 0; + }; + + template + struct compute_parameter_tag_from_args_list + { + static const int sub_value = + compute_parameter_tag_from_args_list::value; + static const int value = + parameter_tag::type>::value ? sub_value * 6 + parameter_tag::type>::value : sub_value; + }; + + static inline bool is_parameter_tag_compatible(uint64_t a, uint64_t b) + { + if (a == 0) + return b == 0; + if (b == 0) + return a == 0; + int sa = a % 6; + int sb = a % 6; + if (sa == 5) sa = 4; + if (sb == 5) sb = 4; + if (sa != sb) + return false; + return is_parameter_tag_compatible(a / 6, b / 6); + } + + static inline unsigned find_closing_tag_runtime(const char* s, unsigned p) + { + return s[p] == 0 ? throw std::runtime_error("unmatched tag <") : + s[p] == '>' ? p : + find_closing_tag_runtime(s, p + 1); + } + + static inline uint64_t get_parameter_tag_runtime(const char* s, unsigned p = 0) + { + return s[p] == 0 ? 0 : + s[p] == '<' ? ( + std::strncmp(s + p, "", 5) == 0 ? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 1 : + std::strncmp(s + p, "", 6) == 0 ? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 2 : + (std::strncmp(s + p, "", 7) == 0 || + std::strncmp(s + p, "", 8) == 0) ? + get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 3 : + (std::strncmp(s + p, "", 5) == 0 || + std::strncmp(s + p, "", 8) == 0) ? + get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 4 : + std::strncmp(s + p, "", 6) == 0 ? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 5 : + throw std::runtime_error("invalid parameter type")) : + get_parameter_tag_runtime(s, p + 1); + } +#ifndef CROW_MSVC_WORKAROUND + constexpr uint64_t get_parameter_tag(const_str s, unsigned p = 0) + { + return p == s.size() ? 0 : + s[p] == '<' ? ( + is_int(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 1 : + is_uint(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 2 : + is_float(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 3 : + is_str(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 4 : + is_path(s, p) ? get_parameter_tag(s, find_closing_tag(s, p)) * 6 + 5 : + throw std::runtime_error("invalid parameter type")) : + get_parameter_tag(s, p + 1); + } +#endif + + template + struct S + { + template + using push = S; + template + using push_back = S; + template class U> + using rebind = U; + }; + + // Check whether the template function can be called with specific arguments + template + struct CallHelper; + template + struct CallHelper> + { + template()(std::declval()...))> + static char __test(int); + + template + static int __test(...); + + static constexpr bool value = sizeof(__test(0)) == sizeof(char); + }; + + // Check Tuple contains type T + template + struct has_type; + + template + struct has_type> : std::false_type + {}; + + template + struct has_type> : has_type> + {}; + + template + struct has_type> : std::true_type + {}; + + // Kind of fold expressions in C++11 + template + struct bool_pack; + template + using all_true = std::is_same, bool_pack>; + + template + struct single_tag_to_type + {}; + + template<> + struct single_tag_to_type<1> + { + using type = int64_t; + }; + + template<> + struct single_tag_to_type<2> + { + using type = uint64_t; + }; + + template<> + struct single_tag_to_type<3> + { + using type = double; + }; + + template<> + struct single_tag_to_type<4> + { + using type = std::string; + }; + + template<> + struct single_tag_to_type<5> + { + using type = std::string; + }; + + + template + struct arguments + { + using subarguments = typename arguments::type; + using type = + typename subarguments::template push::type>; + }; + + template<> + struct arguments<0> + { + using type = S<>; + }; + + template + struct last_element_type + { + using type = typename std::tuple_element>::type; + }; + + + template<> + struct last_element_type<> + {}; + + + // from http://stackoverflow.com/questions/13072359/c11-compile-time-array-with-logarithmic-evaluation-depth + template + using Invoke = typename T::type; + + template + struct seq + { + using type = seq; + }; + + template + struct concat; + + template + struct concat, seq> : seq + {}; + + template + using Concat = Invoke>; + + template + struct gen_seq; + template + using GenSeq = Invoke>; + + template + struct gen_seq : Concat, GenSeq> + {}; + + template<> + struct gen_seq<0> : seq<> + {}; + template<> + struct gen_seq<1> : seq<0> + {}; + + template + struct pop_back_helper; + + template + struct pop_back_helper, Tuple> + { + template class U> + using rebind = U::type...>; + }; + + template + struct pop_back //: public pop_back_helper::type, std::tuple> + { + template class U> + using rebind = typename pop_back_helper::type, std::tuple>::template rebind; + }; + + template<> + struct pop_back<> + { + template class U> + using rebind = U<>; + }; + + // from http://stackoverflow.com/questions/2118541/check-if-c0x-parameter-pack-contains-a-type + template + struct contains : std::true_type + {}; + + template + struct contains : std::conditional::value, std::true_type, contains>::type + {}; + + template + struct contains : std::false_type + {}; + + template + struct empty_context + {}; + + template + struct promote + { + using type = T; + }; + +#define CROW_INTERNAL_PROMOTE_TYPE(t1, t2) \ + template<> \ + struct promote \ + { \ + using type = t2; \ + } + + CROW_INTERNAL_PROMOTE_TYPE(char, int64_t); + CROW_INTERNAL_PROMOTE_TYPE(short, int64_t); + CROW_INTERNAL_PROMOTE_TYPE(int, int64_t); + CROW_INTERNAL_PROMOTE_TYPE(long, int64_t); + CROW_INTERNAL_PROMOTE_TYPE(long long, int64_t); + CROW_INTERNAL_PROMOTE_TYPE(unsigned char, uint64_t); + CROW_INTERNAL_PROMOTE_TYPE(unsigned short, uint64_t); + CROW_INTERNAL_PROMOTE_TYPE(unsigned int, uint64_t); + CROW_INTERNAL_PROMOTE_TYPE(unsigned long, uint64_t); + CROW_INTERNAL_PROMOTE_TYPE(unsigned long long, uint64_t); + CROW_INTERNAL_PROMOTE_TYPE(float, double); +#undef CROW_INTERNAL_PROMOTE_TYPE + + template + using promote_t = typename promote::type; + + } // namespace black_magic + + namespace detail + { + + template + struct get_index_of_element_from_tuple_by_type_impl + { + static constexpr auto value = N; + }; + + template + struct get_index_of_element_from_tuple_by_type_impl + { + static constexpr auto value = N; + }; + + template + struct get_index_of_element_from_tuple_by_type_impl + { + static constexpr auto value = get_index_of_element_from_tuple_by_type_impl::value; + }; + + } // namespace detail + + namespace utility + { + template + T& get_element_by_type(std::tuple& t) + { + return std::get::value>(t); + } + + template + struct function_traits; + +#ifndef CROW_MSVC_WORKAROUND + template + struct function_traits : public function_traits + { + using parent_t = function_traits; + static const size_t arity = parent_t::arity; + using result_type = typename parent_t::result_type; + template + using arg = typename parent_t::template arg; + }; +#endif + + template + struct function_traits + { + static const size_t arity = sizeof...(Args); + + typedef R result_type; + + template + using arg = typename std::tuple_element>::type; + }; + + template + struct function_traits + { + static const size_t arity = sizeof...(Args); + + typedef R result_type; + + template + using arg = typename std::tuple_element>::type; + }; + + template + struct function_traits> + { + static const size_t arity = sizeof...(Args); + + typedef R result_type; + + template + using arg = typename std::tuple_element>::type; + }; + /// @endcond + + inline static std::string base64encode(const unsigned char* data, size_t size, const char* key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") + { + std::string ret; + ret.resize((size + 2) / 3 * 4); + auto it = ret.begin(); + while (size >= 3) + { + *it++ = key[(static_cast(*data) & 0xFC) >> 2]; + unsigned char h = (static_cast(*data++) & 0x03) << 4; + *it++ = key[h | ((static_cast(*data) & 0xF0) >> 4)]; + h = (static_cast(*data++) & 0x0F) << 2; + *it++ = key[h | ((static_cast(*data) & 0xC0) >> 6)]; + *it++ = key[static_cast(*data++) & 0x3F]; + + size -= 3; + } + if (size == 1) + { + *it++ = key[(static_cast(*data) & 0xFC) >> 2]; + unsigned char h = (static_cast(*data++) & 0x03) << 4; + *it++ = key[h]; + *it++ = '='; + *it++ = '='; + } + else if (size == 2) + { + *it++ = key[(static_cast(*data) & 0xFC) >> 2]; + unsigned char h = (static_cast(*data++) & 0x03) << 4; + *it++ = key[h | ((static_cast(*data) & 0xF0) >> 4)]; + h = (static_cast(*data++) & 0x0F) << 2; + *it++ = key[h]; + *it++ = '='; + } + return ret; + } + + inline static std::string base64encode(std::string data, size_t size, const char* key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/") + { + return base64encode((const unsigned char*)data.c_str(), size, key); + } + + inline static std::string base64encode_urlsafe(const unsigned char* data, size_t size) + { + return base64encode(data, size, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"); + } + + inline static std::string base64encode_urlsafe(std::string data, size_t size) + { + return base64encode((const unsigned char*)data.c_str(), size, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"); + } + + inline static std::string base64decode(const char* data, size_t size) + { + // We accept both regular and url encoding here, as there does not seem to be any downside to that. + // If we want to distinguish that we should use +/ for non-url and -_ for url. + + // Mapping logic from characters to [0-63] + auto key = [](char c) -> unsigned char { + if ((c >= 'A') && (c <= 'Z')) return c - 'A'; + if ((c >= 'a') && (c <= 'z')) return c - 'a' + 26; + if ((c >= '0') && (c <= '9')) return c - '0' + 52; + if ((c == '+') || (c == '-')) return 62; + if ((c == '/') || (c == '_')) return 63; + return 0; + }; + + // Not padded + if (size % 4 == 2) // missing last 2 characters + size = (size / 4 * 3) + 1; // Not subtracting extra characters because they're truncated in int division + else if (size % 4 == 3) // missing last character + size = (size / 4 * 3) + 2; // Not subtracting extra characters because they're truncated in int division + + // Padded + else if (data[size - 2] == '=') // padded with '==' + size = (size / 4 * 3) - 2; // == padding means the last block only has 1 character instead of 3, hence the '-2' + else if (data[size - 1] == '=') // padded with '=' + size = (size / 4 * 3) - 1; // = padding means the last block only has 2 character instead of 3, hence the '-1' + + // Padding not needed + else + size = size / 4 * 3; + + std::string ret; + ret.resize(size); + auto it = ret.begin(); + + // These will be used to decode 1 character at a time + unsigned char odd; // char1 and char3 + unsigned char even; // char2 and char4 + + // Take 4 character blocks to turn into 3 + while (size >= 3) + { + // dec_char1 = (char1 shifted 2 bits to the left) OR ((char2 AND 00110000) shifted 4 bits to the right)) + odd = key(*data++); + even = key(*data++); + *it++ = (odd << 2) | ((even & 0x30) >> 4); + // dec_char2 = ((char2 AND 00001111) shifted 4 bits left) OR ((char3 AND 00111100) shifted 2 bits right)) + odd = key(*data++); + *it++ = ((even & 0x0F) << 4) | ((odd & 0x3C) >> 2); + // dec_char3 = ((char3 AND 00000011) shifted 6 bits left) OR (char4) + even = key(*data++); + *it++ = ((odd & 0x03) << 6) | (even); + + size -= 3; + } + if (size == 2) + { + // d_char1 = (char1 shifted 2 bits to the left) OR ((char2 AND 00110000) shifted 4 bits to the right)) + odd = key(*data++); + even = key(*data++); + *it++ = (odd << 2) | ((even & 0x30) >> 4); + // d_char2 = ((char2 AND 00001111) shifted 4 bits left) OR ((char3 AND 00111100) shifted 2 bits right)) + odd = key(*data++); + *it++ = ((even & 0x0F) << 4) | ((odd & 0x3C) >> 2); + } + else if (size == 1) + { + // d_char1 = (char1 shifted 2 bits to the left) OR ((char2 AND 00110000) shifted 4 bits to the right)) + odd = key(*data++); + even = key(*data++); + *it++ = (odd << 2) | ((even & 0x30) >> 4); + } + return ret; + } + + inline static std::string base64decode(const std::string& data, size_t size) + { + return base64decode(data.data(), size); + } + + inline static std::string base64decode(const std::string& data) + { + return base64decode(data.data(), data.length()); + } + + + inline static void sanitize_filename(std::string& data, char replacement = '_') + { + if (data.length() > 255) + data.resize(255); + + static const auto toUpper = [](char c) { + return ((c >= 'a') && (c <= 'z')) ? (c - ('a' - 'A')) : c; + }; + // Check for special device names. The Windows behavior is really odd here, it will consider both AUX and AUX.txt + // a special device. Thus we search for the string (case-insensitive), and then check if the string ends or if + // is has a dangerous follow up character (.:\/) + auto sanitizeSpecialFile = [](std::string& source, unsigned ofs, const char* pattern, bool includeNumber, char replacement) { + unsigned i = ofs, len = source.length(); + const char* p = pattern; + while (*p) + { + if (i >= len) return; + if (toUpper(source[i]) != *p) return; + ++i; + ++p; + } + if (includeNumber) + { + if ((i >= len) || (source[i] < '1') || (source[i] > '9')) return; + ++i; + } + if ((i >= len) || (source[i] == '.') || (source[i] == ':') || (source[i] == '/') || (source[i] == '\\')) + { + source.erase(ofs + 1, (i - ofs) - 1); + source[ofs] = replacement; + } + }; + bool checkForSpecialEntries = true; + for (unsigned i = 0; i < data.length(); ++i) + { + // Recognize directory traversals and the special devices CON/PRN/AUX/NULL/COM[1-]/LPT[1-9] + if (checkForSpecialEntries) + { + checkForSpecialEntries = false; + switch (toUpper(data[i])) + { + case 'A': + sanitizeSpecialFile(data, i, "AUX", false, replacement); + break; + case 'C': + sanitizeSpecialFile(data, i, "CON", false, replacement); + sanitizeSpecialFile(data, i, "COM", true, replacement); + break; + case 'L': + sanitizeSpecialFile(data, i, "LPT", true, replacement); + break; + case 'N': + sanitizeSpecialFile(data, i, "NUL", false, replacement); + break; + case 'P': + sanitizeSpecialFile(data, i, "PRN", false, replacement); + break; + case '.': + sanitizeSpecialFile(data, i, "..", false, replacement); + break; + } + } + + // Sanitize individual characters + unsigned char c = data[i]; + if ((c < ' ') || ((c >= 0x80) && (c <= 0x9F)) || (c == '?') || (c == '<') || (c == '>') || (c == ':') || (c == '*') || (c == '|') || (c == '\"')) + { + data[i] = replacement; + } + else if ((c == '/') || (c == '\\')) + { + if (CROW_UNLIKELY(i == 0)) //Prevent Unix Absolute Paths (Windows Absolute Paths are prevented with `(c == ':')`) + { + data[i] = replacement; + } + else + { + checkForSpecialEntries = true; + } + } + } + } + + } // namespace utility +} // namespace crow + + + +#pragma once + +#include +#include +#include +#include + + + +namespace crow +{ + const char cr = '\r'; + const char lf = '\n'; + const std::string crlf("\r\n"); + + enum class HTTPMethod : char + { +#ifndef DELETE + DELETE = 0, + GET, + HEAD, + POST, + PUT, + + CONNECT, + OPTIONS, + TRACE, + + PATCH, + PURGE, + + COPY, + LOCK, + MKCOL, + MOVE, + PROPFIND, + PROPPATCH, + SEARCH, + UNLOCK, + BIND, + REBIND, + UNBIND, + ACL, + + REPORT, + MKACTIVITY, + CHECKOUT, + MERGE, + + MSEARCH, + NOTIFY, + SUBSCRIBE, + UNSUBSCRIBE, + + MKCALENDAR, + + LINK, + UNLINK, + + SOURCE, +#endif + + Delete = 0, + Get, + Head, + Post, + Put, + + Connect, + Options, + Trace, + + Patch, + Purge, + + Copy, + Lock, + MkCol, + Move, + Propfind, + Proppatch, + Search, + Unlock, + Bind, + Rebind, + Unbind, + Acl, + + Report, + MkActivity, + Checkout, + Merge, + + MSearch, + Notify, + Subscribe, + Unsubscribe, + + MkCalendar, + + Link, + Unlink, + + Source, + + + InternalMethodCount, + // should not add an item below this line: used for array count + }; + + constexpr const char* method_strings[] = + { + "DELETE", + "GET", + "HEAD", + "POST", + "PUT", + + "CONNECT", + "OPTIONS", + "TRACE", + + "PATCH", + "PURGE", + + "COPY", + "LOCK", + "MKCOL", + "MOVE", + "PROPFIND", + "PROPPATCH", + "SEARCH", + "UNLOCK", + "BIND", + "REBIND", + "UNBIND", + "ACL", + + "REPORT", + "MKACTIVITY", + "CHECKOUT", + "MERGE", + + "M-SEARCH", + "NOTIFY", + "SUBSCRIBE", + "UNSUBSCRIBE", + + "MKCALENDAR", + + "LINK", + "UNLINK", + + "SOURCE"}; + + + inline std::string method_name(HTTPMethod method) + { + if (CROW_LIKELY(method < HTTPMethod::InternalMethodCount)) + { + return method_strings[(unsigned char)method]; + } + return "invalid"; + } + + // clang-format off + + enum status + { + CONTINUE = 100, + SWITCHING_PROTOCOLS = 101, + + OK = 200, + CREATED = 201, + ACCEPTED = 202, + NON_AUTHORITATIVE_INFORMATION = 203, + NO_CONTENT = 204, + RESET_CONTENT = 205, + PARTIAL_CONTENT = 206, + + MULTIPLE_CHOICES = 300, + MOVED_PERMANENTLY = 301, + FOUND = 302, + SEE_OTHER = 303, + NOT_MODIFIED = 304, + TEMPORARY_REDIRECT = 307, + PERMANENT_REDIRECT = 308, + + BAD_REQUEST = 400, + UNAUTHORIZED = 401, + FORBIDDEN = 403, + NOT_FOUND = 404, + METHOD_NOT_ALLOWED = 405, + PROXY_AUTHENTICATION_REQUIRED = 407, + CONFLICT = 409, + GONE = 410, + PAYLOAD_TOO_LARGE = 413, + UNSUPPORTED_MEDIA_TYPE = 415, + RANGE_NOT_SATISFIABLE = 416, + EXPECTATION_FAILED = 417, + PRECONDITION_REQUIRED = 428, + TOO_MANY_REQUESTS = 429, + UNAVAILABLE_FOR_LEGAL_REASONS = 451, + + INTERNAL_SERVER_ERROR = 500, + NOT_IMPLEMENTED = 501, + BAD_GATEWAY = 502, + SERVICE_UNAVAILABLE = 503, + GATEWAY_TIMEOUT = 504, + VARIANT_ALSO_NEGOTIATES = 506 + }; + + // clang-format on + + enum class ParamType : char + { + INT, + UINT, + DOUBLE, + STRING, + PATH, + + MAX + }; + + /// @cond SKIP + struct routing_params + { + std::vector int_params; + std::vector uint_params; + std::vector double_params; + std::vector string_params; + + void debug_print() const + { + std::cerr << "routing_params" << std::endl; + for (auto i : int_params) + std::cerr << i << ", "; + std::cerr << std::endl; + for (auto i : uint_params) + std::cerr << i << ", "; + std::cerr << std::endl; + for (auto i : double_params) + std::cerr << i << ", "; + std::cerr << std::endl; + for (auto& i : string_params) + std::cerr << i << ", "; + std::cerr << std::endl; + } + + template + T get(unsigned) const; + }; + + template<> + inline int64_t routing_params::get(unsigned index) const + { + return int_params[index]; + } + + template<> + inline uint64_t routing_params::get(unsigned index) const + { + return uint_params[index]; + } + + template<> + inline double routing_params::get(unsigned index) const + { + return double_params[index]; + } + + template<> + inline std::string routing_params::get(unsigned index) const + { + return string_params[index]; + } + /// @endcond +} // namespace crow + +// clang-format off +#ifndef CROW_MSVC_WORKAROUND +constexpr crow::HTTPMethod method_from_string(const char* str) +{ + return crow::black_magic::is_equ_p(str, "GET", 3) ? crow::HTTPMethod::Get : + crow::black_magic::is_equ_p(str, "DELETE", 6) ? crow::HTTPMethod::Delete : + crow::black_magic::is_equ_p(str, "HEAD", 4) ? crow::HTTPMethod::Head : + crow::black_magic::is_equ_p(str, "POST", 4) ? crow::HTTPMethod::Post : + crow::black_magic::is_equ_p(str, "PUT", 3) ? crow::HTTPMethod::Put : + + crow::black_magic::is_equ_p(str, "OPTIONS", 7) ? crow::HTTPMethod::Options : + crow::black_magic::is_equ_p(str, "CONNECT", 7) ? crow::HTTPMethod::Connect : + crow::black_magic::is_equ_p(str, "TRACE", 5) ? crow::HTTPMethod::Trace : + + crow::black_magic::is_equ_p(str, "PATCH", 5) ? crow::HTTPMethod::Patch : + crow::black_magic::is_equ_p(str, "PURGE", 5) ? crow::HTTPMethod::Purge : + crow::black_magic::is_equ_p(str, "COPY", 4) ? crow::HTTPMethod::Copy : + crow::black_magic::is_equ_p(str, "LOCK", 4) ? crow::HTTPMethod::Lock : + crow::black_magic::is_equ_p(str, "MKCOL", 5) ? crow::HTTPMethod::MkCol : + crow::black_magic::is_equ_p(str, "MOVE", 4) ? crow::HTTPMethod::Move : + crow::black_magic::is_equ_p(str, "PROPFIND", 8) ? crow::HTTPMethod::Propfind : + crow::black_magic::is_equ_p(str, "PROPPATCH", 9) ? crow::HTTPMethod::Proppatch : + crow::black_magic::is_equ_p(str, "SEARCH", 6) ? crow::HTTPMethod::Search : + crow::black_magic::is_equ_p(str, "UNLOCK", 6) ? crow::HTTPMethod::Unlock : + crow::black_magic::is_equ_p(str, "BIND", 4) ? crow::HTTPMethod::Bind : + crow::black_magic::is_equ_p(str, "REBIND", 6) ? crow::HTTPMethod::Rebind : + crow::black_magic::is_equ_p(str, "UNBIND", 6) ? crow::HTTPMethod::Unbind : + crow::black_magic::is_equ_p(str, "ACL", 3) ? crow::HTTPMethod::Acl : + + crow::black_magic::is_equ_p(str, "REPORT", 6) ? crow::HTTPMethod::Report : + crow::black_magic::is_equ_p(str, "MKACTIVITY", 10) ? crow::HTTPMethod::MkActivity : + crow::black_magic::is_equ_p(str, "CHECKOUT", 8) ? crow::HTTPMethod::Checkout : + crow::black_magic::is_equ_p(str, "MERGE", 5) ? crow::HTTPMethod::Merge : + + crow::black_magic::is_equ_p(str, "MSEARCH", 7) ? crow::HTTPMethod::MSearch : + crow::black_magic::is_equ_p(str, "NOTIFY", 6) ? crow::HTTPMethod::Notify : + crow::black_magic::is_equ_p(str, "SUBSCRIBE", 9) ? crow::HTTPMethod::Subscribe : + crow::black_magic::is_equ_p(str, "UNSUBSCRIBE", 11) ? crow::HTTPMethod::Unsubscribe : + + crow::black_magic::is_equ_p(str, "MKCALENDAR", 10) ? crow::HTTPMethod::MkCalendar : + + crow::black_magic::is_equ_p(str, "LINK", 4) ? crow::HTTPMethod::Link : + crow::black_magic::is_equ_p(str, "UNLINK", 6) ? crow::HTTPMethod::Unlink : + + crow::black_magic::is_equ_p(str, "SOURCE", 6) ? crow::HTTPMethod::Source : + throw std::runtime_error("invalid http method"); +} + +constexpr crow::HTTPMethod operator"" _method(const char* str, size_t /*len*/) +{ + return method_from_string( str ); +} +#endif +// clang-format on + + + +#pragma once + +#include + + + + + + + + +namespace crow +{ + /// Find and return the value associated with the key. (returns an empty string if nothing is found) + template + inline const std::string& get_header_value(const T& headers, const std::string& key) + { + if (headers.count(key)) + { + return headers.find(key)->second; + } + static std::string empty; + return empty; + } + + /// An HTTP request. + struct request + { + HTTPMethod method; + std::string raw_url; ///< The full URL containing the `?` and URL parameters. + std::string url; ///< The endpoint without any parameters. + query_string url_params; ///< The parameters associated with the request. (everything after the `?`) + ci_map headers; + std::string body; + std::string remote_ip_address; ///< The IP address from which the request was sent. + unsigned char http_ver_major, http_ver_minor; + bool keep_alive, close_connection, upgrade; + + void* middleware_context{}; + void* middleware_container{}; + boost::asio::io_service* io_service{}; + + /// Construct an empty request. (sets the method to `GET`) + request(): + method(HTTPMethod::Get) + {} + + /// Construct a request with all values assigned. + request(HTTPMethod method, std::string raw_url, std::string url, query_string url_params, ci_map headers, std::string body, unsigned char http_major, unsigned char http_minor, bool has_keep_alive, bool has_close_connection, bool is_upgrade): + method(method), raw_url(std::move(raw_url)), url(std::move(url)), url_params(std::move(url_params)), headers(std::move(headers)), body(std::move(body)), http_ver_major(http_major), http_ver_minor(http_minor), keep_alive(has_keep_alive), close_connection(has_close_connection), upgrade(is_upgrade) + {} + + void add_header(std::string key, std::string value) + { + headers.emplace(std::move(key), std::move(value)); + } + + const std::string& get_header_value(const std::string& key) const + { + return crow::get_header_value(headers, key); + } + + bool check_version(unsigned char major, unsigned char minor) const + { + return http_ver_major == major && http_ver_minor == minor; + } + + /// Send data to whoever made this request with a completion handler and return immediately. + template + void post(CompletionHandler handler) + { + io_service->post(handler); + } + + /// Send data to whoever made this request with a completion handler. + template + void dispatch(CompletionHandler handler) + { + io_service->dispatch(handler); + } + }; +} // namespace crow + + + +#pragma once + +#include +#include +#include + + + + + + + + +namespace crow +{ + + /// Encapsulates anything related to processing and organizing `multipart/xyz` messages + namespace multipart + { + + const std::string dd = "--"; + + /// The first part in a section, contains metadata about the part + struct header + { + std::string value; ///< The first part of the header, usually `Content-Type` or `Content-Disposition` + std::unordered_map params; ///< The parameters of the header, come after the `value` + + operator int() const { return std::stoi(value); } ///< Returns \ref value as integer + operator double() const { return std::stod(value); } ///< Returns \ref value as double + }; + + /// Multipart header map (key is header key). + using mph_map = std::unordered_multimap; + + /// Find and return the value object associated with the key. (returns an empty class if nothing is found) + template + inline const O& get_header_value_object(const T& headers, const std::string& key) + { + if (headers.count(key)) + { + return headers.find(key)->second; + } + static O empty; + return empty; + } + + /// Same as \ref get_header_value_object() but for \ref multipart.header + template + inline const header& get_header_object(const T& headers, const std::string& key) + { + return get_header_value_object
(headers, key); + } + + ///One part of the multipart message + + /// + /// It is usually separated from other sections by a `boundary` + struct part + { + mph_map headers; ///< (optional) The first part before the data, Contains information regarding the type of data and encoding + std::string body; ///< The actual data in the part + + operator int() const { return std::stoi(body); } ///< Returns \ref body as integer + operator double() const { return std::stod(body); } ///< Returns \ref body as double + + const header& get_header_object(const std::string& key) const + { + return multipart::get_header_object(headers, key); + } + }; + + /// Multipart map (key is the name parameter). + using mp_map = std::unordered_multimap; + + /// The parsed multipart request/response + struct message : public returnable + { + ci_map headers; ///< The request/response headers + std::string boundary; ///< The text boundary that separates different `parts` + std::vector parts; ///< The individual parts of the message + mp_map part_map; ///< The individual parts of the message, organized in a map with the `name` header parameter being the key + + const std::string& get_header_value(const std::string& key) const + { + return crow::get_header_value(headers, key); + } + + part get_part_by_name(const std::string& name) + { + return part_map.find(name)->second; + } + + /// Represent all parts as a string (**does not include message headers**) + std::string dump() const override + { + std::stringstream str; + std::string delimiter = dd + boundary; + + for (unsigned i = 0; i < parts.size(); i++) + { + str << delimiter << crlf; + str << dump(i); + } + str << delimiter << dd << crlf; + return str.str(); + } + + /// Represent an individual part as a string + std::string dump(int part_) const + { + std::stringstream str; + part item = parts[part_]; + for (auto& item_h : item.headers) + { + str << item_h.first << ": " << item_h.second.value; + for (auto& it : item_h.second.params) + { + str << "; " << it.first << '=' << pad(it.second); + } + str << crlf; + } + str << crlf; + str << item.body << crlf; + return str.str(); + } + + /// Default constructor using default values + message(const ci_map& headers, const std::string& boundary, const std::vector& sections): + returnable("multipart/form-data; boundary=CROW-BOUNDARY"), headers(headers), boundary(boundary), parts(sections) + { + if (!boundary.empty()) + content_type = "multipart/form-data; boundary=" + boundary; + for (auto& item : parts) + { + part_map.emplace( + (get_header_object(item.headers, "Content-Disposition").params.find("name")->second), + item); + } + } + + /// Create a multipart message from a request data + message(const request& req): + returnable("multipart/form-data; boundary=CROW-BOUNDARY"), + headers(req.headers), + boundary(get_boundary(get_header_value("Content-Type"))) + { + if (!boundary.empty()) + content_type = "multipart/form-data; boundary=" + boundary; + parse_body(req.body, parts, part_map); + } + + private: + std::string get_boundary(const std::string& header) const + { + constexpr char boundary_text[] = "boundary="; + size_t found = header.find(boundary_text); + if (found) + { + std::string to_return(header.substr(found + strlen(boundary_text))); + if (to_return[0] == '\"') + { + to_return = to_return.substr(1, to_return.length() - 2); + } + return to_return; + } + return std::string(); + } + + void parse_body(std::string body, std::vector& sections, mp_map& part_map) + { + + std::string delimiter = dd + boundary; + + // TODO(EDev): Exit on error + while (body != (crlf)) + { + size_t found = body.find(delimiter); + std::string section = body.substr(0, found); + + // +2 is the CRLF. + // We don't check it and delete it so that the same delimiter can be used for The last delimiter (--delimiter--CRLF). + body.erase(0, found + delimiter.length() + 2); + if (!section.empty()) + { + part parsed_section(parse_section(section)); + part_map.emplace( + (get_header_object(parsed_section.headers, "Content-Disposition").params.find("name")->second), + parsed_section); + sections.push_back(std::move(parsed_section)); + } + } + } + + part parse_section(std::string& section) + { + struct part to_return; + + size_t found = section.find(crlf + crlf); + std::string head_line = section.substr(0, found + 2); + section.erase(0, found + 4); + + parse_section_head(head_line, to_return); + to_return.body = section.substr(0, section.length() - 2); + return to_return; + } + + void parse_section_head(std::string& lines, part& part) + { + while (!lines.empty()) + { + header to_add; + + size_t found = lines.find(crlf); + std::string line = lines.substr(0, found); + std::string key; + lines.erase(0, found + 2); + // Add the header if available + if (!line.empty()) + { + size_t found = line.find("; "); + std::string header = line.substr(0, found); + if (found != std::string::npos) + line.erase(0, found + 2); + else + line = std::string(); + + size_t header_split = header.find(": "); + key = header.substr(0, header_split); + + to_add.value = header.substr(header_split + 2); + } + + // Add the parameters + while (!line.empty()) + { + size_t found = line.find("; "); + std::string param = line.substr(0, found); + if (found != std::string::npos) + line.erase(0, found + 2); + else + line = std::string(); + + size_t param_split = param.find('='); + + std::string value = param.substr(param_split + 1); + + to_add.params.emplace(param.substr(0, param_split), trim(value)); + } + part.headers.emplace(key, to_add); + } + } + + inline std::string trim(std::string& string, const char& excess = '"') const + { + if (string.length() > 1 && string[0] == excess && string[string.length() - 1] == excess) + return string.substr(1, string.length() - 2); + return string; + } + + inline std::string pad(std::string& string, const char& padding = '"') const + { + return (padding + string + padding); + } + }; + } // namespace multipart +} // namespace crow + + + +#pragma once +#include +#include +#include +#include +#include +#include + + + + + + + + + + + + + + + +namespace crow +{ + template + class Connection; + + namespace detail + { + template + struct handler_middleware_wrapper; + } // namespace detail + + /// HTTP response + struct response + { + template + friend class crow::Connection; + + template + friend struct crow::detail::handler_middleware_wrapper; + + int code{200}; ///< The Status code for the response. + std::string body; ///< The actual payload containing the response data. + ci_map headers; ///< HTTP headers. + +#ifdef CROW_ENABLE_COMPRESSION + bool compressed = true; ///< If compression is enabled and this is false, the individual response will not be compressed. +#endif + bool skip_body = false; ///< Whether this is a response to a HEAD request. + bool manual_length_header = false; ///< Whether Crow should automatically add a "Content-Length" header. + + /// Set the value of an existing header in the response. + void set_header(std::string key, std::string value) + { + headers.erase(key); + headers.emplace(std::move(key), std::move(value)); + } + + /// Add a new header to the response. + void add_header(std::string key, std::string value) + { + headers.emplace(std::move(key), std::move(value)); + } + + const std::string& get_header_value(const std::string& key) + { + return crow::get_header_value(headers, key); + } + + // clang-format off + response() {} + explicit response(int code) : code(code) {} + response(std::string body) : body(std::move(body)) {} + response(int code, std::string body) : code(code), body(std::move(body)) {} + // clang-format on + response(returnable&& value) + { + body = value.dump(); + set_header("Content-Type", value.content_type); + } + response(returnable& value) + { + body = value.dump(); + set_header("Content-Type", value.content_type); + } + response(int code, returnable& value): + code(code) + { + body = value.dump(); + set_header("Content-Type", value.content_type); + } + + response(response&& r) + { + *this = std::move(r); + } + + response(std::string contentType, std::string body): + body(std::move(body)) + { + set_header("Content-Type", mime_types.at(contentType)); + } + + response(int code, std::string contentType, std::string body): + code(code), body(std::move(body)) + { + set_header("Content-Type", mime_types.at(contentType)); + } + + response& operator=(const response& r) = delete; + + response& operator=(response&& r) noexcept + { + body = std::move(r.body); + code = r.code; + headers = std::move(r.headers); + completed_ = r.completed_; + file_info = std::move(r.file_info); + return *this; + } + + /// Check if the response has completed (whether response.end() has been called) + bool is_completed() const noexcept + { + return completed_; + } + + void clear() + { + body.clear(); + code = 200; + headers.clear(); + completed_ = false; + file_info = static_file_info{}; + } + + /// Return a "Temporary Redirect" response. + + /// + /// Location can either be a route or a full URL. + void redirect(const std::string& location) + { + code = 307; + set_header("Location", location); + } + + /// Return a "Permanent Redirect" response. + + /// + /// Location can either be a route or a full URL. + void redirect_perm(const std::string& location) + { + code = 308; + set_header("Location", location); + } + + /// Return a "Found (Moved Temporarily)" response. + + /// + /// Location can either be a route or a full URL. + void moved(const std::string& location) + { + code = 302; + set_header("Location", location); + } + + /// Return a "Moved Permanently" response. + + /// + /// Location can either be a route or a full URL. + void moved_perm(const std::string& location) + { + code = 301; + set_header("Location", location); + } + + void write(const std::string& body_part) + { + body += body_part; + } + + /// Set the response completion flag and call the handler (to send the response). + void end() + { + if (!completed_) + { + completed_ = true; + if (skip_body) + { + set_header("Content-Length", std::to_string(body.size())); + body = ""; + manual_length_header = true; + } + if (complete_request_handler_) + { + complete_request_handler_(); + } + } + } + + /// Same as end() except it adds a body part right before ending. + void end(const std::string& body_part) + { + body += body_part; + end(); + } + + /// Check if the connection is still alive (usually by checking the socket status). + bool is_alive() + { + return is_alive_helper_ && is_alive_helper_(); + } + + /// Check whether the response has a static file defined. + bool is_static_type() + { + return file_info.path.size(); + } + + /// This constains metadata (coming from the `stat` command) related to any static files associated with this response. + + /// + /// Either a static file or a string body can be returned as 1 response. + struct static_file_info + { + std::string path = ""; + struct stat statbuf; + int statResult; + }; + + /// Return a static file as the response body + void set_static_file_info(std::string path) + { + utility::sanitize_filename(path); + set_static_file_info_unsafe(path); + } + + /// Return a static file as the response body without sanitizing the path (use set_static_file_info instead) + void set_static_file_info_unsafe(std::string path) + { + file_info.path = path; + file_info.statResult = stat(file_info.path.c_str(), &file_info.statbuf); +#ifdef CROW_ENABLE_COMPRESSION + compressed = false; +#endif + if (file_info.statResult == 0) + { + std::size_t last_dot = path.find_last_of("."); + std::string extension = path.substr(last_dot + 1); + code = 200; + this->add_header("Content-Length", std::to_string(file_info.statbuf.st_size)); + + if (!extension.empty()) + { + const auto mimeType = mime_types.find(extension); + if (mimeType != mime_types.end()) + { + this->add_header("Content-Type", mimeType->second); + } + else + { + this->add_header("Content-Type", "text/plain"); + } + } + } + else + { + code = 404; + file_info.path.clear(); + this->end(); + } + } + + private: + bool completed_{}; + std::function complete_request_handler_; + std::function is_alive_helper_; + static_file_info file_info; + }; +} // namespace crow + + + +#pragma once + + + + + +namespace crow +{ + + struct UTF8 + { + struct context + {}; + + void before_handle(request& /*req*/, response& /*res*/, context& /*ctx*/) + {} + + void after_handle(request& /*req*/, response& res, context& /*ctx*/) + { + if (get_header_value(res.headers, "Content-Type").empty()) + { + res.set_header("Content-Type", "text/plain; charset=utf-8"); + } + } + }; + +} // namespace crow + + + +#pragma once +#include + + + + + +namespace crow +{ + // Any middleware requires following 3 members: + + // struct context; + // storing data for the middleware; can be read from another middleware or handlers + + // before_handle + // called before handling the request. + // if res.end() is called, the operation is halted. + // (still call after_handle of this middleware) + // 2 signatures: + // void before_handle(request& req, response& res, context& ctx) + // if you only need to access this middlewares context. + // template + // void before_handle(request& req, response& res, context& ctx, AllContext& all_ctx) + // you can access another middlewares' context by calling `all_ctx.template get()' + // ctx == all_ctx.template get() + + // after_handle + // called after handling the request. + // void after_handle(request& req, response& res, context& ctx) + // template + // void after_handle(request& req, response& res, context& ctx, AllContext& all_ctx) + + struct CookieParser + { + struct context + { + std::unordered_map jar; + std::unordered_map cookies_to_add; + + std::string get_cookie(const std::string& key) const + { + auto cookie = jar.find(key); + if (cookie != jar.end()) + return cookie->second; + return {}; + } + + void set_cookie(const std::string& key, const std::string& value) + { + cookies_to_add.emplace(key, value); + } + }; + + void before_handle(request& req, response& res, context& ctx) + { + int count = req.headers.count("Cookie"); + if (!count) + return; + if (count > 1) + { + res.code = 400; + res.end(); + return; + } + std::string cookies = req.get_header_value("Cookie"); + size_t pos = 0; + while (pos < cookies.size()) + { + size_t pos_equal = cookies.find('=', pos); + if (pos_equal == cookies.npos) + break; + std::string name = cookies.substr(pos, pos_equal - pos); + boost::trim(name); + pos = pos_equal + 1; + while (pos < cookies.size() && cookies[pos] == ' ') + pos++; + if (pos == cookies.size()) + break; + + size_t pos_semicolon = cookies.find(';', pos); + std::string value = cookies.substr(pos, pos_semicolon - pos); + + boost::trim(value); + if (value[0] == '"' && value[value.size() - 1] == '"') + { + value = value.substr(1, value.size() - 2); + } + + ctx.jar.emplace(std::move(name), std::move(value)); + + pos = pos_semicolon; + if (pos == cookies.npos) + break; + pos++; + while (pos < cookies.size() && cookies[pos] == ' ') + pos++; + } + } + + void after_handle(request& /*req*/, response& res, context& ctx) + { + for (auto& cookie : ctx.cookies_to_add) + { + if (cookie.second.empty()) + res.add_header("Set-Cookie", cookie.first + "=\"\""); + else + res.add_header("Set-Cookie", cookie.first + "=" + cookie.second); + } + } + }; + + /* + App app; + A B C + A::context + int aa; + + ctx1 : public A::context + ctx2 : public ctx1, public B::context + ctx3 : public ctx2, public C::context + + C depends on A + + C::handle + context.aaa + + App::context : private CookieParser::contetx, ... + { + jar + + } + + SimpleApp + */ +} // namespace crow + + + +#pragma once + + + + + + + + +#include +#include +#include +#include + +namespace crow +{ + + /// Local middleware should extend ILocalMiddleware + struct ILocalMiddleware + { + using call_global = std::false_type; + }; + + namespace detail + { + template + struct check_before_handle_arity_3_const + { + template + struct get + {}; + }; + + template + struct check_before_handle_arity_3 + { + template + struct get + {}; + }; + + template + struct check_after_handle_arity_3_const + { + template + struct get + {}; + }; + + template + struct check_after_handle_arity_3 + { + template + struct get + {}; + }; + + template + struct check_global_call_false + { + template::type = true> + struct get + {}; + }; + + template + struct is_before_handle_arity_3_impl + { + template + static std::true_type f(typename check_before_handle_arity_3_const::template get*); + + template + static std::true_type f(typename check_before_handle_arity_3::template get*); + + template + static std::false_type f(...); + + public: + static const bool value = decltype(f(nullptr))::value; + }; + + template + struct is_after_handle_arity_3_impl + { + template + static std::true_type f(typename check_after_handle_arity_3_const::template get*); + + template + static std::true_type f(typename check_after_handle_arity_3::template get*); + + template + static std::false_type f(...); + + public: + static constexpr bool value = decltype(f(nullptr))::value; + }; + + template + typename std::enable_if::value>::type + before_handler_call(MW& mw, request& req, response& res, Context& ctx, ParentContext& /*parent_ctx*/) + { + mw.before_handle(req, res, ctx.template get(), ctx); + } + + template + typename std::enable_if::value>::type + before_handler_call(MW& mw, request& req, response& res, Context& ctx, ParentContext& /*parent_ctx*/) + { + mw.before_handle(req, res, ctx.template get()); + } + + template + typename std::enable_if::value>::type + after_handler_call(MW& mw, request& req, response& res, Context& ctx, ParentContext& /*parent_ctx*/) + { + mw.after_handle(req, res, ctx.template get(), ctx); + } + + template + typename std::enable_if::value>::type + after_handler_call(MW& mw, request& req, response& res, Context& ctx, ParentContext& /*parent_ctx*/) + { + mw.after_handle(req, res, ctx.template get()); + } + + + template class CallCriteria, // Checks if QueryMW should be called in this context + int N, typename Context, typename Container> + typename std::enable_if<(N < std::tuple_size::type>::value), bool>::type + middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx) + { + + using CurrentMW = typename std::tuple_element::type>::type; + + if (!CallCriteria::value) + { + return middleware_call_helper(middlewares, req, res, ctx); + } + + using parent_context_t = typename Context::template partial; + before_handler_call(std::get(middlewares), req, res, ctx, static_cast(ctx)); + if (res.is_completed()) + { + after_handler_call(std::get(middlewares), req, res, ctx, static_cast(ctx)); + return true; + } + + if (middleware_call_helper(middlewares, req, res, ctx)) + { + after_handler_call(std::get(middlewares), req, res, ctx, static_cast(ctx)); + return true; + } + + return false; + } + + template class CallCriteria, int N, typename Context, typename Container> + typename std::enable_if<(N >= std::tuple_size::type>::value), bool>::type + middleware_call_helper(Container& /*middlewares*/, request& /*req*/, response& /*res*/, Context& /*ctx*/) + { + return false; + } + + template class CallCriteria, int N, typename Context, typename Container> + typename std::enable_if<(N < 0)>::type + after_handlers_call_helper(Container& /*middlewares*/, Context& /*context*/, request& /*req*/, response& /*res*/) + { + } + + template class CallCriteria, int N, typename Context, typename Container> + typename std::enable_if<(N == 0)>::type after_handlers_call_helper(Container& middlewares, Context& ctx, request& req, response& res) + { + using parent_context_t = typename Context::template partial; + using CurrentMW = typename std::tuple_element::type>::type; + if (CallCriteria::value) + { + after_handler_call(std::get(middlewares), req, res, ctx, static_cast(ctx)); + } + } + + template class CallCriteria, int N, typename Context, typename Container> + typename std::enable_if<(N > 0)>::type after_handlers_call_helper(Container& middlewares, Context& ctx, request& req, response& res) + { + using parent_context_t = typename Context::template partial; + using CurrentMW = typename std::tuple_element::type>::type; + if (CallCriteria::value) + { + after_handler_call(std::get(middlewares), req, res, ctx, static_cast(ctx)); + } + after_handlers_call_helper(middlewares, ctx, req, res); + } + + // A CallCriteria that accepts only global middleware + template + struct middleware_call_criteria_only_global + { + template + static std::false_type f(typename check_global_call_false::template get*); + + template + static std::true_type f(...); + + static const bool value = decltype(f(nullptr))::value; + }; + + template + typename std::enable_if>::value, void>::type + wrapped_handler_call(crow::request& /*req*/, crow::response& res, const F& f, Args&&... args) + { + static_assert(!std::is_same()...))>::value, + "Handler function cannot have void return type; valid return types: string, int, crow::response, crow::returnable"); + + res = crow::response(f(std::forward(args)...)); + res.end(); + } + + template + typename std::enable_if< + !black_magic::CallHelper>::value && + black_magic::CallHelper>::value, + void>::type + wrapped_handler_call(crow::request& req, crow::response& res, const F& f, Args&&... args) + { + static_assert(!std::is_same(), std::declval()...))>::value, + "Handler function cannot have void return type; valid return types: string, int, crow::response, crow::returnable"); + + res = crow::response(f(req, std::forward(args)...)); + res.end(); + } + + template + typename std::enable_if< + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value && + black_magic::CallHelper>::value, + void>::type + wrapped_handler_call(crow::request& /*req*/, crow::response& res, const F& f, Args&&... args) + { + static_assert(std::is_same(), std::declval()...))>::value, + "Handler function with response argument should have void return type"); + + f(res, std::forward(args)...); + } + + template + typename std::enable_if< + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value && + black_magic::CallHelper>::value, + void>::type + wrapped_handler_call(crow::request& req, crow::response& res, const F& f, Args&&... args) + { + static_assert(std::is_same(), std::declval(), std::declval()...))>::value, + "Handler function with response argument should have void return type"); + + f(req, res, std::forward(args)...); + } + + // wrapped_handler_call transparently wraps a handler call behind (req, res, args...) + template + typename std::enable_if< + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value, + void>::type + wrapped_handler_call(crow::request& req, crow::response& res, const F& f, Args&&... args) + { + static_assert(std::is_same(), std::declval(), std::declval()...))>::value, + "Handler function with response argument should have void return type"); + + f(req, res, std::forward(args)...); + } + + template + struct handler_middleware_wrapper + { + // CallCriteria bound to the current Middlewares pack + template + struct middleware_call_criteria + { + static constexpr bool value = black_magic::has_type>::value; + }; + + template + void operator()(crow::request& req, crow::response& res, Args&&... args) const + { + auto& ctx = *reinterpret_cast(req.middleware_context); + auto& container = *reinterpret_cast(req.middleware_container); + + auto glob_completion_handler = std::move(res.complete_request_handler_); + res.complete_request_handler_ = [] {}; + + middleware_call_helper(container, req, res, ctx); + + if (res.completed_) + { + glob_completion_handler(); + return; + } + + res.complete_request_handler_ = [&ctx, &container, &req, &res, &glob_completion_handler] { + after_handlers_call_helper< + middleware_call_criteria, + std::tuple_size::value - 1, + typename App::context_t, + typename App::mw_container_t>(container, ctx, req, res); + glob_completion_handler(); + }; + + wrapped_handler_call(req, res, f, std::forward(args)...); + } + + F f; + }; + + template + struct handler_call_bridge + { + template + using check_app_contains = typename black_magic::has_type; + + static_assert(black_magic::all_true<(std::is_base_of::value)...>::value, + "Local middleware has to inherit crow::ILocalMiddleware"); + + static_assert(black_magic::all_true<(check_app_contains::value)...>::value, + "Local middleware has to be listed in app middleware"); + + template + void operator()(F&& f) const + { + auto wrapped = handler_middleware_wrapper{std::forward(f)}; + tptr->operator()(std::move(wrapped)); + } + + Route* tptr; + }; + + } // namespace detail +} // namespace crow + + + +#pragma once +#include +#include + + + + + + + +namespace crow +{ + namespace websocket + { + enum class WebSocketReadState + { + MiniHeader, + Len16, + Len64, + Mask, + Payload, + }; + + /// A base class for websocket connection. + struct connection + { + virtual void send_binary(const std::string& msg) = 0; + virtual void send_text(const std::string& msg) = 0; + virtual void send_ping(const std::string& msg) = 0; + virtual void send_pong(const std::string& msg) = 0; + virtual void close(const std::string& msg = "quit") = 0; + virtual std::string get_remote_ip() = 0; + virtual ~connection() {} + + void userdata(void* u) { userdata_ = u; } + void* userdata() { return userdata_; } + + private: + void* userdata_; + }; + + // Modified version of the illustration in RFC6455 Section-5.2 + // + // + // 0 1 2 3 -byte + // 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 -bit + // +-+-+-+-+-------+-+-------------+-------------------------------+ + // |F|R|R|R| opcode|M| Payload len | Extended payload length | + // |I|S|S|S| (4) |A| (7) | (16/64) | + // |N|V|V|V| |S| | (if payload len==126/127) | + // | |1|2|3| |K| | | + // +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - + + // | Extended payload length continued, if payload len == 127 | + // + - - - - - - - - - - - - - - - +-------------------------------+ + // | |Masking-key, if MASK set to 1 | + // +-------------------------------+-------------------------------+ + // | Masking-key (continued) | Payload Data | + // +-------------------------------- - - - - - - - - - - - - - - - + + // : Payload Data continued ... : + // + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + // | Payload Data continued ... | + // +---------------------------------------------------------------+ + // + + /// A websocket connection. + template + class Connection : public connection + { + public: + /// Constructor for a connection. + + /// + /// Requires a request with an "Upgrade: websocket" header.
+ /// Automatically handles the handshake. + Connection(const crow::request& req, Adaptor&& adaptor, + std::function open_handler, + std::function message_handler, + std::function close_handler, + std::function error_handler, + std::function accept_handler): + adaptor_(std::move(adaptor)), + open_handler_(std::move(open_handler)), message_handler_(std::move(message_handler)), close_handler_(std::move(close_handler)), error_handler_(std::move(error_handler)), accept_handler_(std::move(accept_handler)) + { + if (!boost::iequals(req.get_header_value("upgrade"), "websocket")) + { + adaptor.close(); + delete this; + return; + } + + if (accept_handler_) + { + if (!accept_handler_(req)) + { + adaptor.close(); + delete this; + return; + } + } + + // Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ== + // Sec-WebSocket-Version: 13 + std::string magic = req.get_header_value("Sec-WebSocket-Key") + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"; + sha1::SHA1 s; + s.processBytes(magic.data(), magic.size()); + uint8_t digest[20]; + s.getDigestBytes(digest); + start(crow::utility::base64encode((unsigned char*)digest, 20)); + } + + /// Send data through the socket. + template + void dispatch(CompletionHandler handler) + { + adaptor_.get_io_service().dispatch(handler); + } + + /// Send data through the socket and return immediately. + template + void post(CompletionHandler handler) + { + adaptor_.get_io_service().post(handler); + } + + /// Send a "Ping" message. + + /// + /// Usually invoked to check if the other point is still online. + void send_ping(const std::string& msg) override + { + dispatch([this, msg] { + auto header = build_header(0x9, msg.size()); + write_buffers_.emplace_back(std::move(header)); + write_buffers_.emplace_back(msg); + do_write(); + }); + } + + /// Send a "Pong" message. + + /// + /// Usually automatically invoked as a response to a "Ping" message. + void send_pong(const std::string& msg) override + { + dispatch([this, msg] { + auto header = build_header(0xA, msg.size()); + write_buffers_.emplace_back(std::move(header)); + write_buffers_.emplace_back(msg); + do_write(); + }); + } + + /// Send a binary encoded message. + void send_binary(const std::string& msg) override + { + dispatch([this, msg] { + auto header = build_header(2, msg.size()); + write_buffers_.emplace_back(std::move(header)); + write_buffers_.emplace_back(msg); + do_write(); + }); + } + + /// Send a plaintext message. + void send_text(const std::string& msg) override + { + dispatch([this, msg] { + auto header = build_header(1, msg.size()); + write_buffers_.emplace_back(std::move(header)); + write_buffers_.emplace_back(msg); + do_write(); + }); + } + + /// Send a close signal. + + /// + /// Sets a flag to destroy the object once the message is sent. + void close(const std::string& msg) override + { + dispatch([this, msg] { + has_sent_close_ = true; + if (has_recv_close_ && !is_close_handler_called_) + { + is_close_handler_called_ = true; + if (close_handler_) + close_handler_(*this, msg); + } + auto header = build_header(0x8, msg.size()); + write_buffers_.emplace_back(std::move(header)); + write_buffers_.emplace_back(msg); + do_write(); + }); + } + + std::string get_remote_ip() override + { + return adaptor_.remote_endpoint().address().to_string(); + } + + protected: + /// Generate the websocket headers using an opcode and the message size (in bytes). + std::string build_header(int opcode, size_t size) + { + char buf[2 + 8] = "\x80\x00"; + buf[0] += opcode; + if (size < 126) + { + buf[1] += static_cast(size); + return {buf, buf + 2}; + } + else if (size < 0x10000) + { + buf[1] += 126; + *(uint16_t*)(buf + 2) = htons(static_cast(size)); + return {buf, buf + 4}; + } + else + { + buf[1] += 127; + *reinterpret_cast(buf + 2) = ((1 == htonl(1)) ? static_cast(size) : (static_cast(htonl((size)&0xFFFFFFFF)) << 32) | htonl(static_cast(size) >> 32)); + return {buf, buf + 10}; + } + } + + /// Send the HTTP upgrade response. + + /// + /// Finishes the handshake process, then starts reading messages from the socket. + void start(std::string&& hello) + { + static std::string header = "HTTP/1.1 101 Switching Protocols\r\n" + "Upgrade: websocket\r\n" + "Connection: Upgrade\r\n" + "Sec-WebSocket-Accept: "; + write_buffers_.emplace_back(header); + write_buffers_.emplace_back(std::move(hello)); + write_buffers_.emplace_back(crlf); + write_buffers_.emplace_back(crlf); + do_write(); + if (open_handler_) + open_handler_(*this); + do_read(); + } + + /// Read a websocket message. + + /// + /// Involves:
+ /// Handling headers (opcodes, size).
+ /// Unmasking the payload.
+ /// Reading the actual payload.
+ void do_read() + { + is_reading = true; + switch (state_) + { + case WebSocketReadState::MiniHeader: + { + mini_header_ = 0; + //boost::asio::async_read(adaptor_.socket(), boost::asio::buffer(&mini_header_, 1), + adaptor_.socket().async_read_some( + boost::asio::buffer(&mini_header_, 2), + [this](const boost::system::error_code& ec, std::size_t +#ifdef CROW_ENABLE_DEBUG + bytes_transferred +#endif + ) + + { + is_reading = false; + mini_header_ = ntohs(mini_header_); +#ifdef CROW_ENABLE_DEBUG + + if (!ec && bytes_transferred != 2) + { + throw std::runtime_error("WebSocket:MiniHeader:async_read fail:asio bug?"); + } +#endif + + if (!ec) + { + if ((mini_header_ & 0x80) == 0x80) + has_mask_ = true; + else //if the websocket specification is enforced and the message isn't masked, terminate the connection + { +#ifndef CROW_ENFORCE_WS_SPEC + has_mask_ = false; +#else + close_connection_ = true; + adaptor_.close(); + if (error_handler_) + error_handler_(*this); + check_destroy(); +#endif + } + + if ((mini_header_ & 0x7f) == 127) + { + state_ = WebSocketReadState::Len64; + } + else if ((mini_header_ & 0x7f) == 126) + { + state_ = WebSocketReadState::Len16; + } + else + { + remaining_length_ = mini_header_ & 0x7f; + state_ = WebSocketReadState::Mask; + } + do_read(); + } + else + { + close_connection_ = true; + adaptor_.close(); + if (error_handler_) + error_handler_(*this); + check_destroy(); + } + }); + } + break; + case WebSocketReadState::Len16: + { + remaining_length_ = 0; + remaining_length16_ = 0; + boost::asio::async_read( + adaptor_.socket(), boost::asio::buffer(&remaining_length16_, 2), + [this](const boost::system::error_code& ec, std::size_t +#ifdef CROW_ENABLE_DEBUG + bytes_transferred +#endif + ) { + is_reading = false; + remaining_length16_ = ntohs(remaining_length16_); + remaining_length_ = remaining_length16_; +#ifdef CROW_ENABLE_DEBUG + if (!ec && bytes_transferred != 2) + { + throw std::runtime_error("WebSocket:Len16:async_read fail:asio bug?"); + } +#endif + + if (!ec) + { + state_ = WebSocketReadState::Mask; + do_read(); + } + else + { + close_connection_ = true; + adaptor_.close(); + if (error_handler_) + error_handler_(*this); + check_destroy(); + } + }); + } + break; + case WebSocketReadState::Len64: + { + boost::asio::async_read( + adaptor_.socket(), boost::asio::buffer(&remaining_length_, 8), + [this](const boost::system::error_code& ec, std::size_t +#ifdef CROW_ENABLE_DEBUG + bytes_transferred +#endif + ) { + is_reading = false; + remaining_length_ = ((1 == ntohl(1)) ? (remaining_length_) : (static_cast(ntohl((remaining_length_)&0xFFFFFFFF)) << 32) | ntohl((remaining_length_) >> 32)); +#ifdef CROW_ENABLE_DEBUG + if (!ec && bytes_transferred != 8) + { + throw std::runtime_error("WebSocket:Len16:async_read fail:asio bug?"); + } +#endif + + if (!ec) + { + state_ = WebSocketReadState::Mask; + do_read(); + } + else + { + close_connection_ = true; + adaptor_.close(); + if (error_handler_) + error_handler_(*this); + check_destroy(); + } + }); + } + break; + case WebSocketReadState::Mask: + if (has_mask_) + { + boost::asio::async_read( + adaptor_.socket(), boost::asio::buffer((char*)&mask_, 4), + [this](const boost::system::error_code& ec, std::size_t +#ifdef CROW_ENABLE_DEBUG + bytes_transferred +#endif + ) { + is_reading = false; +#ifdef CROW_ENABLE_DEBUG + if (!ec && bytes_transferred != 4) + { + throw std::runtime_error("WebSocket:Mask:async_read fail:asio bug?"); + } +#endif + + if (!ec) + { + state_ = WebSocketReadState::Payload; + do_read(); + } + else + { + close_connection_ = true; + if (error_handler_) + error_handler_(*this); + adaptor_.close(); + } + }); + } + else + { + state_ = WebSocketReadState::Payload; + do_read(); + } + break; + case WebSocketReadState::Payload: + { + auto to_read = static_cast(buffer_.size()); + if (remaining_length_ < to_read) + to_read = remaining_length_; + adaptor_.socket().async_read_some( + boost::asio::buffer(buffer_, static_cast(to_read)), + [this](const boost::system::error_code& ec, std::size_t bytes_transferred) { + is_reading = false; + + if (!ec) + { + fragment_.insert(fragment_.end(), buffer_.begin(), buffer_.begin() + bytes_transferred); + remaining_length_ -= bytes_transferred; + if (remaining_length_ == 0) + { + handle_fragment(); + state_ = WebSocketReadState::MiniHeader; + do_read(); + } + else + do_read(); + } + else + { + close_connection_ = true; + if (error_handler_) + error_handler_(*this); + adaptor_.close(); + } + }); + } + break; + } + } + + /// Check if the FIN bit is set. + bool is_FIN() + { + return mini_header_ & 0x8000; + } + + /// Extract the opcode from the header. + int opcode() + { + return (mini_header_ & 0x0f00) >> 8; + } + + /// Process the payload fragment. + + /// + /// Unmasks the fragment, checks the opcode, merges fragments into 1 message body, and calls the appropriate handler. + void handle_fragment() + { + if (has_mask_) + { + for (decltype(fragment_.length()) i = 0; i < fragment_.length(); i++) + { + fragment_[i] ^= ((char*)&mask_)[i % 4]; + } + } + switch (opcode()) + { + case 0: // Continuation + { + message_ += fragment_; + if (is_FIN()) + { + if (message_handler_) + message_handler_(*this, message_, is_binary_); + message_.clear(); + } + } + break; + case 1: // Text + { + is_binary_ = false; + message_ += fragment_; + if (is_FIN()) + { + if (message_handler_) + message_handler_(*this, message_, is_binary_); + message_.clear(); + } + } + break; + case 2: // Binary + { + is_binary_ = true; + message_ += fragment_; + if (is_FIN()) + { + if (message_handler_) + message_handler_(*this, message_, is_binary_); + message_.clear(); + } + } + break; + case 0x8: // Close + { + has_recv_close_ = true; + if (!has_sent_close_) + { + close(fragment_); + } + else + { + adaptor_.close(); + close_connection_ = true; + if (!is_close_handler_called_) + { + if (close_handler_) + close_handler_(*this, fragment_); + is_close_handler_called_ = true; + } + check_destroy(); + } + } + break; + case 0x9: // Ping + { + send_pong(fragment_); + } + break; + case 0xA: // Pong + { + pong_received_ = true; + } + break; + } + + fragment_.clear(); + } + + /// Send the buffers' data through the socket. + + /// + /// Also destroyes the object if the Close flag is set. + void do_write() + { + if (sending_buffers_.empty()) + { + sending_buffers_.swap(write_buffers_); + std::vector buffers; + buffers.reserve(sending_buffers_.size()); + for (auto& s : sending_buffers_) + { + buffers.emplace_back(boost::asio::buffer(s)); + } + boost::asio::async_write( + adaptor_.socket(), buffers, + [&](const boost::system::error_code& ec, std::size_t /*bytes_transferred*/) { + sending_buffers_.clear(); + if (!ec && !close_connection_) + { + if (!write_buffers_.empty()) + do_write(); + if (has_sent_close_) + close_connection_ = true; + } + else + { + close_connection_ = true; + check_destroy(); + } + }); + } + } + + /// Destroy the Connection. + void check_destroy() + { + //if (has_sent_close_ && has_recv_close_) + if (!is_close_handler_called_) + if (close_handler_) + close_handler_(*this, "uncleanly"); + if (sending_buffers_.empty() && !is_reading) + delete this; + } + + private: + Adaptor adaptor_; + + std::vector sending_buffers_; + std::vector write_buffers_; + + boost::array buffer_; + bool is_binary_; + std::string message_; + std::string fragment_; + WebSocketReadState state_{WebSocketReadState::MiniHeader}; + uint16_t remaining_length16_{0}; + uint64_t remaining_length_{0}; + bool close_connection_{false}; + bool is_reading{false}; + bool has_mask_{false}; + uint32_t mask_; + uint16_t mini_header_; + bool has_sent_close_{false}; + bool has_recv_close_{false}; + bool error_occured_{false}; + bool pong_received_{false}; + bool is_close_handler_called_{false}; + + std::function open_handler_; + std::function message_handler_; + std::function close_handler_; + std::function error_handler_; + std::function accept_handler_; + }; + } // namespace websocket +} // namespace crow + + + +/* merged revision: 5b951d74bd66ec9d38448e0a85b1cf8b85d97db3 */ +/* updated to : e13b274770da9b82a1085dec29182acfea72e7a7 (beyond v2.9.5) */ +/* commits not included: + * 091ebb87783a58b249062540bbea07de2a11e9cf + * 6132d1fefa03f769a3979355d1f5da0b8889cad2 + * 7ba312397c2a6c851a4b5efe6c1603b1e1bda6ff + * d7675453a6c03180572f084e95eea0d02df39164 + * dff604db203986e532e5a679bafd0e7382c6bdd9 (Might be useful to actually add [upgrade requests with a body]) + * e01811e7f4894d7f0f7f4bd8492cccec6f6b4038 (related to above) + * 05525c5fde1fc562481f6ae08fa7056185325daf (also related to above) + * 350258965909f249f9c59823aac240313e0d0120 (cannot be implemented due to upgrade) + */ + +// clang-format off +#pragma once + + +namespace crow +{ +extern "C" { + +#include +#if defined(_WIN32) && !defined(__MINGW32__) && \ + (!defined(_MSC_VER) || _MSC_VER<1600) && !defined(__WINE__) +#include +typedef __int8 int8_t; +typedef unsigned __int8 uint8_t; +typedef __int16 int16_t; +typedef unsigned __int16 uint16_t; +typedef __int32 int32_t; +typedef unsigned __int32 uint32_t; +typedef __int64 int64_t; +typedef unsigned __int64 uint64_t; +#elif (defined(__sun) || defined(__sun__)) && defined(__SunOS_5_9) +#include +#else +#include +#endif + + + +/* Maximium header size allowed. If the macro is not defined + * before including this header then the default is used. To + * change the maximum header size, define the macro in the build + * environment (e.g. -DHTTP_MAX_HEADER_SIZE=). To remove + * the effective limit on the size of the header, define the macro + * to a very large number (e.g. -DCROW_HTTP_MAX_HEADER_SIZE=0x7fffffff) + */ +#ifndef CROW_HTTP_MAX_HEADER_SIZE +# define CROW_HTTP_MAX_HEADER_SIZE (80*1024) +#endif + +typedef struct http_parser http_parser; +typedef struct http_parser_settings http_parser_settings; + +/* Callbacks should return non-zero to indicate an error. The parser will + * then halt execution. + * + * The one exception is on_headers_complete. In a HTTP_RESPONSE parser + * returning '1' from on_headers_complete will tell the parser that it + * should not expect a body. This is used when receiving a response to a + * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding: + * chunked' headers that indicate the presence of a body. + * + * Returning `2` from on_headers_complete will tell parser that it should not + * expect neither a body nor any futher responses on this connection. This is + * useful for handling responses to a CONNECT request which may not contain + * `Upgrade` or `Connection: upgrade` headers. + * + * http_data_cb does not return data chunks. It will be called arbitrarally + * many times for each string. E.G. you might get 10 callbacks for "on_url" + * each providing just a few characters more data. + */ +typedef int (*http_data_cb) (http_parser*, const char *at, size_t length); +typedef int (*http_cb) (http_parser*); + + +/* Flag values for http_parser.flags field */ +enum http_connection_flags // This is basically 7 booleans placed into 1 integer. Uses 4 bytes instead of n bytes (7 currently). + { F_CHUNKED = 1 << 0 // 00000000 00000000 00000000 00000001 + , F_CONNECTION_KEEP_ALIVE = 1 << 1 // 00000000 00000000 00000000 00000010 + , F_CONNECTION_CLOSE = 1 << 2 // 00000000 00000000 00000000 00000100 + , F_TRAILING = 1 << 3 // 00000000 00000000 00000000 00001000 + , F_UPGRADE = 1 << 4 // 00000000 00000000 00000000 00010000 + , F_SKIPBODY = 1 << 5 // 00000000 00000000 00000000 00100000 + , F_CONTENTLENGTH = 1 << 6 // 00000000 00000000 00000000 01000000 + }; + + +/* Map for errno-related constants + * + * The provided argument should be a macro that takes 2 arguments. + */ +#define CROW_HTTP_ERRNO_MAP(CROW_XX) \ + /* No error */ \ + CROW_XX(OK, "success") \ + \ + /* Callback-related errors */ \ + CROW_XX(CB_message_begin, "the on_message_begin callback failed") \ + CROW_XX(CB_url, "the \"on_url\" callback failed") \ + CROW_XX(CB_header_field, "the \"on_header_field\" callback failed") \ + CROW_XX(CB_header_value, "the \"on_header_value\" callback failed") \ + CROW_XX(CB_headers_complete, "the \"on_headers_complete\" callback failed") \ + CROW_XX(CB_body, "the \"on_body\" callback failed") \ + CROW_XX(CB_message_complete, "the \"on_message_complete\" callback failed") \ + CROW_XX(CB_status, "the \"on_status\" callback failed") \ + \ + /* Parsing-related errors */ \ + CROW_XX(INVALID_EOF_STATE, "stream ended at an unexpected time") \ + CROW_XX(HEADER_OVERFLOW, "too many header bytes seen; overflow detected") \ + CROW_XX(CLOSED_CONNECTION, "data received after completed connection: close message") \ + CROW_XX(INVALID_VERSION, "invalid HTTP version") \ + CROW_XX(INVALID_STATUS, "invalid HTTP status code") \ + CROW_XX(INVALID_METHOD, "invalid HTTP method") \ + CROW_XX(INVALID_URL, "invalid URL") \ + CROW_XX(INVALID_HOST, "invalid host") \ + CROW_XX(INVALID_PORT, "invalid port") \ + CROW_XX(INVALID_PATH, "invalid path") \ + CROW_XX(INVALID_QUERY_STRING, "invalid query string") \ + CROW_XX(INVALID_FRAGMENT, "invalid fragment") \ + CROW_XX(LF_EXPECTED, "LF character expected") \ + CROW_XX(INVALID_HEADER_TOKEN, "invalid character in header") \ + CROW_XX(INVALID_CONTENT_LENGTH, "invalid character in content-length header") \ + CROW_XX(UNEXPECTED_CONTENT_LENGTH, "unexpected content-length header") \ + CROW_XX(INVALID_CHUNK_SIZE, "invalid character in chunk size header") \ + CROW_XX(INVALID_CONSTANT, "invalid constant string") \ + CROW_XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state") \ + CROW_XX(STRICT, "strict mode assertion failed") \ + CROW_XX(UNKNOWN, "an unknown error occurred") \ + CROW_XX(INVALID_TRANSFER_ENCODING, "request has invalid transfer-encoding") \ + + +/* Define CHPE_* values for each errno value above */ +#define CROW_HTTP_ERRNO_GEN(n, s) CHPE_##n, +enum http_errno { + CROW_HTTP_ERRNO_MAP(CROW_HTTP_ERRNO_GEN) +}; +#undef CROW_HTTP_ERRNO_GEN + + +/* Get an http_errno value from an http_parser */ +#define CROW_HTTP_PARSER_ERRNO(p) ((enum http_errno)(p)->http_errno) + + + struct http_parser + { + /** PRIVATE **/ + unsigned int flags : 7; /* F_* values from 'flags' enum; semi-public */ + unsigned int state : 8; /* enum state from http_parser.c */ + unsigned int header_state : 7; /* enum header_state from http_parser.c */ + unsigned int index : 5; /* index into current matcher */ + unsigned int uses_transfer_encoding : 1; /* Transfer-Encoding header is present */ + unsigned int allow_chunked_length : 1; /* Allow headers with both `Content-Length` and `Transfer-Encoding: chunked` set */ + unsigned int lenient_http_headers : 1; + + uint32_t nread; /* # bytes read in various scenarios */ + uint64_t content_length; /* # bytes in body. `(uint64_t) -1` (all bits one) if no Content-Length header. */ + unsigned long qs_point; + + /** READ-ONLY **/ + unsigned char http_major; + unsigned char http_minor; + unsigned int method : 8; /* requests only */ + unsigned int http_errno : 7; + + /* 1 = Upgrade header was present and the parser has exited because of that. + * 0 = No upgrade header present. + * Should be checked when http_parser_execute() returns in addition to + * error checking. + */ + unsigned int upgrade : 1; + + /** PUBLIC **/ + void* data; /* A pointer to get hook to the "connection" or "socket" object */ + }; + + + struct http_parser_settings + { + http_cb on_message_begin; + http_data_cb on_url; + http_data_cb on_header_field; + http_data_cb on_header_value; + http_cb on_headers_complete; + http_data_cb on_body; + http_cb on_message_complete; + }; + + + +// SOURCE (.c) CODE +#include +#include +#include +#include +#include + +static uint32_t max_header_size = CROW_HTTP_MAX_HEADER_SIZE; + +#ifndef CROW_ULLONG_MAX +# define CROW_ULLONG_MAX ((uint64_t) -1) /* 2^64-1 */ +#endif + +#ifndef CROW_MIN +# define CROW_MIN(a,b) ((a) < (b) ? (a) : (b)) +#endif + +#ifndef CROW_ARRAY_SIZE +# define CROW_ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) +#endif + +#ifndef CROW_BIT_AT +# define CROW_BIT_AT(a, i) \ + (!!((unsigned int) (a)[(unsigned int) (i) >> 3] & \ + (1 << ((unsigned int) (i) & 7)))) +#endif + +#define CROW_SET_ERRNO(e) \ +do { \ + parser->nread = nread; \ + parser->http_errno = (e); \ +} while(0) + +/* Run the notify callback FOR, returning ER if it fails */ +#define CROW_CALLBACK_NOTIFY_(FOR, ER) \ +do { \ + assert(CROW_HTTP_PARSER_ERRNO(parser) == CHPE_OK); \ + \ + if (CROW_LIKELY(settings->on_##FOR)) { \ + if (CROW_UNLIKELY(0 != settings->on_##FOR(parser))) { \ + CROW_SET_ERRNO(CHPE_CB_##FOR); \ + } \ + \ + /* We either errored above or got paused; get out */ \ + if (CROW_UNLIKELY(CROW_HTTP_PARSER_ERRNO(parser) != CHPE_OK)) { \ + return (ER); \ + } \ + } \ +} while (0) + +/* Run the notify callback FOR and consume the current byte */ +#define CROW_CALLBACK_NOTIFY(FOR) CROW_CALLBACK_NOTIFY_(FOR, p - data + 1) + +/* Run the notify callback FOR and don't consume the current byte */ +#define CROW_CALLBACK_NOTIFY_NOADVANCE(FOR) CROW_CALLBACK_NOTIFY_(FOR, p - data) + +/* Run data callback FOR with LEN bytes, returning ER if it fails */ +#define CROW_CALLBACK_DATA_(FOR, LEN, ER) \ +do { \ + assert(CROW_HTTP_PARSER_ERRNO(parser) == CHPE_OK); \ + \ + if (FOR##_mark) { \ + if (CROW_LIKELY(settings->on_##FOR)) { \ + if (CROW_UNLIKELY(0 != \ + settings->on_##FOR(parser, FOR##_mark, (LEN)))) { \ + CROW_SET_ERRNO(CHPE_CB_##FOR); \ + } \ + \ + /* We either errored above or got paused; get out */ \ + if (CROW_UNLIKELY(CROW_HTTP_PARSER_ERRNO(parser) != CHPE_OK)) {\ + return (ER); \ + } \ + } \ + FOR##_mark = NULL; \ + } \ +} while (0) + +/* Run the data callback FOR and consume the current byte */ +#define CROW_CALLBACK_DATA(FOR) \ + CROW_CALLBACK_DATA_(FOR, p - FOR##_mark, p - data + 1) + +/* Run the data callback FOR and don't consume the current byte */ +#define CROW_CALLBACK_DATA_NOADVANCE(FOR) \ + CROW_CALLBACK_DATA_(FOR, p - FOR##_mark, p - data) + +/* Set the mark FOR; non-destructive if mark is already set */ +#define CROW_MARK(FOR) \ +do { \ + if (!FOR##_mark) { \ + FOR##_mark = p; \ + } \ +} while (0) + +/* Don't allow the total size of the HTTP headers (including the status + * line) to exceed max_header_size. This check is here to protect + * embedders against denial-of-service attacks where the attacker feeds + * us a never-ending header that the embedder keeps buffering. + * + * This check is arguably the responsibility of embedders but we're doing + * it on the embedder's behalf because most won't bother and this way we + * make the web a little safer. max_header_size is still far bigger + * than any reasonable request or response so this should never affect + * day-to-day operation. + */ +#define CROW_COUNT_HEADER_SIZE(V) \ +do { \ + nread += (uint32_t)(V); \ + if (CROW_UNLIKELY(nread > max_header_size)) { \ + CROW_SET_ERRNO(CHPE_HEADER_OVERFLOW); \ + goto error; \ + } \ +} while (0) +#define CROW_REEXECUTE() \ + goto reexecute; \ + +#define CROW_PROXY_CONNECTION "proxy-connection" +#define CROW_CONNECTION "connection" +#define CROW_CONTENT_LENGTH "content-length" +#define CROW_TRANSFER_ENCODING "transfer-encoding" +#define CROW_UPGRADE "upgrade" +#define CROW_CHUNKED "chunked" +#define CROW_KEEP_ALIVE "keep-alive" +#define CROW_CLOSE "close" + + + + enum state + { + s_dead = 1 /* important that this is > 0 */ + + , + s_start_req + + , + s_req_method, + s_req_spaces_before_url, + s_req_schema, + s_req_schema_slash, + s_req_schema_slash_slash, + s_req_server_start, + s_req_server, // } + s_req_server_with_at, // | + s_req_path, // | The parser recognizes how to switch between these states, + s_req_query_string_start, // | however it doesn't process them any differently. + s_req_query_string, // } + s_req_http_start, + s_req_http_H, + s_req_http_HT, + s_req_http_HTT, + s_req_http_HTTP, + s_req_http_I, + s_req_http_IC, + s_req_http_major, + s_req_http_dot, + s_req_http_minor, + s_req_http_end, + s_req_line_almost_done + + , + s_header_field_start, + s_header_field, + s_header_value_discard_ws, + s_header_value_discard_ws_almost_done, + s_header_value_discard_lws, + s_header_value_start, + s_header_value, + s_header_value_lws + + , + s_header_almost_done + + , + s_chunk_size_start, + s_chunk_size, + s_chunk_parameters, + s_chunk_size_almost_done + + , + s_headers_almost_done, + s_headers_done + + /* Important: 's_headers_done' must be the last 'header' state. All + * states beyond this must be 'body' states. It is used for overflow + * checking. See the CROW_PARSING_HEADER() macro. + */ + + , + s_chunk_data, + s_chunk_data_almost_done, + s_chunk_data_done + + , + s_body_identity, + s_body_identity_eof + + , + s_message_done + }; + + +#define CROW_PARSING_HEADER(state) (state <= s_headers_done) + + +enum header_states + { h_general = 0 + , h_C + , h_CO + , h_CON + + , h_matching_connection + , h_matching_proxy_connection + , h_matching_content_length + , h_matching_transfer_encoding + , h_matching_upgrade + + , h_connection + , h_content_length + , h_content_length_num + , h_content_length_ws + , h_transfer_encoding + , h_upgrade + + , h_matching_transfer_encoding_token_start + , h_matching_transfer_encoding_chunked + , h_matching_transfer_encoding_token + + , h_matching_connection_keep_alive + , h_matching_connection_close + + , h_transfer_encoding_chunked + , h_connection_keep_alive + , h_connection_close + }; + +enum http_host_state + { + s_http_host_dead = 1 + , s_http_userinfo_start + , s_http_userinfo + , s_http_host_start + , s_http_host_v6_start + , s_http_host + , s_http_host_v6 + , s_http_host_v6_end + , s_http_host_v6_zone_start + , s_http_host_v6_zone + , s_http_host_port_start + , s_http_host_port +}; + +/* Macros for character classes; depends on strict-mode */ +#define CROW_LOWER(c) (unsigned char)(c | 0x20) +#define CROW_IS_ALPHA(c) (CROW_LOWER(c) >= 'a' && CROW_LOWER(c) <= 'z') +#define CROW_IS_NUM(c) ((c) >= '0' && (c) <= '9') +#define CROW_IS_ALPHANUM(c) (CROW_IS_ALPHA(c) || CROW_IS_NUM(c)) +//#define CROW_IS_HEX(c) (CROW_IS_NUM(c) || (CROW_LOWER(c) >= 'a' && CROW_LOWER(c) <= 'f')) +#define CROW_IS_MARK(c) ((c) == '-' || (c) == '_' || (c) == '.' || \ + (c) == '!' || (c) == '~' || (c) == '*' || (c) == '\'' || (c) == '(' || \ + (c) == ')') +#define CROW_IS_USERINFO_CHAR(c) (CROW_IS_ALPHANUM(c) || CROW_IS_MARK(c) || (c) == '%' || \ + (c) == ';' || (c) == ':' || (c) == '&' || (c) == '=' || (c) == '+' || \ + (c) == '$' || (c) == ',') + +#define CROW_TOKEN(c) (tokens[(unsigned char)c]) +#define CROW_IS_URL_CHAR(c) (CROW_BIT_AT(normal_url_char, (unsigned char)c)) +//#define CROW_IS_HOST_CHAR(c) (CROW_IS_ALPHANUM(c) || (c) == '.' || (c) == '-') + + /** + * Verify that a char is a valid visible (printable) US-ASCII + * character or %x80-FF + **/ +#define CROW_IS_HEADER_CHAR(ch) \ + (ch == cr || ch == lf || ch == 9 || ((unsigned char)ch > 31 && ch != 127)) + +#define CROW_start_state s_start_req + +# define CROW_STRICT_CHECK(cond) \ +do { \ + if (cond) { \ + CROW_SET_ERRNO(CHPE_STRICT); \ + goto error; \ + } \ +} while (0) +#define CROW_NEW_MESSAGE() (CROW_start_state) + +/* Our URL parser. + * + * This is designed to be shared by http_parser_execute() for URL validation, + * hence it has a state transition + byte-for-byte interface. In addition, it + * is meant to be embedded in http_parser_parse_url(), which does the dirty + * work of turning state transitions URL components for its API. + * + * This function should only be invoked with non-space characters. It is + * assumed that the caller cares about (and can detect) the transition between + * URL and non-URL states by looking for these. + */ +inline enum state +parse_url_char(enum state s, const char ch, http_parser *parser, const char* url_mark, const char* p) +{ +# define CROW_T(v) 0 + + +static const uint8_t normal_url_char[32] = { +/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ + 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, +/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ + 0 |CROW_T(2)| 0 | 0 |CROW_T(16)| 0 | 0 | 0, +/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ + 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, +/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ + 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0, +/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ + 0 | 2 | 4 | 0 | 16 | 32 | 64 | 128, +/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, +/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 80 P 81 Q 82 R 83 S 84 CROW_T 85 U 86 V 87 W */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128, +/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ + 1 | 2 | 4 | 8 | 16 | 32 | 64 | 0, }; + +#undef CROW_T + + if (ch == ' ' || ch == '\r' || ch == '\n') { + return s_dead; + } + if (ch == '\t' || ch == '\f') { + return s_dead; + } + + switch (s) { + case s_req_spaces_before_url: + /* Proxied requests are followed by scheme of an absolute URI (alpha). + * All methods except CONNECT are followed by '/' or '*'. + */ + + if (ch == '/' || ch == '*') { + return s_req_path; + } + + if (CROW_IS_ALPHA(ch)) { + return s_req_schema; + } + + break; + + case s_req_schema: + if (CROW_IS_ALPHA(ch)) { + return s; + } + + if (ch == ':') { + return s_req_schema_slash; + } + + break; + + case s_req_schema_slash: + if (ch == '/') { + return s_req_schema_slash_slash; + } + + break; + + case s_req_schema_slash_slash: + if (ch == '/') { + return s_req_server_start; + } + + break; + + case s_req_server_with_at: + if (ch == '@') { + return s_dead; + } + + /* fall through */ + case s_req_server_start: + case s_req_server: + if (ch == '/') { + return s_req_path; + } + + if (ch == '?') { + parser->qs_point = p - url_mark; + return s_req_query_string_start; + } + + if (ch == '@') { + return s_req_server_with_at; + } + + if (CROW_IS_USERINFO_CHAR(ch) || ch == '[' || ch == ']') { + return s_req_server; + } + + break; + + case s_req_path: + if (CROW_IS_URL_CHAR(ch)) { + return s; + } + else if (ch == '?') + { + parser->qs_point = p - url_mark; + return s_req_query_string_start; + } + + break; + + case s_req_query_string_start: + case s_req_query_string: + if (CROW_IS_URL_CHAR(ch)) { + return s_req_query_string; + } + else if (ch == '?') + { + return s_req_query_string; + } + + break; + + default: + break; + } + + /* We should never fall out of the switch above unless there's an error */ + return s_dead; +} + +inline size_t http_parser_execute (http_parser *parser, + const http_parser_settings *settings, + const char *data, + size_t len) +{ + +/* Tokens as defined by rfc 2616. Also lowercases them. + * token = 1* + * separators = "(" | ")" | "<" | ">" | "@" + * | "," | ";" | ":" | "\" | <"> + * | "/" | "[" | "]" | "?" | "=" + * | "{" | "}" | SP | HT + */ +static const char tokens[256] = { +/* 0 nul 1 soh 2 stx 3 etx 4 eot 5 enq 6 ack 7 bel */ + 0, 0, 0, 0, 0, 0, 0, 0, +/* 8 bs 9 ht 10 nl 11 vt 12 np 13 cr 14 so 15 si */ + 0, 0, 0, 0, 0, 0, 0, 0, +/* 16 dle 17 dc1 18 dc2 19 dc3 20 dc4 21 nak 22 syn 23 etb */ + 0, 0, 0, 0, 0, 0, 0, 0, +/* 24 can 25 em 26 sub 27 esc 28 fs 29 gs 30 rs 31 us */ + 0, 0, 0, 0, 0, 0, 0, 0, +/* 32 sp 33 ! 34 " 35 # 36 $ 37 % 38 & 39 ' */ + 0, '!', 0, '#', '$', '%', '&', '\'', +/* 40 ( 41 ) 42 * 43 + 44 , 45 - 46 . 47 / */ + 0, 0, '*', '+', 0, '-', '.', 0, +/* 48 0 49 1 50 2 51 3 52 4 53 5 54 6 55 7 */ + '0', '1', '2', '3', '4', '5', '6', '7', +/* 56 8 57 9 58 : 59 ; 60 < 61 = 62 > 63 ? */ + '8', '9', 0, 0, 0, 0, 0, 0, +/* 64 @ 65 A 66 B 67 C 68 D 69 E 70 F 71 G */ + 0, 'a', 'b', 'c', 'd', 'e', 'f', 'g', +/* 72 H 73 I 74 J 75 K 76 L 77 M 78 N 79 O */ + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', +/* 80 P 81 Q 82 R 83 S 84 T 85 U 86 V 87 W */ + 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', +/* 88 X 89 Y 90 Z 91 [ 92 \ 93 ] 94 ^ 95 _ */ + 'x', 'y', 'z', 0, 0, 0, '^', '_', +/* 96 ` 97 a 98 b 99 c 100 d 101 e 102 f 103 g */ + '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', +/* 104 h 105 i 106 j 107 k 108 l 109 m 110 n 111 o */ + 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', +/* 112 p 113 q 114 r 115 s 116 t 117 u 118 v 119 w */ + 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', +/* 120 x 121 y 122 z 123 { 124 | 125 } 126 ~ 127 del */ + 'x', 'y', 'z', 0, '|', 0, '~', 0 }; + + +static const int8_t unhex[256] = + {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 + ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 + ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 + , 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1 + ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 + ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 + ,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1 + ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 + }; + + + + char c, ch; + int8_t unhex_val; + const char *p = data; + const char *header_field_mark = 0; + const char *header_value_mark = 0; + const char *url_mark = 0; + const char *url_start_mark = 0; + const char *body_mark = 0; + const unsigned int lenient = parser->lenient_http_headers; + const unsigned int allow_chunked_length = parser->allow_chunked_length; + + uint32_t nread = parser->nread; + + /* We're in an error state. Don't bother doing anything. */ + if (CROW_HTTP_PARSER_ERRNO(parser) != CHPE_OK) { + return 0; + } + + if (len == 0) { + switch (parser->state) { + case s_body_identity_eof: + /* Use of CROW_CALLBACK_NOTIFY() here would erroneously return 1 byte read if we got paused. */ + CROW_CALLBACK_NOTIFY_NOADVANCE(message_complete); + return 0; + + case s_dead: + case s_start_req: + return 0; + + default: + CROW_SET_ERRNO(CHPE_INVALID_EOF_STATE); + return 1; + } + } + + + if (parser->state == s_header_field) + header_field_mark = data; + if (parser->state == s_header_value) + header_value_mark = data; + switch (parser->state) { + case s_req_path: + case s_req_schema: + case s_req_schema_slash: + case s_req_schema_slash_slash: + case s_req_server_start: + case s_req_server: + case s_req_server_with_at: + case s_req_query_string_start: + case s_req_query_string: + url_mark = data; + break; + default: + break; + } + + for (p=data; p != data + len; p++) { + ch = *p; + + if (CROW_PARSING_HEADER(parser->state)) + CROW_COUNT_HEADER_SIZE(1); + +reexecute: + switch (parser->state) { + + case s_dead: + /* this state is used after a 'Connection: close' message + * the parser will error out if it reads another message + */ + if (CROW_LIKELY(ch == cr || ch == lf)) + break; + + CROW_SET_ERRNO(CHPE_CLOSED_CONNECTION); + goto error; + + case s_start_req: + { + if (ch == cr || ch == lf) + break; + parser->flags = 0; + parser->uses_transfer_encoding = 0; + parser->content_length = CROW_ULLONG_MAX; + + if (CROW_UNLIKELY(!CROW_IS_ALPHA(ch))) { + CROW_SET_ERRNO(CHPE_INVALID_METHOD); + goto error; + } + + parser->method = 0; + parser->index = 1; + switch (ch) { + case 'A': parser->method = (unsigned)HTTPMethod::Acl; break; + case 'B': parser->method = (unsigned)HTTPMethod::Bind; break; + case 'C': parser->method = (unsigned)HTTPMethod::Connect; /* or COPY, CHECKOUT */ break; + case 'D': parser->method = (unsigned)HTTPMethod::Delete; break; + case 'G': parser->method = (unsigned)HTTPMethod::Get; break; + case 'H': parser->method = (unsigned)HTTPMethod::Head; break; + case 'L': parser->method = (unsigned)HTTPMethod::Lock; /* or LINK */ break; + case 'M': parser->method = (unsigned)HTTPMethod::MkCol; /* or MOVE, MKACTIVITY, MERGE, M-SEARCH, MKCALENDAR */ break; + case 'N': parser->method = (unsigned)HTTPMethod::Notify; break; + case 'O': parser->method = (unsigned)HTTPMethod::Options; break; + case 'P': parser->method = (unsigned)HTTPMethod::Post; /* or PROPFIND|PROPPATCH|PUT|PATCH|PURGE */ break; + case 'R': parser->method = (unsigned)HTTPMethod::Report; /* or REBIND */ break; + case 'S': parser->method = (unsigned)HTTPMethod::Subscribe; /* or SEARCH, SOURCE */ break; + case 'T': parser->method = (unsigned)HTTPMethod::Trace; break; + case 'U': parser->method = (unsigned)HTTPMethod::Unlock; /* or UNSUBSCRIBE, UNBIND, UNLINK */ break; + default: + CROW_SET_ERRNO(CHPE_INVALID_METHOD); + goto error; + } + parser->state = s_req_method; + + CROW_CALLBACK_NOTIFY(message_begin); + + break; + } + + case s_req_method: + { + const char *matcher; + if (CROW_UNLIKELY(ch == '\0')) { + CROW_SET_ERRNO(CHPE_INVALID_METHOD); + goto error; + } + + matcher = method_strings[parser->method]; + if (ch == ' ' && matcher[parser->index] == '\0') { + parser->state = s_req_spaces_before_url; + } else if (ch == matcher[parser->index]) { + ; /* nada */ + } else if ((ch >= 'A' && ch <= 'Z') || ch == '-') { + + switch (parser->method << 16 | parser->index << 8 | ch) { +#define CROW_XX(meth, pos, ch, new_meth) \ + case ((unsigned)HTTPMethod::meth << 16 | pos << 8 | ch): \ + parser->method = (unsigned)HTTPMethod::new_meth; break; + + CROW_XX(Post, 1, 'U', Put) + CROW_XX(Post, 1, 'A', Patch) + CROW_XX(Post, 1, 'R', Propfind) + CROW_XX(Put, 2, 'R', Purge) + CROW_XX(Connect, 1, 'H', Checkout) + CROW_XX(Connect, 2, 'P', Copy) + CROW_XX(MkCol, 1, 'O', Move) + CROW_XX(MkCol, 1, 'E', Merge) + CROW_XX(MkCol, 1, '-', MSearch) + CROW_XX(MkCol, 2, 'A', MkActivity) + CROW_XX(MkCol, 3, 'A', MkCalendar) + CROW_XX(Subscribe, 1, 'E', Search) + CROW_XX(Subscribe, 1, 'O', Source) + CROW_XX(Report, 2, 'B', Rebind) + CROW_XX(Propfind, 4, 'P', Proppatch) + CROW_XX(Lock, 1, 'I', Link) + CROW_XX(Unlock, 2, 'S', Unsubscribe) + CROW_XX(Unlock, 2, 'B', Unbind) + CROW_XX(Unlock, 3, 'I', Unlink) +#undef CROW_XX + default: + CROW_SET_ERRNO(CHPE_INVALID_METHOD); + goto error; + } + } else { + CROW_SET_ERRNO(CHPE_INVALID_METHOD); + goto error; + } + + ++parser->index; + break; + } + + case s_req_spaces_before_url: + { + if (ch == ' ') break; + + CROW_MARK(url); + CROW_MARK(url_start); + if (parser->method == (unsigned)HTTPMethod::Connect) { + parser->state = s_req_server_start; + } + + parser->state = parse_url_char(static_cast(parser->state), ch, parser, url_start_mark, p); + if (CROW_UNLIKELY(parser->state == s_dead)) { + CROW_SET_ERRNO(CHPE_INVALID_URL); + goto error; + } + + break; + } + + case s_req_schema: + case s_req_schema_slash: + case s_req_schema_slash_slash: + case s_req_server_start: + { + switch (ch) { + /* No whitespace allowed here */ + case ' ': + case cr: + case lf: + CROW_SET_ERRNO(CHPE_INVALID_URL); + goto error; + default: + parser->state = parse_url_char(static_cast(parser->state), ch, parser, url_start_mark, p); + if (CROW_UNLIKELY(parser->state == s_dead)) { + CROW_SET_ERRNO(CHPE_INVALID_URL); + goto error; + } + } + + break; + } + + case s_req_server: + case s_req_server_with_at: + case s_req_path: + case s_req_query_string_start: + case s_req_query_string: + { + switch (ch) { + case ' ': + parser->state = s_req_http_start; + CROW_CALLBACK_DATA(url); + break; + case cr: // No space after URL means no HTTP version. Which means the request is using HTTP/0.9 + case lf: + if (CROW_UNLIKELY(parser->method != (unsigned)HTTPMethod::Get)) // HTTP/0.9 doesn't define any method other than GET + { + parser->state = s_dead; + CROW_SET_ERRNO(CHPE_INVALID_VERSION); + goto error; + } + parser->http_major = 0; + parser->http_minor = 9; + parser->state = (ch == cr) ? + s_req_line_almost_done : + s_header_field_start; + CROW_CALLBACK_DATA(url); + break; + default: + parser->state = parse_url_char(static_cast(parser->state), ch, parser, url_start_mark, p); + if (CROW_UNLIKELY(parser->state == s_dead)) { + CROW_SET_ERRNO(CHPE_INVALID_URL); + goto error; + } + } + break; + } + + case s_req_http_start: + switch (ch) { + case ' ': + break; + case 'H': + parser->state = s_req_http_H; + break; + case 'I': + if (parser->method == (unsigned)HTTPMethod::Source) { + parser->state = s_req_http_I; + break; + } + /* fall through */ + default: + CROW_SET_ERRNO(CHPE_INVALID_CONSTANT); + goto error; + } + break; + + case s_req_http_H: + CROW_STRICT_CHECK(ch != 'T'); + parser->state = s_req_http_HT; + break; + + case s_req_http_HT: + CROW_STRICT_CHECK(ch != 'T'); + parser->state = s_req_http_HTT; + break; + + case s_req_http_HTT: + CROW_STRICT_CHECK(ch != 'P'); + parser->state = s_req_http_HTTP; + break; + + case s_req_http_I: + CROW_STRICT_CHECK(ch != 'C'); + parser->state = s_req_http_IC; + break; + + case s_req_http_IC: + CROW_STRICT_CHECK(ch != 'E'); + parser->state = s_req_http_HTTP; /* Treat "ICE" as "HTTP". */ + break; + + case s_req_http_HTTP: + CROW_STRICT_CHECK(ch != '/'); + parser->state = s_req_http_major; + break; + + /* dot */ + case s_req_http_major: + if (CROW_UNLIKELY(!CROW_IS_NUM(ch))) { + CROW_SET_ERRNO(CHPE_INVALID_VERSION); + goto error; + } + + parser->http_major = ch - '0'; + parser->state = s_req_http_dot; + break; + + case s_req_http_dot: + { + if (CROW_UNLIKELY(ch != '.')) { + CROW_SET_ERRNO(CHPE_INVALID_VERSION); + goto error; + } + + parser->state = s_req_http_minor; + break; + } + + /* minor HTTP version */ + case s_req_http_minor: + if (CROW_UNLIKELY(!CROW_IS_NUM(ch))) { + CROW_SET_ERRNO(CHPE_INVALID_VERSION); + goto error; + } + + parser->http_minor = ch - '0'; + parser->state = s_req_http_end; + break; + + /* end of request line */ + case s_req_http_end: + { + if (ch == cr) { + parser->state = s_req_line_almost_done; + break; + } + + if (ch == lf) { + parser->state = s_header_field_start; + break; + } + + CROW_SET_ERRNO(CHPE_INVALID_VERSION); + goto error; + break; + } + + /* end of request line */ + case s_req_line_almost_done: + { + if (CROW_UNLIKELY(ch != lf)) { + CROW_SET_ERRNO(CHPE_LF_EXPECTED); + goto error; + } + + parser->state = s_header_field_start; + break; + } + + case s_header_field_start: + { + if (ch == cr) { + parser->state = s_headers_almost_done; + break; + } + + if (ch == lf) { + /* they might be just sending \n instead of \r\n so this would be + * the second \n to denote the end of headers*/ + parser->state = s_headers_almost_done; + CROW_REEXECUTE(); + } + + c = CROW_TOKEN(ch); + + if (CROW_UNLIKELY(!c)) { + CROW_SET_ERRNO(CHPE_INVALID_HEADER_TOKEN); + goto error; + } + + CROW_MARK(header_field); + + parser->index = 0; + parser->state = s_header_field; + + switch (c) { + case 'c': + parser->header_state = h_C; + break; + + case 'p': + parser->header_state = h_matching_proxy_connection; + break; + + case 't': + parser->header_state = h_matching_transfer_encoding; + break; + + case 'u': + parser->header_state = h_matching_upgrade; + break; + + default: + parser->header_state = h_general; + break; + } + break; + } + + case s_header_field: + { + const char* start = p; + for (; p != data + len; p++) { + ch = *p; + c = CROW_TOKEN(ch); + + if (!c) + break; + + switch (parser->header_state) { + case h_general: { + size_t left = data + len - p; + const char* pe = p + CROW_MIN(left, max_header_size); + while (p+1 < pe && CROW_TOKEN(p[1])) { + p++; + } + break; + } + + case h_C: + parser->index++; + parser->header_state = (c == 'o' ? h_CO : h_general); + break; + + case h_CO: + parser->index++; + parser->header_state = (c == 'n' ? h_CON : h_general); + break; + + case h_CON: + parser->index++; + switch (c) { + case 'n': + parser->header_state = h_matching_connection; + break; + case 't': + parser->header_state = h_matching_content_length; + break; + default: + parser->header_state = h_general; + break; + } + break; + + /* connection */ + + case h_matching_connection: + parser->index++; + if (parser->index > sizeof(CROW_CONNECTION)-1 || c != CROW_CONNECTION[parser->index]) { + parser->header_state = h_general; + } else if (parser->index == sizeof(CROW_CONNECTION)-2) { + parser->header_state = h_connection; + } + break; + + /* proxy-connection */ + + case h_matching_proxy_connection: + parser->index++; + if (parser->index > sizeof(CROW_PROXY_CONNECTION)-1 || c != CROW_PROXY_CONNECTION[parser->index]) { + parser->header_state = h_general; + } else if (parser->index == sizeof(CROW_PROXY_CONNECTION)-2) { + parser->header_state = h_connection; + } + break; + + /* content-length */ + + case h_matching_content_length: + parser->index++; + if (parser->index > sizeof(CROW_CONTENT_LENGTH)-1 || c != CROW_CONTENT_LENGTH[parser->index]) { + parser->header_state = h_general; + } else if (parser->index == sizeof(CROW_CONTENT_LENGTH)-2) { + parser->header_state = h_content_length; + } + break; + + /* transfer-encoding */ + + case h_matching_transfer_encoding: + parser->index++; + if (parser->index > sizeof(CROW_TRANSFER_ENCODING)-1 || c != CROW_TRANSFER_ENCODING[parser->index]) { + parser->header_state = h_general; + } else if (parser->index == sizeof(CROW_TRANSFER_ENCODING)-2) { + parser->header_state = h_transfer_encoding; + parser->uses_transfer_encoding = 1; + } + break; + + /* upgrade */ + + case h_matching_upgrade: + parser->index++; + if (parser->index > sizeof(CROW_UPGRADE)-1 || c != CROW_UPGRADE[parser->index]) { + parser->header_state = h_general; + } else if (parser->index == sizeof(CROW_UPGRADE)-2) { + parser->header_state = h_upgrade; + } + break; + + case h_connection: + case h_content_length: + case h_transfer_encoding: + case h_upgrade: + if (ch != ' ') parser->header_state = h_general; + break; + + default: + assert(0 && "Unknown header_state"); + break; + } + } + + if (p == data + len) { + --p; + CROW_COUNT_HEADER_SIZE(p - start); + break; + } + + CROW_COUNT_HEADER_SIZE(p - start); + + if (ch == ':') { + parser->state = s_header_value_discard_ws; + CROW_CALLBACK_DATA(header_field); + break; + } +/* RFC-7230 Sec 3.2.4 expressly forbids line-folding in header field-names. + if (ch == cr) { + parser->state = s_header_almost_done; + CROW_CALLBACK_DATA(header_field); + break; + } + + if (ch == lf) { + parser->state = s_header_field_start; + CROW_CALLBACK_DATA(header_field); + break; + } +*/ + CROW_SET_ERRNO(CHPE_INVALID_HEADER_TOKEN); + goto error; + } + + case s_header_value_discard_ws: + if (ch == ' ' || ch == '\t') break; + + if (ch == cr) { + parser->state = s_header_value_discard_ws_almost_done; + break; + } + + if (ch == lf) { + parser->state = s_header_value_discard_lws; + break; + } + + /* fall through */ + + case s_header_value_start: + { + CROW_MARK(header_value); + + parser->state = s_header_value; + parser->index = 0; + + c = CROW_LOWER(ch); + + switch (parser->header_state) { + case h_upgrade: + parser->flags |= F_UPGRADE; + parser->header_state = h_general; + break; + + case h_transfer_encoding: + /* looking for 'Transfer-Encoding: chunked' */ + if ('c' == c) { + parser->header_state = h_matching_transfer_encoding_chunked; + } else { + parser->header_state = h_matching_transfer_encoding_token; + } + break; + + /* Multi-value `Transfer-Encoding` header */ + case h_matching_transfer_encoding_token_start: + break; + + case h_content_length: + if (CROW_UNLIKELY(!CROW_IS_NUM(ch))) { + CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH); + goto error; + } + + if (parser->flags & F_CONTENTLENGTH) { + CROW_SET_ERRNO(CHPE_UNEXPECTED_CONTENT_LENGTH); + goto error; + } + parser->flags |= F_CONTENTLENGTH; + parser->content_length = ch - '0'; + parser->header_state = h_content_length_num; + break; + + /* when obsolete line folding is encountered for content length + * continue to the s_header_value state */ + case h_content_length_ws: + break; + + case h_connection: + /* looking for 'Connection: keep-alive' */ + if (c == 'k') { + parser->header_state = h_matching_connection_keep_alive; + /* looking for 'Connection: close' */ + } else if (c == 'c') { + parser->header_state = h_matching_connection_close; + } else if (c == ' ' || c == '\t') { + /* Skip lws */ + } else { + parser->header_state = h_general; + } + break; + + default: + parser->header_state = h_general; + break; + } + break; + } + + case s_header_value: + { + const char* start = p; + enum header_states h_state = static_cast(parser->header_state); + for (; p != data + len; p++) { + ch = *p; + + if (ch == cr) { + parser->state = s_header_almost_done; + parser->header_state = h_state; + CROW_CALLBACK_DATA(header_value); + break; + } + + if (ch == lf) { + parser->state = s_header_almost_done; + CROW_COUNT_HEADER_SIZE(p - start); + parser->header_state = h_state; + CROW_CALLBACK_DATA_NOADVANCE(header_value); + CROW_REEXECUTE(); + } + + if (!lenient && !CROW_IS_HEADER_CHAR(ch)) { + CROW_SET_ERRNO(CHPE_INVALID_HEADER_TOKEN); + goto error; + } + + c = CROW_LOWER(ch); + + switch (h_state) { + case h_general: + { + size_t left = data + len - p; + const char* pe = p + CROW_MIN(left, max_header_size); + + for (; p != pe; p++) { + ch = *p; + if (ch == cr || ch == lf) { + --p; + break; + } + if (!lenient && !CROW_IS_HEADER_CHAR(ch)) { + CROW_SET_ERRNO(CHPE_INVALID_HEADER_TOKEN); + goto error; + } + } + if (p == data + len) + --p; + break; + } + + case h_connection: + case h_transfer_encoding: + assert(0 && "Shouldn't get here."); + break; + + case h_content_length: + if (ch == ' ') break; + h_state = h_content_length_num; + /* fall through */ + + case h_content_length_num: + { + uint64_t t; + + if (ch == ' ') { + h_state = h_content_length_ws; + break; + } + + if (CROW_UNLIKELY(!CROW_IS_NUM(ch))) { + CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH); + parser->header_state = h_state; + goto error; + } + + t = parser->content_length; + t *= 10; + t += ch - '0'; + + /* Overflow? Test against a conservative limit for simplicity. */ + if (CROW_UNLIKELY((CROW_ULLONG_MAX - 10) / 10 < parser->content_length)) { + CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH); + parser->header_state = h_state; + goto error; + } + + parser->content_length = t; + break; + } + + case h_content_length_ws: + if (ch == ' ') break; + CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH); + parser->header_state = h_state; + goto error; + + /* Transfer-Encoding: chunked */ + case h_matching_transfer_encoding_token_start: + /* looking for 'Transfer-Encoding: chunked' */ + if ('c' == c) { + h_state = h_matching_transfer_encoding_chunked; + } else if (CROW_TOKEN(c)) { + /* TODO(indutny): similar code below does this, but why? + * At the very least it seems to be inconsistent given that + * h_matching_transfer_encoding_token does not check for + * `STRICT_TOKEN` + */ + h_state = h_matching_transfer_encoding_token; + } else if (c == ' ' || c == '\t') { + /* Skip lws */ + } else { + h_state = h_general; + } + break; + + case h_matching_transfer_encoding_chunked: + parser->index++; + if (parser->index > sizeof(CROW_CHUNKED)-1 || c != CROW_CHUNKED[parser->index]) { + h_state = h_matching_transfer_encoding_token; + } else if (parser->index == sizeof(CROW_CHUNKED)-2) { + h_state = h_transfer_encoding_chunked; + } + break; + + case h_matching_transfer_encoding_token: + if (ch == ',') { + h_state = h_matching_transfer_encoding_token_start; + parser->index = 0; + } + break; + + /* looking for 'Connection: keep-alive' */ + case h_matching_connection_keep_alive: + parser->index++; + if (parser->index > sizeof(CROW_KEEP_ALIVE)-1 || c != CROW_KEEP_ALIVE[parser->index]) { + h_state = h_general; + } else if (parser->index == sizeof(CROW_KEEP_ALIVE)-2) { + h_state = h_connection_keep_alive; + } + break; + + /* looking for 'Connection: close' */ + case h_matching_connection_close: + parser->index++; + if (parser->index > sizeof(CROW_CLOSE)-1 || c != CROW_CLOSE[parser->index]) { + h_state = h_general; + } else if (parser->index == sizeof(CROW_CLOSE)-2) { + h_state = h_connection_close; + } + break; + + // Edited from original (because of commits that werent included) + case h_transfer_encoding_chunked: + if (ch != ' ') h_state = h_matching_transfer_encoding_token; + break; + case h_connection_keep_alive: + case h_connection_close: + if (ch != ' ') h_state = h_general; + break; + + default: + parser->state = s_header_value; + h_state = h_general; + break; + } + } + parser->header_state = h_state; + + + if (p == data + len) + --p; + + CROW_COUNT_HEADER_SIZE(p - start); + break; + } + + case s_header_almost_done: + { + if (CROW_UNLIKELY(ch != lf)) { + CROW_SET_ERRNO(CHPE_LF_EXPECTED); + goto error; + } + + parser->state = s_header_value_lws; + break; + } + + case s_header_value_lws: + { + if (ch == ' ' || ch == '\t') { + if (parser->header_state == h_content_length_num) { + /* treat obsolete line folding as space */ + parser->header_state = h_content_length_ws; + } + parser->state = s_header_value_start; + CROW_REEXECUTE(); + } + + /* finished the header */ + switch (parser->header_state) { + case h_connection_keep_alive: + parser->flags |= F_CONNECTION_KEEP_ALIVE; + break; + case h_connection_close: + parser->flags |= F_CONNECTION_CLOSE; + break; + case h_transfer_encoding_chunked: + parser->flags |= F_CHUNKED; + break; + default: + break; + } + + parser->state = s_header_field_start; + CROW_REEXECUTE(); + } + + case s_header_value_discard_ws_almost_done: + { + CROW_STRICT_CHECK(ch != lf); + parser->state = s_header_value_discard_lws; + break; + } + + case s_header_value_discard_lws: + { + if (ch == ' ' || ch == '\t') { + parser->state = s_header_value_discard_ws; + break; + } else { + /* header value was empty */ + CROW_MARK(header_value); + parser->state = s_header_field_start; + CROW_CALLBACK_DATA_NOADVANCE(header_value); + CROW_REEXECUTE(); + } + } + + case s_headers_almost_done: + { + CROW_STRICT_CHECK(ch != lf); + + if (parser->flags & F_TRAILING) { + /* End of a chunked request */ + CROW_CALLBACK_NOTIFY(message_complete); + break; + } + + /* Cannot use transfer-encoding and a content-length header together + per the HTTP specification. (RFC 7230 Section 3.3.3) */ + if ((parser->uses_transfer_encoding == 1) && + (parser->flags & F_CONTENTLENGTH)) { + /* Allow it for lenient parsing as long as `Transfer-Encoding` is + * not `chunked` or allow_length_with_encoding is set + */ + if (parser->flags & F_CHUNKED) { + if (!allow_chunked_length) { + CROW_SET_ERRNO(CHPE_UNEXPECTED_CONTENT_LENGTH); + goto error; + } + } else if (!lenient) { + CROW_SET_ERRNO(CHPE_UNEXPECTED_CONTENT_LENGTH); + goto error; + } + } + + parser->state = s_headers_done; + + /* Set this here so that on_headers_complete() callbacks can see it */ + parser->upgrade = + (parser->flags & F_UPGRADE || parser->method == (unsigned)HTTPMethod::Connect); + + /* Here we call the headers_complete callback. This is somewhat + * different than other callbacks because if the user returns 1, we + * will interpret that as saying that this message has no body. This + * is needed for the annoying case of recieving a response to a HEAD + * request. + * + * We'd like to use CROW_CALLBACK_NOTIFY_NOADVANCE() here but we cannot, so + * we have to simulate it by handling a change in errno below. + */ + if (settings->on_headers_complete) { + switch (settings->on_headers_complete(parser)) { + case 0: + break; + + case 2: + parser->upgrade = 1; + //break; + + /* fall through */ + case 1: + parser->flags |= F_SKIPBODY; + break; + + default: + CROW_SET_ERRNO(CHPE_CB_headers_complete); + parser->nread = nread; + return p - data; /* Error */ + } + } + + if (CROW_HTTP_PARSER_ERRNO(parser) != CHPE_OK) { + parser->nread = nread; + return p - data; + } + + CROW_REEXECUTE(); + } + + case s_headers_done: + { + CROW_STRICT_CHECK(ch != lf); + + parser->nread = 0; + nread = 0; + + /* Exit, the rest of the connect is in a different protocol. */ + if (parser->upgrade) { + CROW_CALLBACK_NOTIFY(message_complete); + parser->nread = nread; + return (p - data) + 1; + } + + if (parser->flags & F_SKIPBODY) { + CROW_CALLBACK_NOTIFY(message_complete); + } else if (parser->flags & F_CHUNKED) { + /* chunked encoding - ignore Content-Length header, + * prepare for a chunk */ + parser->state = s_chunk_size_start; + } + else if (parser->uses_transfer_encoding == 1) + { + if (!lenient) + { + /* RFC 7230 3.3.3 */ + + /* If a Transfer-Encoding header field + * is present in a request and the chunked transfer coding is not + * the final encoding, the message body length cannot be determined + * reliably; the server MUST respond with the 400 (Bad Request) + * status code and then close the connection. + */ + CROW_SET_ERRNO(CHPE_INVALID_TRANSFER_ENCODING); + parser->nread = nread; + return (p - data); /* Error */ + } + else + { + /* RFC 7230 3.3.3 */ + + /* If a Transfer-Encoding header field is present in a response and + * the chunked transfer coding is not the final encoding, the + * message body length is determined by reading the connection until + * it is closed by the server. + */ + parser->state = s_body_identity_eof; + } + } + else + { + if (parser->content_length == 0) + { + /* Content-Length header given but zero: Content-Length: 0\r\n */ + CROW_CALLBACK_NOTIFY(message_complete); + } + else if (parser->content_length != CROW_ULLONG_MAX) + { + /* Content-Length header given and non-zero */ + parser->state = s_body_identity; + } + else + { + /* Assume content-length 0 - read the next */ + CROW_CALLBACK_NOTIFY(message_complete); + } + } + + break; + } + + case s_body_identity: + { + uint64_t to_read = CROW_MIN(parser->content_length, + (uint64_t) ((data + len) - p)); + + assert(parser->content_length != 0 + && parser->content_length != CROW_ULLONG_MAX); + + /* The difference between advancing content_length and p is because + * the latter will automaticaly advance on the next loop iteration. + * Further, if content_length ends up at 0, we want to see the last + * byte again for our message complete callback. + */ + CROW_MARK(body); + parser->content_length -= to_read; + p += to_read - 1; + + if (parser->content_length == 0) { + parser->state = s_message_done; + + /* Mimic CROW_CALLBACK_DATA_NOADVANCE() but with one extra byte. + * + * The alternative to doing this is to wait for the next byte to + * trigger the data callback, just as in every other case. The + * problem with this is that this makes it difficult for the test + * harness to distinguish between complete-on-EOF and + * complete-on-length. It's not clear that this distinction is + * important for applications, but let's keep it for now. + */ + CROW_CALLBACK_DATA_(body, p - body_mark + 1, p - data); + CROW_REEXECUTE(); + } + + break; + } + + /* read until EOF */ + case s_body_identity_eof: + CROW_MARK(body); + p = data + len - 1; + + break; + + case s_message_done: + CROW_CALLBACK_NOTIFY(message_complete); + break; + + case s_chunk_size_start: + { + assert(nread == 1); + assert(parser->flags & F_CHUNKED); + + unhex_val = unhex[static_cast(ch)]; + if (CROW_UNLIKELY(unhex_val == -1)) { + CROW_SET_ERRNO(CHPE_INVALID_CHUNK_SIZE); + goto error; + } + + parser->content_length = unhex_val; + parser->state = s_chunk_size; + break; + } + + case s_chunk_size: + { + uint64_t t; + + assert(parser->flags & F_CHUNKED); + + if (ch == cr) { + parser->state = s_chunk_size_almost_done; + break; + } + + unhex_val = unhex[static_cast(ch)]; + + if (unhex_val == -1) { + if (ch == ';' || ch == ' ') { + parser->state = s_chunk_parameters; + break; + } + + CROW_SET_ERRNO(CHPE_INVALID_CHUNK_SIZE); + goto error; + } + + t = parser->content_length; + t *= 16; + t += unhex_val; + + /* Overflow? Test against a conservative limit for simplicity. */ + if (CROW_UNLIKELY((CROW_ULLONG_MAX - 16) / 16 < parser->content_length)) { + CROW_SET_ERRNO(CHPE_INVALID_CONTENT_LENGTH); + goto error; + } + + parser->content_length = t; + break; + } + + case s_chunk_parameters: + { + assert(parser->flags & F_CHUNKED); + /* just ignore this shit. TODO check for overflow */ + if (ch == cr) { + parser->state = s_chunk_size_almost_done; + break; + } + break; + } + + case s_chunk_size_almost_done: + { + assert(parser->flags & F_CHUNKED); + CROW_STRICT_CHECK(ch != lf); + + parser->nread = 0; + nread = 0; + + if (parser->content_length == 0) { + parser->flags |= F_TRAILING; + parser->state = s_header_field_start; + } else { + parser->state = s_chunk_data; + } + break; + } + + case s_chunk_data: + { + uint64_t to_read = CROW_MIN(parser->content_length, + (uint64_t) ((data + len) - p)); + + assert(parser->flags & F_CHUNKED); + assert(parser->content_length != 0 + && parser->content_length != CROW_ULLONG_MAX); + + /* See the explanation in s_body_identity for why the content + * length and data pointers are managed this way. + */ + CROW_MARK(body); + parser->content_length -= to_read; + p += to_read - 1; + + if (parser->content_length == 0) { + parser->state = s_chunk_data_almost_done; + } + + break; + } + + case s_chunk_data_almost_done: + assert(parser->flags & F_CHUNKED); + assert(parser->content_length == 0); + CROW_STRICT_CHECK(ch != cr); + parser->state = s_chunk_data_done; + CROW_CALLBACK_DATA(body); + break; + + case s_chunk_data_done: + assert(parser->flags & F_CHUNKED); + CROW_STRICT_CHECK(ch != lf); + parser->nread = 0; + nread = 0; + parser->state = s_chunk_size_start; + break; + + default: + assert(0 && "unhandled state"); + CROW_SET_ERRNO(CHPE_INVALID_INTERNAL_STATE); + goto error; + } + } + + /* Run callbacks for any marks that we have leftover after we ran out of + * bytes. There should be at most one of these set, so it's OK to invoke + * them in series (unset marks will not result in callbacks). + * + * We use the NOADVANCE() variety of callbacks here because 'p' has already + * overflowed 'data' and this allows us to correct for the off-by-one that + * we'd otherwise have (since CROW_CALLBACK_DATA() is meant to be run with a 'p' + * value that's in-bounds). + */ + + assert(((header_field_mark ? 1 : 0) + + (header_value_mark ? 1 : 0) + + (url_mark ? 1 : 0) + + (body_mark ? 1 : 0)) <= 1); + + CROW_CALLBACK_DATA_NOADVANCE(header_field); + CROW_CALLBACK_DATA_NOADVANCE(header_value); + CROW_CALLBACK_DATA_NOADVANCE(url); + CROW_CALLBACK_DATA_NOADVANCE(body); + + parser->nread = nread; + return len; + +error: + if (CROW_HTTP_PARSER_ERRNO(parser) == CHPE_OK) { + CROW_SET_ERRNO(CHPE_UNKNOWN); + } + + parser->nread = nread; + return (p - data); +} + +inline void + http_parser_init(http_parser* parser) +{ + void *data = parser->data; /* preserve application data */ + memset(parser, 0, sizeof(*parser)); + parser->data = data; + parser->state = s_start_req; + parser->http_errno = CHPE_OK; +} + +/* Return a string name of the given error */ +inline const char * +http_errno_name(enum http_errno err) { +/* Map errno values to strings for human-readable output */ +#define CROW_HTTP_STRERROR_GEN(n, s) { "CHPE_" #n, s }, +static struct { + const char *name; + const char *description; +} http_strerror_tab[] = { + CROW_HTTP_ERRNO_MAP(CROW_HTTP_STRERROR_GEN) +}; +#undef CROW_HTTP_STRERROR_GEN + assert(((size_t) err) < CROW_ARRAY_SIZE(http_strerror_tab)); + return http_strerror_tab[err].name; +} + +/* Return a string description of the given error */ +inline const char * +http_errno_description(enum http_errno err) { +/* Map errno values to strings for human-readable output */ +#define CROW_HTTP_STRERROR_GEN(n, s) { "CHPE_" #n, s }, +static struct { + const char *name; + const char *description; +} http_strerror_tab[] = { + CROW_HTTP_ERRNO_MAP(CROW_HTTP_STRERROR_GEN) +}; +#undef CROW_HTTP_STRERROR_GEN + assert(((size_t) err) < CROW_ARRAY_SIZE(http_strerror_tab)); + return http_strerror_tab[err].description; +} + +/* Checks if this is the final chunk of the body. */ +inline int +http_body_is_final(const struct http_parser *parser) { + return parser->state == s_message_done; +} + +/* Change the maximum header size provided at compile time. */ +inline void +http_parser_set_max_header_size(uint32_t size) { + max_header_size = size; +} + +#undef CROW_HTTP_ERRNO_MAP +#undef CROW_SET_ERRNO +#undef CROW_CALLBACK_NOTIFY_ +#undef CROW_CALLBACK_NOTIFY +#undef CROW_CALLBACK_NOTIFY_NOADVANCE +#undef CROW_CALLBACK_DATA_ +#undef CROW_CALLBACK_DATA +#undef CROW_CALLBACK_DATA_NOADVANCE +#undef CROW_MARK +#undef CROW_PROXY_CONNECTION +#undef CROW_CONNECTION +#undef CROW_CONTENT_LENGTH +#undef CROW_TRANSFER_ENCODING +#undef CROW_UPGRADE +#undef CROW_CHUNKED +#undef CROW_KEEP_ALIVE +#undef CROW_CLOSE +#undef CROW_PARSING_HEADER +#undef CROW_LOWER +#undef CROW_IS_ALPHA +#undef CROW_IS_NUM +#undef CROW_IS_ALPHANUM +//#undef CROW_IS_HEX +#undef CROW_IS_MARK +#undef CROW_IS_USERINFO_CHAR +#undef CROW_TOKEN +#undef CROW_IS_URL_CHAR +//#undef CROW_IS_HOST_CHAR +#undef CROW_STRICT_CHECK + +} +} + +// clang-format on + + + +#pragma once + +#include +#include +#include +#include + + + + + + +namespace crow +{ + /// A wrapper for `nodejs/http-parser`. + + /// + /// Used to generate a \ref crow.request from the TCP socket buffer. + template + struct HTTPParser : public http_parser + { + static int on_message_begin(http_parser*) + { + return 0; + } + static int on_url(http_parser* self_, const char* at, size_t length) + { + HTTPParser* self = static_cast(self_); + self->raw_url.insert(self->raw_url.end(), at, at + length); + return 0; + } + static int on_header_field(http_parser* self_, const char* at, size_t length) + { + HTTPParser* self = static_cast(self_); + switch (self->header_building_state) + { + case 0: + if (!self->header_value.empty()) + { + self->headers.emplace(std::move(self->header_field), std::move(self->header_value)); + } + self->header_field.assign(at, at + length); + self->header_building_state = 1; + break; + case 1: + self->header_field.insert(self->header_field.end(), at, at + length); + break; + } + return 0; + } + static int on_header_value(http_parser* self_, const char* at, size_t length) + { + HTTPParser* self = static_cast(self_); + switch (self->header_building_state) + { + case 0: + self->header_value.insert(self->header_value.end(), at, at + length); + break; + case 1: + self->header_building_state = 0; + self->header_value.assign(at, at + length); + break; + } + return 0; + } + static int on_headers_complete(http_parser* self_) + { + HTTPParser* self = static_cast(self_); + if (!self->header_field.empty()) + { + self->headers.emplace(std::move(self->header_field), std::move(self->header_value)); + } + + self->set_connection_parameters(); + + self->process_header(); + return 0; + } + static int on_body(http_parser* self_, const char* at, size_t length) + { + HTTPParser* self = static_cast(self_); + self->body.insert(self->body.end(), at, at + length); + return 0; + } + static int on_message_complete(http_parser* self_) + { + HTTPParser* self = static_cast(self_); + + self->message_complete = true; + // url params + self->url = self->raw_url.substr(0, self->qs_point != 0 ? self->qs_point : std::string::npos); + self->url_params = query_string(self->raw_url); + + self->process_message(); + return 0; + } + HTTPParser(Handler* handler): + handler_(handler) + { + http_parser_init(this); + } + + // return false on error + /// Parse a buffer into the different sections of an HTTP request. + bool feed(const char* buffer, int length) + { + if (message_complete) + return true; + + const static http_parser_settings settings_{ + on_message_begin, + on_url, + on_header_field, + on_header_value, + on_headers_complete, + on_body, + on_message_complete, + }; + + int nparsed = http_parser_execute(this, &settings_, buffer, length); + if (http_errno != CHPE_OK) + { + return false; + } + return nparsed == length; + } + + bool done() + { + return feed(nullptr, 0); + } + + void clear() + { + url.clear(); + raw_url.clear(); + header_field.clear(); + header_value.clear(); + headers.clear(); + url_params.clear(); + body.clear(); + header_building_state = 0; + qs_point = 0; + http_major = 0; + http_minor = 0; + message_complete = false; + state = CROW_NEW_MESSAGE(); + keep_alive = false; + close_connection = false; + } + + inline void process_header() + { + handler_->handle_header(); + } + + inline void process_message() + { + handler_->handle(); + } + + inline void set_connection_parameters() + { + //NOTE(EDev): it seems that the problem is with crow's policy on closing the connection for HTTP_VERSION < 1.0, the behaviour for that in crow is "don't close the connection, but don't send a keep-alive either" + + // HTTP1.1 = always send keep_alive, HTTP1.0 = only send if header exists, HTTP?.? = never send + keep_alive = (http_major == 1 && http_minor == 0) ? + ((flags & F_CONNECTION_KEEP_ALIVE) ? true : false) : + ((http_major == 1 && http_minor == 1) ? true : false); + + // HTTP1.1 = only close if close header exists, HTTP1.0 = always close unless keep_alive header exists, HTTP?.?= never close + close_connection = (http_major == 1 && http_minor == 0) ? + ((flags & F_CONNECTION_KEEP_ALIVE) ? false : true) : + ((http_major == 1 && http_minor == 1) ? ((flags & F_CONNECTION_CLOSE) ? true : false) : false); + } + + /// Take the parsed HTTP request data and convert it to a \ref crow.request + request to_request() const + { + return request{static_cast(method), std::move(raw_url), std::move(url), std::move(url_params), std::move(headers), std::move(body), http_major, http_minor, keep_alive, close_connection, static_cast(upgrade)}; + } + + std::string raw_url; + std::string url; + + int header_building_state = 0; + bool message_complete = false; + std::string header_field; + std::string header_value; + ci_map headers; + query_string url_params; ///< What comes after the `?` in the URL. + std::string body; + bool keep_alive; ///< Whether or not the server should send a `connection: Keep-Alive` header to the client. + bool close_connection; ///< Whether or not the server should shut down the TCP connection once a response is sent. + + Handler* handler_; ///< This is currently an HTTP connection object (\ref crow.Connection). + }; +} // namespace crow + +#undef CROW_NEW_MESSAGE +#undef CROW_start_state + + + +#pragma once + + + + + + + + +namespace crow +{ + namespace detail + { + + + template + struct partial_context : public black_magic::pop_back::template rebind, public black_magic::last_element_type::type::context + { + using parent_context = typename black_magic::pop_back::template rebind<::crow::detail::partial_context>; + template + using partial = typename std::conditional>::type; + + template + typename T::context& get() + { + return static_cast(*this); + } + }; + + + + template<> + struct partial_context<> + { + template + using partial = partial_context; + }; + + + template + struct context : private partial_context + //struct context : private Middlewares::context... // simple but less type-safe + { + template class CallCriteria, int N, typename Context, typename Container> + friend typename std::enable_if<(N == 0)>::type after_handlers_call_helper(Container& middlewares, Context& ctx, request& req, response& res); + template class CallCriteria, int N, typename Context, typename Container> + friend typename std::enable_if<(N > 0)>::type after_handlers_call_helper(Container& middlewares, Context& ctx, request& req, response& res); + + template class CallCriteria, int N, typename Context, typename Container> + friend typename std::enable_if<(N < std::tuple_size::type>::value), bool>::type + middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx); + + template + typename T::context& get() + { + return static_cast(*this); + } + + template + using partial = typename partial_context::template partial; + }; + } // namespace detail +} // namespace crow + + + +#pragma once + +//#define CROW_JSON_NO_ERROR_CHECK +//#define CROW_JSON_USE_MAP + +#include +#ifdef CROW_JSON_USE_MAP +#include +#else +#include +#endif +#include +#include +#include +#include +#include +#include +#include +#include + + + + + + + + + + +using std::isinf; +using std::isnan; + + +namespace crow +{ + namespace mustache + { + class template_t; + } + + namespace json + { + inline void escape(const std::string& str, std::string& ret) + { + ret.reserve(ret.size() + str.size() + str.size() / 4); + for (auto c : str) + { + switch (c) + { + case '"': ret += "\\\""; break; + case '\\': ret += "\\\\"; break; + case '\n': ret += "\\n"; break; + case '\b': ret += "\\b"; break; + case '\f': ret += "\\f"; break; + case '\r': ret += "\\r"; break; + case '\t': ret += "\\t"; break; + default: + if (c >= 0 && c < 0x20) + { + ret += "\\u00"; + auto to_hex = [](char c) { + c = c & 0xf; + if (c < 10) + return '0' + c; + return 'a' + c - 10; + }; + ret += to_hex(c / 16); + ret += to_hex(c % 16); + } + else + ret += c; + break; + } + } + } + inline std::string escape(const std::string& str) + { + std::string ret; + escape(str, ret); + return ret; + } + + enum class type : char + { + Null, + False, + True, + Number, + String, + List, + Object, + Function + }; + + inline const char* get_type_str(type t) + { + switch (t) + { + case type::Number: return "Number"; + case type::False: return "False"; + case type::True: return "True"; + case type::List: return "List"; + case type::String: return "String"; + case type::Object: return "Object"; + case type::Function: return "Function"; + default: return "Unknown"; + } + } + + enum class num_type : char + { + Signed_integer, + Unsigned_integer, + Floating_point, + Null + }; + + class rvalue; + rvalue load(const char* data, size_t size); + + namespace detail + { + /// A read string implementation with comparison functionality. + struct r_string : boost::less_than_comparable, boost::less_than_comparable, boost::equality_comparable, boost::equality_comparable + { + r_string(){}; + r_string(char* s, char* e): + s_(s), e_(e){}; + ~r_string() + { + if (owned_) + delete[] s_; + } + + r_string(const r_string& r) + { + *this = r; + } + + r_string(r_string&& r) + { + *this = r; + } + + r_string& operator=(r_string&& r) + { + s_ = r.s_; + e_ = r.e_; + owned_ = r.owned_; + if (r.owned_) + r.owned_ = 0; + return *this; + } + + r_string& operator=(const r_string& r) + { + s_ = r.s_; + e_ = r.e_; + owned_ = 0; + return *this; + } + + operator std::string() const + { + return std::string(s_, e_); + } + + + const char* begin() const { return s_; } + const char* end() const { return e_; } + size_t size() const { return end() - begin(); } + + using iterator = const char*; + using const_iterator = const char*; + + char* s_; ///< Start. + mutable char* e_; ///< End. + uint8_t owned_{0}; + friend std::ostream& operator<<(std::ostream& os, const r_string& s) + { + os << static_cast(s); + return os; + } + + private: + void force(char* s, uint32_t length) + { + s_ = s; + e_ = s_ + length; + owned_ = 1; + } + friend rvalue crow::json::load(const char* data, size_t size); + }; + + inline bool operator<(const r_string& l, const r_string& r) + { + return boost::lexicographical_compare(l, r); + } + + inline bool operator<(const r_string& l, const std::string& r) + { + return boost::lexicographical_compare(l, r); + } + + inline bool operator>(const r_string& l, const std::string& r) + { + return boost::lexicographical_compare(r, l); + } + + inline bool operator==(const r_string& l, const r_string& r) + { + return boost::equals(l, r); + } + + inline bool operator==(const r_string& l, const std::string& r) + { + return boost::equals(l, r); + } + } // namespace detail + + /// JSON read value. + + /// + /// Value can mean any json value, including a JSON object. + /// Read means this class is used to primarily read strings into a JSON value. + class rvalue + { + static const int cached_bit = 2; + static const int error_bit = 4; + + public: + rvalue() noexcept: + option_{error_bit} + { + } + rvalue(type t) noexcept: + lsize_{}, lremain_{}, t_{t} + { + } + rvalue(type t, char* s, char* e) noexcept: + start_{s}, end_{e}, t_{t} + { + determine_num_type(); + } + + rvalue(const rvalue& r): + start_(r.start_), end_(r.end_), key_(r.key_), t_(r.t_), nt_(r.nt_), option_(r.option_) + { + copy_l(r); + } + + rvalue(rvalue&& r) noexcept + { + *this = std::move(r); + } + + rvalue& operator=(const rvalue& r) + { + start_ = r.start_; + end_ = r.end_; + key_ = r.key_; + t_ = r.t_; + nt_ = r.nt_; + option_ = r.option_; + copy_l(r); + return *this; + } + rvalue& operator=(rvalue&& r) noexcept + { + start_ = r.start_; + end_ = r.end_; + key_ = std::move(r.key_); + l_ = std::move(r.l_); + lsize_ = r.lsize_; + lremain_ = r.lremain_; + t_ = r.t_; + nt_ = r.nt_; + option_ = r.option_; + return *this; + } + + explicit operator bool() const noexcept + { + return (option_ & error_bit) == 0; + } + + explicit operator int64_t() const + { + return i(); + } + + explicit operator uint64_t() const + { + return u(); + } + + explicit operator int() const + { + return static_cast(i()); + } + + /// Return any json value (not object or list) as a string. + explicit operator std::string() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() == type::Object || t() == type::List) + throw std::runtime_error("json type container"); +#endif + switch (t()) + { + case type::String: + return std::string(s()); + case type::Null: + return std::string("null"); + case type::True: + return std::string("true"); + case type::False: + return std::string("false"); + default: + return std::string(start_, end_ - start_); + } + } + + /// The type of the JSON value. + type t() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (option_ & error_bit) + { + throw std::runtime_error("invalid json object"); + } +#endif + return t_; + } + + /// The number type of the JSON value. + num_type nt() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (option_ & error_bit) + { + throw std::runtime_error("invalid json object"); + } +#endif + return nt_; + } + + /// The integer value. + int64_t i() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + switch (t()) + { + case type::Number: + case type::String: + return boost::lexical_cast(start_, end_ - start_); + default: + const std::string msg = "expected number, got: " + std::string(get_type_str(t())); + throw std::runtime_error(msg); + } +#endif + return boost::lexical_cast(start_, end_ - start_); + } + + /// The unsigned integer value. + uint64_t u() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + switch (t()) + { + case type::Number: + case type::String: + return boost::lexical_cast(start_, end_ - start_); + default: + throw std::runtime_error(std::string("expected number, got: ") + get_type_str(t())); + } +#endif + return boost::lexical_cast(start_, end_ - start_); + } + + /// The double precision floating-point number value. + double d() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::Number) + throw std::runtime_error("value is not number"); +#endif + return boost::lexical_cast(start_, end_ - start_); + } + + /// The boolean value. + bool b() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::True && t() != type::False) + throw std::runtime_error("value is not boolean"); +#endif + return t() == type::True; + } + + /// The string value. + detail::r_string s() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::String) + throw std::runtime_error("value is not string"); +#endif + unescape(); + return detail::r_string{start_, end_}; + } + + /// The list or object value + std::vector lo() + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::Object && t() != type::List) + throw std::runtime_error("value is not a container"); +#endif + std::vector ret; + ret.reserve(lsize_); + for (uint32_t i = 0; i < lsize_; i++) + { + ret.emplace_back(l_[i]); + } + return ret; + } + + /// Convert escaped string character to their original form ("\\n" -> '\n'). + void unescape() const + { + if (*(start_ - 1)) + { + char* head = start_; + char* tail = start_; + while (head != end_) + { + if (*head == '\\') + { + switch (*++head) + { + case '"': *tail++ = '"'; break; + case '\\': *tail++ = '\\'; break; + case '/': *tail++ = '/'; break; + case 'b': *tail++ = '\b'; break; + case 'f': *tail++ = '\f'; break; + case 'n': *tail++ = '\n'; break; + case 'r': *tail++ = '\r'; break; + case 't': *tail++ = '\t'; break; + case 'u': + { + auto from_hex = [](char c) { + if (c >= 'a') + return c - 'a' + 10; + if (c >= 'A') + return c - 'A' + 10; + return c - '0'; + }; + unsigned int code = + (from_hex(head[1]) << 12) + + (from_hex(head[2]) << 8) + + (from_hex(head[3]) << 4) + + from_hex(head[4]); + if (code >= 0x800) + { + *tail++ = 0xE0 | (code >> 12); + *tail++ = 0x80 | ((code >> 6) & 0x3F); + *tail++ = 0x80 | (code & 0x3F); + } + else if (code >= 0x80) + { + *tail++ = 0xC0 | (code >> 6); + *tail++ = 0x80 | (code & 0x3F); + } + else + { + *tail++ = code; + } + head += 4; + } + break; + } + } + else + *tail++ = *head; + head++; + } + end_ = tail; + *end_ = 0; + *(start_ - 1) = 0; + } + } + + /// Check if the json object has the passed string as a key. + bool has(const char* str) const + { + return has(std::string(str)); + } + + bool has(const std::string& str) const + { + struct Pred + { + bool operator()(const rvalue& l, const rvalue& r) const + { + return l.key_ < r.key_; + }; + bool operator()(const rvalue& l, const std::string& r) const + { + return l.key_ < r; + }; + bool operator()(const std::string& l, const rvalue& r) const + { + return l < r.key_; + }; + }; + if (!is_cached()) + { + std::sort(begin(), end(), Pred()); + set_cached(); + } + auto it = lower_bound(begin(), end(), str, Pred()); + return it != end() && it->key_ == str; + } + + int count(const std::string& str) + { + return has(str) ? 1 : 0; + } + + rvalue* begin() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::Object && t() != type::List) + throw std::runtime_error("value is not a container"); +#endif + return l_.get(); + } + rvalue* end() const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::Object && t() != type::List) + throw std::runtime_error("value is not a container"); +#endif + return l_.get() + lsize_; + } + + const detail::r_string& key() const + { + return key_; + } + + size_t size() const + { + if (t() == type::String) + return s().size(); +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::Object && t() != type::List) + throw std::runtime_error("value is not a container"); +#endif + return lsize_; + } + + const rvalue& operator[](int index) const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::List) + throw std::runtime_error("value is not a list"); + if (index >= static_cast(lsize_) || index < 0) + throw std::runtime_error("list out of bound"); +#endif + return l_[index]; + } + + const rvalue& operator[](size_t index) const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::List) + throw std::runtime_error("value is not a list"); + if (index >= lsize_) + throw std::runtime_error("list out of bound"); +#endif + return l_[index]; + } + + const rvalue& operator[](const char* str) const + { + return this->operator[](std::string(str)); + } + + const rvalue& operator[](const std::string& str) const + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::Object) + throw std::runtime_error("value is not an object"); +#endif + struct Pred + { + bool operator()(const rvalue& l, const rvalue& r) const + { + return l.key_ < r.key_; + }; + bool operator()(const rvalue& l, const std::string& r) const + { + return l.key_ < r; + }; + bool operator()(const std::string& l, const rvalue& r) const + { + return l < r.key_; + }; + }; + if (!is_cached()) + { + std::sort(begin(), end(), Pred()); + set_cached(); + } + auto it = lower_bound(begin(), end(), str, Pred()); + if (it != end() && it->key_ == str) + return *it; +#ifndef CROW_JSON_NO_ERROR_CHECK + throw std::runtime_error("cannot find key"); +#else + static rvalue nullValue; + return nullValue; +#endif + } + + void set_error() + { + option_ |= error_bit; + } + + bool error() const + { + return (option_ & error_bit) != 0; + } + + std::vector keys() + { +#ifndef CROW_JSON_NO_ERROR_CHECK + if (t() != type::Object) + throw std::runtime_error("value is not an object"); +#endif + std::vector ret; + ret.reserve(lsize_); + for (uint32_t i = 0; i < lsize_; i++) + { + ret.emplace_back(std::string(l_[i].key())); + } + return ret; + } + + private: + bool is_cached() const + { + return (option_ & cached_bit) != 0; + } + void set_cached() const + { + option_ |= cached_bit; + } + void copy_l(const rvalue& r) + { + if (r.t() != type::Object && r.t() != type::List) + return; + lsize_ = r.lsize_; + lremain_ = 0; + l_.reset(new rvalue[lsize_]); + std::copy(r.begin(), r.end(), begin()); + } + + void emplace_back(rvalue&& v) + { + if (!lremain_) + { + int new_size = lsize_ + lsize_; + if (new_size - lsize_ > 60000) + new_size = lsize_ + 60000; + if (new_size < 4) + new_size = 4; + rvalue* p = new rvalue[new_size]; + rvalue* p2 = p; + for (auto& x : *this) + *p2++ = std::move(x); + l_.reset(p); + lremain_ = new_size - lsize_; + } + l_[lsize_++] = std::move(v); + lremain_--; + } + + /// Determines num_type from the string. + void determine_num_type() + { + if (t_ != type::Number) + { + nt_ = num_type::Null; + return; + } + + const std::size_t len = end_ - start_; + const bool has_minus = std::memchr(start_, '-', len) != nullptr; + const bool has_e = std::memchr(start_, 'e', len) != nullptr || std::memchr(start_, 'E', len) != nullptr; + const bool has_dec_sep = std::memchr(start_, '.', len) != nullptr; + if (has_dec_sep || has_e) + nt_ = num_type::Floating_point; + else if (has_minus) + nt_ = num_type::Signed_integer; + else + nt_ = num_type::Unsigned_integer; + } + + mutable char* start_; + mutable char* end_; + detail::r_string key_; + std::unique_ptr l_; + uint32_t lsize_; + uint16_t lremain_; + type t_; + num_type nt_{num_type::Null}; + mutable uint8_t option_{0}; + + friend rvalue load_nocopy_internal(char* data, size_t size); + friend rvalue load(const char* data, size_t size); + friend std::ostream& operator<<(std::ostream& os, const rvalue& r) + { + switch (r.t_) + { + + case type::Null: os << "null"; break; + case type::False: os << "false"; break; + case type::True: os << "true"; break; + case type::Number: + { + switch (r.nt()) + { + case num_type::Floating_point: os << r.d(); break; + case num_type::Signed_integer: os << r.i(); break; + case num_type::Unsigned_integer: os << r.u(); break; + case num_type::Null: throw std::runtime_error("Number with num_type Null"); + } + } + break; + case type::String: os << '"' << r.s() << '"'; break; + case type::List: + { + os << '['; + bool first = true; + for (auto& x : r) + { + if (!first) + os << ','; + first = false; + os << x; + } + os << ']'; + } + break; + case type::Object: + { + os << '{'; + bool first = true; + for (auto& x : r) + { + if (!first) + os << ','; + os << '"' << escape(x.key_) << "\":"; + first = false; + os << x; + } + os << '}'; + } + break; + case type::Function: os << "custom function"; break; + } + return os; + } + }; + namespace detail + { + } + + inline bool operator==(const rvalue& l, const std::string& r) + { + return l.s() == r; + } + + inline bool operator==(const std::string& l, const rvalue& r) + { + return l == r.s(); + } + + inline bool operator!=(const rvalue& l, const std::string& r) + { + return l.s() != r; + } + + inline bool operator!=(const std::string& l, const rvalue& r) + { + return l != r.s(); + } + + inline bool operator==(const rvalue& l, double r) + { + return l.d() == r; + } + + inline bool operator==(double l, const rvalue& r) + { + return l == r.d(); + } + + inline bool operator!=(const rvalue& l, double r) + { + return l.d() != r; + } + + inline bool operator!=(double l, const rvalue& r) + { + return l != r.d(); + } + + + inline rvalue load_nocopy_internal(char* data, size_t size) + { + // Defend against excessive recursion + static constexpr unsigned max_depth = 10000; + + //static const char* escaped = "\"\\/\b\f\n\r\t"; + struct Parser + { + Parser(char* data, size_t /*size*/): + data(data) + { + } + + bool consume(char c) + { + if (CROW_UNLIKELY(*data != c)) + return false; + data++; + return true; + } + + void ws_skip() + { + while (*data == ' ' || *data == '\t' || *data == '\r' || *data == '\n') + ++data; + }; + + rvalue decode_string() + { + if (CROW_UNLIKELY(!consume('"'))) + return {}; + char* start = data; + uint8_t has_escaping = 0; + while (1) + { + if (CROW_LIKELY(*data != '"' && *data != '\\' && *data != '\0')) + { + data++; + } + else if (*data == '"') + { + *data = 0; + *(start - 1) = has_escaping; + data++; + return {type::String, start, data - 1}; + } + else if (*data == '\\') + { + has_escaping = 1; + data++; + switch (*data) + { + case 'u': + { + auto check = [](char c) { + return ('0' <= c && c <= '9') || + ('a' <= c && c <= 'f') || + ('A' <= c && c <= 'F'); + }; + if (!(check(*(data + 1)) && + check(*(data + 2)) && + check(*(data + 3)) && + check(*(data + 4)))) + return {}; + } + data += 5; + break; + case '"': + case '\\': + case '/': + case 'b': + case 'f': + case 'n': + case 'r': + case 't': + data++; + break; + default: + return {}; + } + } + else + return {}; + } + return {}; + } + + rvalue decode_list(unsigned depth) + { + rvalue ret(type::List); + if (CROW_UNLIKELY(!consume('[')) || CROW_UNLIKELY(depth > max_depth)) + { + ret.set_error(); + return ret; + } + ws_skip(); + if (CROW_UNLIKELY(*data == ']')) + { + data++; + return ret; + } + + while (1) + { + auto v = decode_value(depth + 1); + if (CROW_UNLIKELY(!v)) + { + ret.set_error(); + break; + } + ws_skip(); + ret.emplace_back(std::move(v)); + if (*data == ']') + { + data++; + break; + } + if (CROW_UNLIKELY(!consume(','))) + { + ret.set_error(); + break; + } + ws_skip(); + } + return ret; + } + + rvalue decode_number() + { + char* start = data; + + enum NumberParsingState + { + Minus, + AfterMinus, + ZeroFirst, + Digits, + DigitsAfterPoints, + E, + DigitsAfterE, + Invalid, + } state{Minus}; + while (CROW_LIKELY(state != Invalid)) + { + switch (*data) + { + case '0': + state = static_cast("\2\2\7\3\4\6\6"[state]); + /*if (state == NumberParsingState::Minus || state == NumberParsingState::AfterMinus) + { + state = NumberParsingState::ZeroFirst; + } + else if (state == NumberParsingState::Digits || + state == NumberParsingState::DigitsAfterE || + state == NumberParsingState::DigitsAfterPoints) + { + // ok; pass + } + else if (state == NumberParsingState::E) + { + state = NumberParsingState::DigitsAfterE; + } + else + return {};*/ + break; + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + state = static_cast("\3\3\7\3\4\6\6"[state]); + while (*(data + 1) >= '0' && *(data + 1) <= '9') + data++; + /*if (state == NumberParsingState::Minus || state == NumberParsingState::AfterMinus) + { + state = NumberParsingState::Digits; + } + else if (state == NumberParsingState::Digits || + state == NumberParsingState::DigitsAfterE || + state == NumberParsingState::DigitsAfterPoints) + { + // ok; pass + } + else if (state == NumberParsingState::E) + { + state = NumberParsingState::DigitsAfterE; + } + else + return {};*/ + break; + case '.': + state = static_cast("\7\7\4\4\7\7\7"[state]); + /* + if (state == NumberParsingState::Digits || state == NumberParsingState::ZeroFirst) + { + state = NumberParsingState::DigitsAfterPoints; + } + else + return {}; + */ + break; + case '-': + state = static_cast("\1\7\7\7\7\6\7"[state]); + /*if (state == NumberParsingState::Minus) + { + state = NumberParsingState::AfterMinus; + } + else if (state == NumberParsingState::E) + { + state = NumberParsingState::DigitsAfterE; + } + else + return {};*/ + break; + case '+': + state = static_cast("\7\7\7\7\7\6\7"[state]); + /*if (state == NumberParsingState::E) + { + state = NumberParsingState::DigitsAfterE; + } + else + return {};*/ + break; + case 'e': + case 'E': + state = static_cast("\7\7\7\5\5\7\7"[state]); + /*if (state == NumberParsingState::Digits || + state == NumberParsingState::DigitsAfterPoints) + { + state = NumberParsingState::E; + } + else + return {};*/ + break; + default: + if (CROW_LIKELY(state == NumberParsingState::ZeroFirst || + state == NumberParsingState::Digits || + state == NumberParsingState::DigitsAfterPoints || + state == NumberParsingState::DigitsAfterE)) + return {type::Number, start, data}; + else + return {}; + } + data++; + } + + return {}; + } + + + rvalue decode_value(unsigned depth) + { + switch (*data) + { + case '[': + return decode_list(depth + 1); + case '{': + return decode_object(depth + 1); + case '"': + return decode_string(); + case 't': + if ( //e-data >= 4 && + data[1] == 'r' && + data[2] == 'u' && + data[3] == 'e') + { + data += 4; + return {type::True}; + } + else + return {}; + case 'f': + if ( //e-data >= 5 && + data[1] == 'a' && + data[2] == 'l' && + data[3] == 's' && + data[4] == 'e') + { + data += 5; + return {type::False}; + } + else + return {}; + case 'n': + if ( //e-data >= 4 && + data[1] == 'u' && + data[2] == 'l' && + data[3] == 'l') + { + data += 4; + return {type::Null}; + } + else + return {}; + //case '1': case '2': case '3': + //case '4': case '5': case '6': + //case '7': case '8': case '9': + //case '0': case '-': + default: + return decode_number(); + } + return {}; + } + + rvalue decode_object(unsigned depth) + { + rvalue ret(type::Object); + if (CROW_UNLIKELY(!consume('{')) || CROW_UNLIKELY(depth > max_depth)) + { + ret.set_error(); + return ret; + } + + ws_skip(); + + if (CROW_UNLIKELY(*data == '}')) + { + data++; + return ret; + } + + while (1) + { + auto t = decode_string(); + if (CROW_UNLIKELY(!t)) + { + ret.set_error(); + break; + } + + ws_skip(); + if (CROW_UNLIKELY(!consume(':'))) + { + ret.set_error(); + break; + } + + // TODO(ipkn) caching key to speed up (flyweight?) + // I have no idea how flyweight could apply here, but maybe some speedup can happen if we stopped checking type since decode_string returns a string anyway + auto key = t.s(); + + ws_skip(); + auto v = decode_value(depth + 1); + if (CROW_UNLIKELY(!v)) + { + ret.set_error(); + break; + } + ws_skip(); + + v.key_ = std::move(key); + ret.emplace_back(std::move(v)); + if (CROW_UNLIKELY(*data == '}')) + { + data++; + break; + } + if (CROW_UNLIKELY(!consume(','))) + { + ret.set_error(); + break; + } + ws_skip(); + } + return ret; + } + + rvalue parse() + { + ws_skip(); + auto ret = decode_value(0); // or decode object? + ws_skip(); + if (ret && *data != '\0') + ret.set_error(); + return ret; + } + + char* data; + }; + return Parser(data, size).parse(); + } + inline rvalue load(const char* data, size_t size) + { + char* s = new char[size + 1]; + memcpy(s, data, size); + s[size] = 0; + auto ret = load_nocopy_internal(s, size); + if (ret) + ret.key_.force(s, size); + else + delete[] s; + return ret; + } + + inline rvalue load(const char* data) + { + return load(data, strlen(data)); + } + + inline rvalue load(const std::string& str) + { + return load(str.data(), str.size()); + } + + + /// JSON write value. + + /// + /// Value can mean any json value, including a JSON object.
+ /// Write means this class is used to primarily assemble JSON objects using keys and values and export those into a string. + class wvalue : public returnable + { + friend class crow::mustache::template_t; + + public: + using object = +#ifdef CROW_JSON_USE_MAP + std::map; +#else + std::unordered_map; +#endif + + using list = std::vector; + + type t() const { return t_; } + + private: + type t_{type::Null}; ///< The type of the value. + num_type nt{num_type::Null}; ///< The specific type of the number if \ref t_ is a number. + union number + { + double d; + int64_t si; + uint64_t ui; + + public: + constexpr number() noexcept: + ui() {} /* default constructor initializes unsigned integer. */ + constexpr number(std::uint64_t value) noexcept: + ui(value) {} + constexpr number(std::int64_t value) noexcept: + si(value) {} + constexpr number(double value) noexcept: + d(value) {} + } num; ///< Value if type is a number. + std::string s; ///< Value if type is a string. + std::unique_ptr l; ///< Value if type is a list. + std::unique_ptr o; ///< Value if type is a JSON object. + std::function f; ///< Value if type is a function (C++ lambda) + + public: + wvalue(): + returnable("application/json") {} + + wvalue(std::nullptr_t): + returnable("application/json"), t_(type::Null) {} + + wvalue(bool value): + returnable("application/json"), t_(value ? type::True : type::False) {} + + wvalue(std::uint8_t value): + returnable("application/json"), t_(type::Number), nt(num_type::Unsigned_integer), num(static_cast(value)) {} + wvalue(std::uint16_t value): + returnable("application/json"), t_(type::Number), nt(num_type::Unsigned_integer), num(static_cast(value)) {} + wvalue(std::uint32_t value): + returnable("application/json"), t_(type::Number), nt(num_type::Unsigned_integer), num(static_cast(value)) {} + wvalue(std::uint64_t value): + returnable("application/json"), t_(type::Number), nt(num_type::Unsigned_integer), num(static_cast(value)) {} + + wvalue(std::int8_t value): + returnable("application/json"), t_(type::Number), nt(num_type::Signed_integer), num(static_cast(value)) {} + wvalue(std::int16_t value): + returnable("application/json"), t_(type::Number), nt(num_type::Signed_integer), num(static_cast(value)) {} + wvalue(std::int32_t value): + returnable("application/json"), t_(type::Number), nt(num_type::Signed_integer), num(static_cast(value)) {} + wvalue(std::int64_t value): + returnable("application/json"), t_(type::Number), nt(num_type::Signed_integer), num(static_cast(value)) {} + + wvalue(float value): + returnable("application/json"), t_(type::Number), nt(num_type::Floating_point), num(static_cast(value)) {} + wvalue(double value): + returnable("application/json"), t_(type::Number), nt(num_type::Floating_point), num(static_cast(value)) {} + + wvalue(char const* value): + returnable("application/json"), t_(type::String), s(value) {} + + wvalue(std::string const& value): + returnable("application/json"), t_(type::String), s(value) {} + wvalue(std::string&& value): + returnable("application/json"), t_(type::String), s(std::move(value)) {} + + wvalue(std::initializer_list> initializer_list): + returnable("application/json"), t_(type::Object), o(new object(initializer_list)) {} + + wvalue(object const& value): + returnable("application/json"), t_(type::Object), o(new object(value)) {} + wvalue(object&& value): + returnable("application/json"), t_(type::Object), o(new object(std::move(value))) {} + + wvalue(const list& r): + returnable("application/json") + { + t_ = type::List; + l = std::unique_ptr(new list{}); + l->reserve(r.size()); + for (auto it = r.begin(); it != r.end(); ++it) + l->emplace_back(*it); + } + wvalue(list& r): + returnable("application/json") + { + t_ = type::List; + l = std::unique_ptr(new list{}); + l->reserve(r.size()); + for (auto it = r.begin(); it != r.end(); ++it) + l->emplace_back(*it); + } + + /// Create a write value from a read value (useful for editing JSON strings). + wvalue(const rvalue& r): + returnable("application/json") + { + t_ = r.t(); + switch (r.t()) + { + case type::Null: + case type::False: + case type::True: + case type::Function: + return; + case type::Number: + nt = r.nt(); + if (nt == num_type::Floating_point) + num.d = r.d(); + else if (nt == num_type::Signed_integer) + num.si = r.i(); + else + num.ui = r.u(); + return; + case type::String: + s = r.s(); + return; + case type::List: + l = std::unique_ptr(new list{}); + l->reserve(r.size()); + for (auto it = r.begin(); it != r.end(); ++it) + l->emplace_back(*it); + return; + case type::Object: + o = std::unique_ptr(new object{}); + for (auto it = r.begin(); it != r.end(); ++it) + o->emplace(it->key(), *it); + return; + } + } + + wvalue(const wvalue& r): + returnable("application/json") + { + t_ = r.t(); + switch (r.t()) + { + case type::Null: + case type::False: + case type::True: + return; + case type::Number: + nt = r.nt; + if (nt == num_type::Floating_point) + num.d = r.num.d; + else if (nt == num_type::Signed_integer) + num.si = r.num.si; + else + num.ui = r.num.ui; + return; + case type::String: + s = r.s; + return; + case type::List: + l = std::unique_ptr(new list{}); + l->reserve(r.size()); + for (auto it = r.l->begin(); it != r.l->end(); ++it) + l->emplace_back(*it); + return; + case type::Object: + o = std::unique_ptr(new object{}); + o->insert(r.o->begin(), r.o->end()); + return; + case type::Function: + f = r.f; + } + } + + wvalue(wvalue&& r): + returnable("application/json") + { + *this = std::move(r); + } + + wvalue& operator=(wvalue&& r) + { + t_ = r.t_; + num = r.num; + s = std::move(r.s); + l = std::move(r.l); + o = std::move(r.o); + return *this; + } + + /// Used for compatibility, same as \ref reset() + void clear() + { + reset(); + } + + void reset() + { + t_ = type::Null; + l.reset(); + o.reset(); + } + + wvalue& operator=(std::nullptr_t) + { + reset(); + return *this; + } + wvalue& operator=(bool value) + { + reset(); + if (value) + t_ = type::True; + else + t_ = type::False; + return *this; + } + + wvalue& operator=(double value) + { + reset(); + t_ = type::Number; + num.d = value; + nt = num_type::Floating_point; + return *this; + } + + wvalue& operator=(unsigned short value) + { + reset(); + t_ = type::Number; + num.ui = value; + nt = num_type::Unsigned_integer; + return *this; + } + + wvalue& operator=(short value) + { + reset(); + t_ = type::Number; + num.si = value; + nt = num_type::Signed_integer; + return *this; + } + + wvalue& operator=(long long value) + { + reset(); + t_ = type::Number; + num.si = value; + nt = num_type::Signed_integer; + return *this; + } + + wvalue& operator=(long value) + { + reset(); + t_ = type::Number; + num.si = value; + nt = num_type::Signed_integer; + return *this; + } + + wvalue& operator=(int value) + { + reset(); + t_ = type::Number; + num.si = value; + nt = num_type::Signed_integer; + return *this; + } + + wvalue& operator=(unsigned long long value) + { + reset(); + t_ = type::Number; + num.ui = value; + nt = num_type::Unsigned_integer; + return *this; + } + + wvalue& operator=(unsigned long value) + { + reset(); + t_ = type::Number; + num.ui = value; + nt = num_type::Unsigned_integer; + return *this; + } + + wvalue& operator=(unsigned int value) + { + reset(); + t_ = type::Number; + num.ui = value; + nt = num_type::Unsigned_integer; + return *this; + } + + wvalue& operator=(const char* str) + { + reset(); + t_ = type::String; + s = str; + return *this; + } + + wvalue& operator=(const std::string& str) + { + reset(); + t_ = type::String; + s = str; + return *this; + } + + wvalue& operator=(list&& v) + { + if (t_ != type::List) + reset(); + t_ = type::List; + if (!l) + l = std::unique_ptr(new list{}); + l->clear(); + l->resize(v.size()); + size_t idx = 0; + for (auto& x : v) + { + (*l)[idx++] = std::move(x); + } + return *this; + } + + template + wvalue& operator=(const std::vector& v) + { + if (t_ != type::List) + reset(); + t_ = type::List; + if (!l) + l = std::unique_ptr(new list{}); + l->clear(); + l->resize(v.size()); + size_t idx = 0; + for (auto& x : v) + { + (*l)[idx++] = x; + } + return *this; + } + + wvalue& operator=(std::initializer_list> initializer_list) + { + if (t_ != type::Object) + { + reset(); + t_ = type::Object; + o = std::unique_ptr(new object(initializer_list)); + } + else + { +#if defined(__APPLE__) || defined(__MACH__) + o = std::unique_ptr(new object(initializer_list)); +#else + (*o) = initializer_list; +#endif + } + return *this; + } + + wvalue& operator=(object const& value) + { + if (t_ != type::Object) + { + reset(); + t_ = type::Object; + o = std::unique_ptr(new object(value)); + } + else + { +#if defined(__APPLE__) || defined(__MACH__) + o = std::unique_ptr(new object(value)); +#else + (*o) = value; +#endif + } + return *this; + } + + wvalue& operator=(object&& value) + { + if (t_ != type::Object) + { + reset(); + t_ = type::Object; + o = std::unique_ptr(new object(std::move(value))); + } + else + { + (*o) = std::move(value); + } + return *this; + } + + wvalue& operator=(std::function&& func) + { + reset(); + t_ = type::Function; + f = std::move(func); + return *this; + } + + wvalue& operator[](unsigned index) + { + if (t_ != type::List) + reset(); + t_ = type::List; + if (!l) + l = std::unique_ptr(new list{}); + if (l->size() < index + 1) + l->resize(index + 1); + return (*l)[index]; + } + + int count(const std::string& str) + { + if (t_ != type::Object) + return 0; + if (!o) + return 0; + return o->count(str); + } + + wvalue& operator[](const std::string& str) + { + if (t_ != type::Object) + reset(); + t_ = type::Object; + if (!o) + o = std::unique_ptr(new object{}); + return (*o)[str]; + } + + std::vector keys() const + { + if (t_ != type::Object) + return {}; + std::vector result; + for (auto& kv : *o) + { + result.push_back(kv.first); + } + return result; + } + + std::string execute(std::string txt = "") const //Not using reference because it cannot be used with a default rvalue + { + if (t_ != type::Function) + return ""; + return f(txt); + } + + /// If the wvalue is a list, it returns the length of the list, otherwise it returns 1. + std::size_t size() const + { + if (t_ != type::List) + return 1; + return l->size(); + } + + /// Returns an estimated size of the value in bytes. + size_t estimate_length() const + { + switch (t_) + { + case type::Null: return 4; + case type::False: return 5; + case type::True: return 4; + case type::Number: return 30; + case type::String: return 2 + s.size() + s.size() / 2; + case type::List: + { + size_t sum{}; + if (l) + { + for (auto& x : *l) + { + sum += 1; + sum += x.estimate_length(); + } + } + return sum + 2; + } + case type::Object: + { + size_t sum{}; + if (o) + { + for (auto& kv : *o) + { + sum += 2; + sum += 2 + kv.first.size() + kv.first.size() / 2; + sum += kv.second.estimate_length(); + } + } + return sum + 2; + } + case type::Function: + return 0; + } + return 1; + } + + private: + inline void dump_string(const std::string& str, std::string& out) const + { + out.push_back('"'); + escape(str, out); + out.push_back('"'); + } + + inline void dump_internal(const wvalue& v, std::string& out) const + { + switch (v.t_) + { + case type::Null: out += "null"; break; + case type::False: out += "false"; break; + case type::True: out += "true"; break; + case type::Number: + { + if (v.nt == num_type::Floating_point) + { + if (isnan(v.num.d) || isinf(v.num.d)) + { + out += "null"; + CROW_LOG_WARNING << "Invalid JSON value detected (" << v.num.d << "), value set to null"; + break; + } +#ifdef _MSC_VER +#define MSC_COMPATIBLE_SPRINTF(BUFFER_PTR, FORMAT_PTR, VALUE) sprintf_s((BUFFER_PTR), 128, (FORMAT_PTR), (VALUE)) +#else +#define MSC_COMPATIBLE_SPRINTF(BUFFER_PTR, FORMAT_PTR, VALUE) sprintf((BUFFER_PTR), (FORMAT_PTR), (VALUE)) +#endif + enum + { + start, + decp, + zero + } f_state; + char outbuf[128]; + MSC_COMPATIBLE_SPRINTF(outbuf, "%f", v.num.d); + char *p = &outbuf[0], *o = nullptr; + f_state = start; + while (*p != '\0') + { + //std::cout << *p << std::endl; + char ch = *p; + switch (f_state) + { + case start: + if (ch == '.') + { + if (p + 1 && *(p + 1) == '0') p++; + f_state = decp; + } + p++; + break; + case decp: + if (ch == '0') + { + f_state = zero; + o = p; + } + p++; + break; + case zero: + if (ch != '0') + { + o = nullptr; + f_state = decp; + } + p++; + break; + } + } + if (o != nullptr) + *o = '\0'; + out += outbuf; +#undef MSC_COMPATIBLE_SPRINTF + } + else if (v.nt == num_type::Signed_integer) + { + out += std::to_string(v.num.si); + } + else + { + out += std::to_string(v.num.ui); + } + } + break; + case type::String: dump_string(v.s, out); break; + case type::List: + { + out.push_back('['); + if (v.l) + { + bool first = true; + for (auto& x : *v.l) + { + if (!first) + { + out.push_back(','); + } + first = false; + dump_internal(x, out); + } + } + out.push_back(']'); + } + break; + case type::Object: + { + out.push_back('{'); + if (v.o) + { + bool first = true; + for (auto& kv : *v.o) + { + if (!first) + { + out.push_back(','); + } + first = false; + dump_string(kv.first, out); + out.push_back(':'); + dump_internal(kv.second, out); + } + } + out.push_back('}'); + } + break; + + case type::Function: + out += "custom function"; + break; + } + } + + public: + std::string dump() const + { + std::string ret; + ret.reserve(estimate_length()); + dump_internal(*this, ret); + return ret; + } + }; + + + + //std::vector dump_ref(wvalue& v) + //{ + //} + } // namespace json +} // namespace crow + + + +#pragma once +#include +#include +#include +#include +#include + + + + + + + + + +namespace crow +{ + namespace mustache + { + using context = json::wvalue; + + template_t load(const std::string& filename); + + class invalid_template_exception : public std::exception + { + public: + invalid_template_exception(const std::string& msg): + msg("crow::mustache error: " + msg) + {} + virtual const char* what() const throw() + { + return msg.c_str(); + } + std::string msg; + }; + + struct rendered_template : returnable + { + rendered_template(): + returnable("text/html") {} + + rendered_template(std::string& body): + returnable("text/html"), body_(std::move(body)) {} + + std::string body_; + + std::string dump() const override + { + return body_; + } + }; + + enum class ActionType + { + Ignore, + Tag, + UnescapeTag, + OpenBlock, + CloseBlock, + ElseBlock, + Partial, + }; + + struct Action + { + int start; + int end; + int pos; + ActionType t; + Action(ActionType t, size_t start, size_t end, size_t pos = 0): + start(static_cast(start)), end(static_cast(end)), pos(static_cast(pos)), t(t) + { + } + }; + + /// A mustache template object. + class template_t + { + public: + template_t(std::string body): + body_(std::move(body)) + { + // {{ {{# {{/ {{^ {{! {{> {{= + parse(); + } + + private: + std::string tag_name(const Action& action) const + { + return body_.substr(action.start, action.end - action.start); + } + auto find_context(const std::string& name, const std::vector& stack, bool shouldUseOnlyFirstStackValue = false) const -> std::pair + { + if (name == ".") + { + return {true, *stack.back()}; + } + static json::wvalue empty_str; + empty_str = ""; + + int dotPosition = name.find("."); + if (dotPosition == static_cast(name.npos)) + { + for (auto it = stack.rbegin(); it != stack.rend(); ++it) + { + if ((*it)->t() == json::type::Object) + { + if ((*it)->count(name)) + return {true, (**it)[name]}; + } + } + } + else + { + std::vector dotPositions; + dotPositions.push_back(-1); + while (dotPosition != static_cast(name.npos)) + { + dotPositions.push_back(dotPosition); + dotPosition = name.find(".", dotPosition + 1); + } + dotPositions.push_back(name.size()); + std::vector names; + names.reserve(dotPositions.size() - 1); + for (int i = 1; i < static_cast(dotPositions.size()); i++) + names.emplace_back(name.substr(dotPositions[i - 1] + 1, dotPositions[i] - dotPositions[i - 1] - 1)); + + for (auto it = stack.rbegin(); it != stack.rend(); ++it) + { + context* view = *it; + bool found = true; + for (auto jt = names.begin(); jt != names.end(); ++jt) + { + if (view->t() == json::type::Object && + view->count(*jt)) + { + view = &(*view)[*jt]; + } + else + { + if (shouldUseOnlyFirstStackValue) + { + return {false, empty_str}; + } + found = false; + break; + } + } + if (found) + return {true, *view}; + } + } + + return {false, empty_str}; + } + + void escape(const std::string& in, std::string& out) const + { + out.reserve(out.size() + in.size()); + for (auto it = in.begin(); it != in.end(); ++it) + { + switch (*it) + { + case '&': out += "&"; break; + case '<': out += "<"; break; + case '>': out += ">"; break; + case '"': out += """; break; + case '\'': out += "'"; break; + case '/': out += "/"; break; + case '`': out += "`"; break; + case '=': out += "="; break; + default: out += *it; break; + } + } + } + + bool isTagInsideObjectBlock(const int& current, const std::vector& stack) const + { + int openedBlock = 0; + int totalBlocksBefore = 0; + for (int i = current; i > 0; --i) + { + ++totalBlocksBefore; + auto& action = actions_[i - 1]; + + if (action.t == ActionType::OpenBlock) + { + if (openedBlock == 0 && (*stack.rbegin())->t() == json::type::Object) + { + return true; + } + --openedBlock; + } + else if (action.t == ActionType::CloseBlock) + { + ++openedBlock; + } + } + + return false; + } + + void render_internal(int actionBegin, int actionEnd, std::vector& stack, std::string& out, int indent) const + { + int current = actionBegin; + + if (indent) + out.insert(out.size(), indent, ' '); + + while (current < actionEnd) + { + auto& fragment = fragments_[current]; + auto& action = actions_[current]; + render_fragment(fragment, indent, out); + switch (action.t) + { + case ActionType::Ignore: + // do nothing + break; + case ActionType::Partial: + { + std::string partial_name = tag_name(action); + auto partial_templ = load(partial_name); + int partial_indent = action.pos; + partial_templ.render_internal(0, partial_templ.fragments_.size() - 1, stack, out, partial_indent ? indent + partial_indent : 0); + } + break; + case ActionType::UnescapeTag: + case ActionType::Tag: + { + bool shouldUseOnlyFirstStackValue = false; + if (isTagInsideObjectBlock(current, stack)) + { + shouldUseOnlyFirstStackValue = true; + } + auto optional_ctx = find_context(tag_name(action), stack, shouldUseOnlyFirstStackValue); + auto& ctx = optional_ctx.second; + switch (ctx.t()) + { + case json::type::Number: + out += ctx.dump(); + break; + case json::type::String: + if (action.t == ActionType::Tag) + escape(ctx.s, out); + else + out += ctx.s; + break; + case json::type::Function: + { + std::string execute_result = ctx.execute(); + while (execute_result.find("{{") != std::string::npos) + { + template_t result_plug(execute_result); + execute_result = result_plug.render_string(*(stack[0])); + } + + if (action.t == ActionType::Tag) + escape(execute_result, out); + else + out += execute_result; + } + break; + default: + throw std::runtime_error("not implemented tag type" + boost::lexical_cast(static_cast(ctx.t()))); + } + } + break; + case ActionType::ElseBlock: + { + static context nullContext; + auto optional_ctx = find_context(tag_name(action), stack); + if (!optional_ctx.first) + { + stack.emplace_back(&nullContext); + break; + } + + auto& ctx = optional_ctx.second; + switch (ctx.t()) + { + case json::type::List: + if (ctx.l && !ctx.l->empty()) + current = action.pos; + else + stack.emplace_back(&nullContext); + break; + case json::type::False: + case json::type::Null: + stack.emplace_back(&nullContext); + break; + default: + current = action.pos; + break; + } + break; + } + case ActionType::OpenBlock: + { + auto optional_ctx = find_context(tag_name(action), stack); + if (!optional_ctx.first) + { + current = action.pos; + break; + } + + auto& ctx = optional_ctx.second; + switch (ctx.t()) + { + case json::type::List: + if (ctx.l) + for (auto it = ctx.l->begin(); it != ctx.l->end(); ++it) + { + stack.push_back(&*it); + render_internal(current + 1, action.pos, stack, out, indent); + stack.pop_back(); + } + current = action.pos; + break; + case json::type::Number: + case json::type::String: + case json::type::Object: + case json::type::True: + stack.push_back(&ctx); + break; + case json::type::False: + case json::type::Null: + current = action.pos; + break; + default: + throw std::runtime_error("{{#: not implemented context type: " + boost::lexical_cast(static_cast(ctx.t()))); + break; + } + break; + } + case ActionType::CloseBlock: + stack.pop_back(); + break; + default: + throw std::runtime_error("not implemented " + boost::lexical_cast(static_cast(action.t))); + } + current++; + } + auto& fragment = fragments_[actionEnd]; + render_fragment(fragment, indent, out); + } + void render_fragment(const std::pair fragment, int indent, std::string& out) const + { + if (indent) + { + for (int i = fragment.first; i < fragment.second; i++) + { + out += body_[i]; + if (body_[i] == '\n' && i + 1 != static_cast(body_.size())) + out.insert(out.size(), indent, ' '); + } + } + else + out.insert(out.size(), body_, fragment.first, fragment.second - fragment.first); + } + + public: + /// Output a returnable template from this mustache template + rendered_template render() const + { + context empty_ctx; + std::vector stack; + stack.emplace_back(&empty_ctx); + + std::string ret; + render_internal(0, fragments_.size() - 1, stack, ret, 0); + return rendered_template(ret); + } + + /// Apply the values from the context provided and output a returnable template from this mustache template + rendered_template render(context& ctx) const + { + std::vector stack; + stack.emplace_back(&ctx); + + std::string ret; + render_internal(0, fragments_.size() - 1, stack, ret, 0); + return rendered_template(ret); + } + + /// Output a returnable template from this mustache template + std::string render_string() const + { + context empty_ctx; + std::vector stack; + stack.emplace_back(&empty_ctx); + + std::string ret; + render_internal(0, fragments_.size() - 1, stack, ret, 0); + return ret; + } + + /// Apply the values from the context provided and output a returnable template from this mustache template + std::string render_string(context& ctx) const + { + std::vector stack; + stack.emplace_back(&ctx); + + std::string ret; + render_internal(0, fragments_.size() - 1, stack, ret, 0); + return ret; + } + + private: + void parse() + { + std::string tag_open = "{{"; + std::string tag_close = "}}"; + + std::vector blockPositions; + + size_t current = 0; + while (1) + { + size_t idx = body_.find(tag_open, current); + if (idx == body_.npos) + { + fragments_.emplace_back(static_cast(current), static_cast(body_.size())); + actions_.emplace_back(ActionType::Ignore, 0, 0); + break; + } + fragments_.emplace_back(static_cast(current), static_cast(idx)); + + idx += tag_open.size(); + size_t endIdx = body_.find(tag_close, idx); + if (endIdx == idx) + { + throw invalid_template_exception("empty tag is not allowed"); + } + if (endIdx == body_.npos) + { + // error, no matching tag + throw invalid_template_exception("not matched opening tag"); + } + current = endIdx + tag_close.size(); + switch (body_[idx]) + { + case '#': + idx++; + while (body_[idx] == ' ') + idx++; + while (body_[endIdx - 1] == ' ') + endIdx--; + blockPositions.emplace_back(static_cast(actions_.size())); + actions_.emplace_back(ActionType::OpenBlock, idx, endIdx); + break; + case '/': + idx++; + while (body_[idx] == ' ') + idx++; + while (body_[endIdx - 1] == ' ') + endIdx--; + { + auto& matched = actions_[blockPositions.back()]; + if (body_.compare(idx, endIdx - idx, + body_, matched.start, matched.end - matched.start) != 0) + { + throw invalid_template_exception("not matched {{# {{/ pair: " + + body_.substr(matched.start, matched.end - matched.start) + ", " + + body_.substr(idx, endIdx - idx)); + } + matched.pos = actions_.size(); + } + actions_.emplace_back(ActionType::CloseBlock, idx, endIdx, blockPositions.back()); + blockPositions.pop_back(); + break; + case '^': + idx++; + while (body_[idx] == ' ') + idx++; + while (body_[endIdx - 1] == ' ') + endIdx--; + blockPositions.emplace_back(static_cast(actions_.size())); + actions_.emplace_back(ActionType::ElseBlock, idx, endIdx); + break; + case '!': + // do nothing action + actions_.emplace_back(ActionType::Ignore, idx + 1, endIdx); + break; + case '>': // partial + idx++; + while (body_[idx] == ' ') + idx++; + while (body_[endIdx - 1] == ' ') + endIdx--; + actions_.emplace_back(ActionType::Partial, idx, endIdx); + break; + case '{': + if (tag_open != "{{" || tag_close != "}}") + throw invalid_template_exception("cannot use triple mustache when delimiter changed"); + + idx++; + if (body_[endIdx + 2] != '}') + { + throw invalid_template_exception("{{{: }}} not matched"); + } + while (body_[idx] == ' ') + idx++; + while (body_[endIdx - 1] == ' ') + endIdx--; + actions_.emplace_back(ActionType::UnescapeTag, idx, endIdx); + current++; + break; + case '&': + idx++; + while (body_[idx] == ' ') + idx++; + while (body_[endIdx - 1] == ' ') + endIdx--; + actions_.emplace_back(ActionType::UnescapeTag, idx, endIdx); + break; + case '=': + // tag itself is no-op + idx++; + actions_.emplace_back(ActionType::Ignore, idx, endIdx); + endIdx--; + if (body_[endIdx] != '=') + throw invalid_template_exception("{{=: not matching = tag: " + body_.substr(idx, endIdx - idx)); + endIdx--; + while (body_[idx] == ' ') + idx++; + while (body_[endIdx] == ' ') + endIdx--; + endIdx++; + { + bool succeeded = false; + for (size_t i = idx; i < endIdx; i++) + { + if (body_[i] == ' ') + { + tag_open = body_.substr(idx, i - idx); + while (body_[i] == ' ') + i++; + tag_close = body_.substr(i, endIdx - i); + if (tag_open.empty()) + throw invalid_template_exception("{{=: empty open tag"); + if (tag_close.empty()) + throw invalid_template_exception("{{=: empty close tag"); + + if (tag_close.find(" ") != tag_close.npos) + throw invalid_template_exception("{{=: invalid open/close tag: " + tag_open + " " + tag_close); + succeeded = true; + break; + } + } + if (!succeeded) + throw invalid_template_exception("{{=: cannot find space between new open/close tags"); + } + break; + default: + // normal tag case; + while (body_[idx] == ' ') + idx++; + while (body_[endIdx - 1] == ' ') + endIdx--; + actions_.emplace_back(ActionType::Tag, idx, endIdx); + break; + } + } + + // removing standalones + for (int i = actions_.size() - 2; i >= 0; i--) + { + if (actions_[i].t == ActionType::Tag || actions_[i].t == ActionType::UnescapeTag) + continue; + auto& fragment_before = fragments_[i]; + auto& fragment_after = fragments_[i + 1]; + bool is_last_action = i == static_cast(actions_.size()) - 2; + bool all_space_before = true; + int j, k; + for (j = fragment_before.second - 1; j >= fragment_before.first; j--) + { + if (body_[j] != ' ') + { + all_space_before = false; + break; + } + } + if (all_space_before && i > 0) + continue; + if (!all_space_before && body_[j] != '\n') + continue; + bool all_space_after = true; + for (k = fragment_after.first; k < static_cast(body_.size()) && k < fragment_after.second; k++) + { + if (body_[k] != ' ') + { + all_space_after = false; + break; + } + } + if (all_space_after && !is_last_action) + continue; + if (!all_space_after && + !( + body_[k] == '\n' || + (body_[k] == '\r' && + k + 1 < static_cast(body_.size()) && + body_[k + 1] == '\n'))) + continue; + if (actions_[i].t == ActionType::Partial) + { + actions_[i].pos = fragment_before.second - j - 1; + } + fragment_before.second = j + 1; + if (!all_space_after) + { + if (body_[k] == '\n') + k++; + else + k += 2; + fragment_after.first = k; + } + } + } + + std::vector> fragments_; + std::vector actions_; + std::string body_; + }; + + inline template_t compile(const std::string& body) + { + return template_t(body); + } + namespace detail + { + inline std::string& get_template_base_directory_ref() + { + static std::string template_base_directory = "templates"; + return template_base_directory; + } + + /// A base directory not related to any blueprint + inline std::string& get_global_template_base_directory_ref() + { + static std::string template_base_directory = "templates"; + return template_base_directory; + } + } // namespace detail + + inline std::string default_loader(const std::string& filename) + { + std::string path = detail::get_template_base_directory_ref(); + if (!(path.back() == '/' || path.back() == '\\')) + path += '/'; + path += filename; + std::ifstream inf(path); + if (!inf) + { + CROW_LOG_WARNING << "Template \"" << filename << "\" not found."; + return {}; + } + return {std::istreambuf_iterator(inf), std::istreambuf_iterator()}; + } + + namespace detail + { + inline std::function& get_loader_ref() + { + static std::function loader = default_loader; + return loader; + } + } // namespace detail + + inline void set_base(const std::string& path) + { + auto& base = detail::get_template_base_directory_ref(); + base = path; + if (base.back() != '\\' && + base.back() != '/') + { + base += '/'; + } + } + + inline void set_global_base(const std::string& path) + { + auto& base = detail::get_global_template_base_directory_ref(); + base = path; + if (base.back() != '\\' && + base.back() != '/') + { + base += '/'; + } + } + + inline void set_loader(std::function loader) + { + detail::get_loader_ref() = std::move(loader); + } + + inline std::string load_text(const std::string& filename) + { + std::string filename_sanitized(filename); + utility::sanitize_filename(filename_sanitized); + return detail::get_loader_ref()(filename_sanitized); + } + + inline std::string load_text_unsafe(const std::string& filename) + { + return detail::get_loader_ref()(filename); + } + + inline template_t load(const std::string& filename) + { + std::string filename_sanitized(filename); + utility::sanitize_filename(filename_sanitized); + return compile(detail::get_loader_ref()(filename_sanitized)); + } + + inline template_t load_unsafe(const std::string& filename) + { + return compile(detail::get_loader_ref()(filename)); + } + } // namespace mustache +} // namespace crow + + + +#pragma once + +#include +#include +#include +#include +#include +#include +#include + + + + + + + + + + + + + + + + + + +namespace crow +{ + + constexpr const uint16_t INVALID_BP_ID{((uint16_t)-1)}; + + /// A base class for all rules. + + /// + /// Used to provide a common interface for code dealing with different types of rules.
+ /// A Rule provides a URL, allowed HTTP methods, and handlers. + class BaseRule + { + public: + BaseRule(std::string rule): + rule_(std::move(rule)) + {} + + virtual ~BaseRule() + {} + + virtual void validate() = 0; + std::unique_ptr upgrade() + { + if (rule_to_upgrade_) + return std::move(rule_to_upgrade_); + return {}; + } + + virtual void handle(request&, response&, const routing_params&) = 0; + virtual void handle_upgrade(const request&, response& res, SocketAdaptor&&) + { + res = response(404); + res.end(); + } +#ifdef CROW_ENABLE_SSL + virtual void handle_upgrade(const request&, response& res, SSLAdaptor&&) + { + res = response(404); + res.end(); + } +#endif + + uint32_t get_methods() + { + return methods_; + } + + template + void foreach_method(F f) + { + for (uint32_t method = 0, method_bit = 1; method < static_cast(HTTPMethod::InternalMethodCount); method++, method_bit <<= 1) + { + if (methods_ & method_bit) + f(method); + } + } + + + std::string custom_templates_base; + + const std::string& rule() { return rule_; } + + protected: + uint32_t methods_{1 << static_cast(HTTPMethod::Get)}; + + std::string rule_; + std::string name_; + + std::unique_ptr rule_to_upgrade_; + + friend class Router; + friend class Blueprint; + template + friend struct RuleParameterTraits; + }; + + + namespace detail + { + namespace routing_handler_call_helper + { + template + struct call_pair + { + using type = T; + static const int pos = Pos; + }; + + template + struct call_params + { + H1& handler; + const routing_params& params; + request& req; + response& res; + }; + + template + struct call + {}; + + template + struct call, black_magic::S> + { + void operator()(F cparams) + { + using pushed = typename black_magic::S::template push_back>; + call, pushed>()(cparams); + } + }; + + template + struct call, black_magic::S> + { + void operator()(F cparams) + { + using pushed = typename black_magic::S::template push_back>; + call, pushed>()(cparams); + } + }; + + template + struct call, black_magic::S> + { + void operator()(F cparams) + { + using pushed = typename black_magic::S::template push_back>; + call, pushed>()(cparams); + } + }; + + template + struct call, black_magic::S> + { + void operator()(F cparams) + { + using pushed = typename black_magic::S::template push_back>; + call, pushed>()(cparams); + } + }; + + template + struct call, black_magic::S> + { + void operator()(F cparams) + { + cparams.handler( + cparams.req, + cparams.res, + cparams.params.template get(Args1::pos)...); + } + }; + + template + struct Wrapped + { + template + void set_(Func f, typename std::enable_if>::type, const request&>::value, int>::type = 0) + { + handler_ = ( +#ifdef CROW_CAN_USE_CPP14 + [f = std::move(f)] +#else + [f] +#endif + (const request&, response& res, Args... args) { + res = response(f(args...)); + res.end(); + }); + } + + template + struct req_handler_wrapper + { + req_handler_wrapper(Func f): + f(std::move(f)) + { + } + + void operator()(const request& req, response& res, Args... args) + { + res = response(f(req, args...)); + res.end(); + } + + Func f; + }; + + template + void set_(Func f, typename std::enable_if< + std::is_same>::type, const request&>::value && + !std::is_same>::type, response&>::value, + int>::type = 0) + { + handler_ = req_handler_wrapper(std::move(f)); + /*handler_ = ( + [f = std::move(f)] + (const request& req, response& res, Args... args){ + res = response(f(req, args...)); + res.end(); + });*/ + } + + template + void set_(Func f, typename std::enable_if< + std::is_same>::type, const request&>::value && + std::is_same>::type, response&>::value, + int>::type = 0) + { + handler_ = std::move(f); + } + + template + struct handler_type_helper + { + using type = std::function; + using args_type = black_magic::S...>; + }; + + template + struct handler_type_helper + { + using type = std::function; + using args_type = black_magic::S...>; + }; + + template + struct handler_type_helper + { + using type = std::function; + using args_type = black_magic::S...>; + }; + + typename handler_type_helper::type handler_; + + void operator()(request& req, response& res, const routing_params& params) + { + detail::routing_handler_call_helper::call< + detail::routing_handler_call_helper::call_params< + decltype(handler_)>, + 0, 0, 0, 0, + typename handler_type_helper::args_type, + black_magic::S<>>()( + detail::routing_handler_call_helper::call_params< + decltype(handler_)>{handler_, params, req, res}); + } + }; + + } // namespace routing_handler_call_helper + } // namespace detail + + + class CatchallRule + { + public: + /// @cond SKIP + CatchallRule() {} + + template + typename std::enable_if>::value, void>::type + operator()(Func&& f) + { + static_assert(!std::is_same::value, + "Handler function cannot have void return type; valid return types: string, int, crow::response, crow::returnable"); + + handler_ = ( +#ifdef CROW_CAN_USE_CPP14 + [f = std::move(f)] +#else + [f] +#endif + (const request&, response& res) { + res = response(f()); + res.end(); + }); + } + + template + typename std::enable_if< + !black_magic::CallHelper>::value && + black_magic::CallHelper>::value, + void>::type + operator()(Func&& f) + { + static_assert(!std::is_same()))>::value, + "Handler function cannot have void return type; valid return types: string, int, crow::response, crow::returnable"); + + handler_ = ( +#ifdef CROW_CAN_USE_CPP14 + [f = std::move(f)] +#else + [f] +#endif + (const crow::request& req, crow::response& res) { + res = response(f(req)); + res.end(); + }); + } + + template + typename std::enable_if< + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value && + black_magic::CallHelper>::value, + void>::type + operator()(Func&& f) + { + static_assert(std::is_same()))>::value, + "Handler function with response argument should have void return type"); + handler_ = ( +#ifdef CROW_CAN_USE_CPP14 + [f = std::move(f)] +#else + [f] +#endif + (const crow::request&, crow::response& res) { + f(res); + }); + } + + template + typename std::enable_if< + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value && + !black_magic::CallHelper>::value, + void>::type + operator()(Func&& f) + { + static_assert(std::is_same(), std::declval()))>::value, + "Handler function with response argument should have void return type"); + + handler_ = std::move(f); + } + /// @endcond + bool has_handler() + { + return (handler_ != nullptr); + } + + protected: + friend class Router; + + private: + std::function handler_; + }; + + + /// A rule dealing with websockets. + + /// + /// Provides the interface for the user to put in the necessary handlers for a websocket to work. + class WebSocketRule : public BaseRule + { + using self_t = WebSocketRule; + + public: + WebSocketRule(std::string rule): + BaseRule(std::move(rule)) + {} + + void validate() override + {} + + void handle(request&, response& res, const routing_params&) override + { + res = response(404); + res.end(); + } + + void handle_upgrade(const request& req, response&, SocketAdaptor&& adaptor) override + { + new crow::websocket::Connection(req, std::move(adaptor), open_handler_, message_handler_, close_handler_, error_handler_, accept_handler_); + } +#ifdef CROW_ENABLE_SSL + void handle_upgrade(const request& req, response&, SSLAdaptor&& adaptor) override + { + new crow::websocket::Connection(req, std::move(adaptor), open_handler_, message_handler_, close_handler_, error_handler_, accept_handler_); + } +#endif + + template + self_t& onopen(Func f) + { + open_handler_ = f; + return *this; + } + + template + self_t& onmessage(Func f) + { + message_handler_ = f; + return *this; + } + + template + self_t& onclose(Func f) + { + close_handler_ = f; + return *this; + } + + template + self_t& onerror(Func f) + { + error_handler_ = f; + return *this; + } + + template + self_t& onaccept(Func f) + { + accept_handler_ = f; + return *this; + } + + protected: + std::function open_handler_; + std::function message_handler_; + std::function close_handler_; + std::function error_handler_; + std::function accept_handler_; + }; + + /// Allows the user to assign parameters using functions. + + /// + /// `rule.name("name").methods(HTTPMethod::POST)` + template + struct RuleParameterTraits + { + using self_t = T; + WebSocketRule& websocket() + { + auto p = new WebSocketRule(static_cast(this)->rule_); + static_cast(this)->rule_to_upgrade_.reset(p); + return *p; + } + + self_t& name(std::string name) noexcept + { + static_cast(this)->name_ = std::move(name); + return static_cast(*this); + } + + self_t& methods(HTTPMethod method) + { + static_cast(this)->methods_ = 1 << static_cast(method); + return static_cast(*this); + } + + template + self_t& methods(HTTPMethod method, MethodArgs... args_method) + { + methods(args_method...); + static_cast(this)->methods_ |= 1 << static_cast(method); + return static_cast(*this); + } + }; + + /// A rule that can change its parameters during runtime. + class DynamicRule : public BaseRule, public RuleParameterTraits + { + public: + DynamicRule(std::string rule): + BaseRule(std::move(rule)) + {} + + void validate() override + { + if (!erased_handler_) + { + throw std::runtime_error(name_ + (!name_.empty() ? ": " : "") + "no handler for url " + rule_); + } + } + + void handle(request& req, response& res, const routing_params& params) override + { + if (!custom_templates_base.empty()) + mustache::set_base(custom_templates_base); + else if (mustache::detail::get_template_base_directory_ref() != "templates") + mustache::set_base("templates"); + erased_handler_(req, res, params); + } + + template + void operator()(Func f) + { +#ifdef CROW_MSVC_WORKAROUND + using function_t = utility::function_traits; +#else + using function_t = utility::function_traits; +#endif + erased_handler_ = wrap(std::move(f), black_magic::gen_seq()); + } + + // enable_if Arg1 == request && Arg2 == response + // enable_if Arg1 == request && Arg2 != resposne + // enable_if Arg1 != request +#ifdef CROW_MSVC_WORKAROUND + template +#else + template +#endif + std::function + wrap(Func f, black_magic::seq) + { +#ifdef CROW_MSVC_WORKAROUND + using function_t = utility::function_traits; +#else + using function_t = utility::function_traits; +#endif + if (!black_magic::is_parameter_tag_compatible( + black_magic::get_parameter_tag_runtime(rule_.c_str()), + black_magic::compute_parameter_tag_from_args_list< + typename function_t::template arg...>::value)) + { + throw std::runtime_error("route_dynamic: Handler type is mismatched with URL parameters: " + rule_); + } + auto ret = detail::routing_handler_call_helper::Wrapped...>(); + ret.template set_< + typename function_t::template arg...>(std::move(f)); + return ret; + } + + template + void operator()(std::string name, Func&& f) + { + name_ = std::move(name); + (*this).template operator()(std::forward(f)); + } + + private: + std::function erased_handler_; + }; + + /// Default rule created when CROW_ROUTE is called. + template + class TaggedRule : public BaseRule, public RuleParameterTraits> + { + public: + using self_t = TaggedRule; + + TaggedRule(std::string rule): + BaseRule(std::move(rule)) + {} + + void validate() override + { + if (!handler_) + { + throw std::runtime_error(name_ + (!name_.empty() ? ": " : "") + "no handler for url " + rule_); + } + } + + template + void operator()(Func&& f) + { + handler_ = ( +#ifdef CROW_CAN_USE_CPP14 + [f = std::move(f)] +#else + [f] +#endif + (crow::request& req, crow::response& res, Args... args) { + detail::wrapped_handler_call(req, res, f, std::forward(args)...); + }); + } + + template + void operator()(std::string name, Func&& f) + { + name_ = std::move(name); + (*this).template operator()(std::forward(f)); + } + + void handle(request& req, response& res, const routing_params& params) override + { + if (!custom_templates_base.empty()) + mustache::set_base(custom_templates_base); + else if (mustache::detail::get_template_base_directory_ref() != mustache::detail::get_global_template_base_directory_ref()) + mustache::set_base(mustache::detail::get_global_template_base_directory_ref()); + + detail::routing_handler_call_helper::call< + detail::routing_handler_call_helper::call_params, + 0, 0, 0, 0, + black_magic::S, + black_magic::S<>>()( + detail::routing_handler_call_helper::call_params{handler_, params, req, res}); + } + + /// Enable local middleware for this handler + template + crow::detail::handler_call_bridge, App, Middlewares...> + middlewares() + { + // the handler_call_bridge allows the functor to be placed directly after this function + // instead of wrapping it with more parentheses + return {this}; + } + + private: + std::function handler_; + }; + + const int RULE_SPECIAL_REDIRECT_SLASH = 1; + + + /// A search tree. + class Trie + { + public: + struct Node + { + uint16_t rule_index{}; + // Assign the index to the maximum 32 unsigned integer value by default so that any other number (specifically 0) is a valid BP id. + uint16_t blueprint_index{INVALID_BP_ID}; + std::string key; + ParamType param = ParamType::MAX; // MAX = No param. + std::vector children; + + bool IsSimpleNode() const + { + return !rule_index && + blueprint_index == INVALID_BP_ID && + children.size() < 2 && + param == ParamType::MAX && + std::all_of(std::begin(children), std::end(children), [](Node* x) { + return x->param == ParamType::MAX; + }); + } + }; + + + Trie() + {} + + /// Check whether or not the trie is empty. + bool is_empty() + { + return head_.children.empty(); + } + + void optimize() + { + for (auto child : head_.children) + { + optimizeNode(child); + } + } + + + private: + void optimizeNode(Node* node) + { + if (node->children.empty()) + return; + if (node->IsSimpleNode()) + { + Node* child_temp = node->children[0]; + node->key = node->key + child_temp->key; + node->rule_index = child_temp->rule_index; + node->blueprint_index = child_temp->blueprint_index; + node->children = std::move(child_temp->children); + delete (child_temp); + optimizeNode(node); + } + else + { + for (auto& child : node->children) + { + optimizeNode(child); + } + } + } + + void debug_node_print(Node* node, int level) + { + if (node->param != ParamType::MAX) + { + switch (node->param) + { + case ParamType::INT: + CROW_LOG_DEBUG << std::string(2 * level, ' ') << ""; + break; + case ParamType::UINT: + CROW_LOG_DEBUG << std::string(2 * level, ' ') << ""; + break; + case ParamType::DOUBLE: + CROW_LOG_DEBUG << std::string(2 * level, ' ') << ""; + break; + case ParamType::STRING: + CROW_LOG_DEBUG << std::string(2 * level, ' ') << ""; + break; + case ParamType::PATH: + CROW_LOG_DEBUG << std::string(2 * level, ' ') << ""; + break; + default: + CROW_LOG_DEBUG << std::string(2 * level, ' ') << ""; + break; + } + } + else + CROW_LOG_DEBUG << std::string(2 * level, ' ') << node->key; + + for (auto& child : node->children) + { + debug_node_print(child, level + 1); + } + } + + public: + void debug_print() + { + CROW_LOG_DEBUG << "HEAD"; + for (auto& child : head_.children) + debug_node_print(child, 1); + } + + void validate() + { + if (!head_.IsSimpleNode()) + throw std::runtime_error("Internal error: Trie header should be simple!"); + optimize(); + } + + //Rule_index, Blueprint_index, routing_params + std::tuple, routing_params> find(const std::string& req_url, const Node* node = nullptr, unsigned pos = 0, routing_params* params = nullptr, std::vector* blueprints = nullptr) const + { + //start params as an empty struct + routing_params empty; + if (params == nullptr) + params = ∅ + //same for blueprint vector + std::vector MT; + if (blueprints == nullptr) + blueprints = &MT; + + uint16_t found{}; //The rule index to be found + std::vector found_BP; //The Blueprint indices to be found + routing_params match_params; //supposedly the final matched parameters + + //start from the head node + if (node == nullptr) + node = &head_; + + auto update_found = [&found, &found_BP, &match_params](std::tuple, routing_params>& ret) { + found_BP = std::move(std::get<1>(ret)); + if (std::get<0>(ret) && (!found || found > std::get<0>(ret))) + { + found = std::get<0>(ret); + match_params = std::move(std::get<2>(ret)); + } + }; + + //if the function was called on a node at the end of the string (the last recursion), return the nodes rule index, and whatever params were passed to the function + if (pos == req_url.size()) + { + found_BP = std::move(*blueprints); + return std::tuple, routing_params>{node->rule_index, *blueprints, *params}; + } + + bool found_fragment = false; + + for (auto& child : node->children) + { + if (child->param != ParamType::MAX) + { + if (child->param == ParamType::INT) + { + char c = req_url[pos]; + if ((c >= '0' && c <= '9') || c == '+' || c == '-') + { + char* eptr; + errno = 0; + long long int value = strtoll(req_url.data() + pos, &eptr, 10); + if (errno != ERANGE && eptr != req_url.data() + pos) + { + found_fragment = true; + params->int_params.push_back(value); + if (child->blueprint_index != INVALID_BP_ID) blueprints->push_back(child->blueprint_index); + auto ret = find(req_url, child, eptr - req_url.data(), params, blueprints); + update_found(ret); + params->int_params.pop_back(); + if (!blueprints->empty()) blueprints->pop_back(); + } + } + } + + else if (child->param == ParamType::UINT) + { + char c = req_url[pos]; + if ((c >= '0' && c <= '9') || c == '+') + { + char* eptr; + errno = 0; + unsigned long long int value = strtoull(req_url.data() + pos, &eptr, 10); + if (errno != ERANGE && eptr != req_url.data() + pos) + { + found_fragment = true; + params->uint_params.push_back(value); + if (child->blueprint_index != INVALID_BP_ID) blueprints->push_back(child->blueprint_index); + auto ret = find(req_url, child, eptr - req_url.data(), params, blueprints); + update_found(ret); + params->uint_params.pop_back(); + if (!blueprints->empty()) blueprints->pop_back(); + } + } + } + + else if (child->param == ParamType::DOUBLE) + { + char c = req_url[pos]; + if ((c >= '0' && c <= '9') || c == '+' || c == '-' || c == '.') + { + char* eptr; + errno = 0; + double value = strtod(req_url.data() + pos, &eptr); + if (errno != ERANGE && eptr != req_url.data() + pos) + { + found_fragment = true; + params->double_params.push_back(value); + if (child->blueprint_index != INVALID_BP_ID) blueprints->push_back(child->blueprint_index); + auto ret = find(req_url, child, eptr - req_url.data(), params, blueprints); + update_found(ret); + params->double_params.pop_back(); + if (!blueprints->empty()) blueprints->pop_back(); + } + } + } + + else if (child->param == ParamType::STRING) + { + size_t epos = pos; + for (; epos < req_url.size(); epos++) + { + if (req_url[epos] == '/') + break; + } + + if (epos != pos) + { + found_fragment = true; + params->string_params.push_back(req_url.substr(pos, epos - pos)); + if (child->blueprint_index != INVALID_BP_ID) blueprints->push_back(child->blueprint_index); + auto ret = find(req_url, child, epos, params, blueprints); + update_found(ret); + params->string_params.pop_back(); + if (!blueprints->empty()) blueprints->pop_back(); + } + } + + else if (child->param == ParamType::PATH) + { + size_t epos = req_url.size(); + + if (epos != pos) + { + found_fragment = true; + params->string_params.push_back(req_url.substr(pos, epos - pos)); + if (child->blueprint_index != INVALID_BP_ID) blueprints->push_back(child->blueprint_index); + auto ret = find(req_url, child, epos, params, blueprints); + update_found(ret); + params->string_params.pop_back(); + if (!blueprints->empty()) blueprints->pop_back(); + } + } + } + + else + { + const std::string& fragment = child->key; + if (req_url.compare(pos, fragment.size(), fragment) == 0) + { + found_fragment = true; + if (child->blueprint_index != INVALID_BP_ID) blueprints->push_back(child->blueprint_index); + auto ret = find(req_url, child, pos + fragment.size(), params, blueprints); + update_found(ret); + if (!blueprints->empty()) blueprints->pop_back(); + } + } + } + + if (!found_fragment) + found_BP = std::move(*blueprints); + + return std::tuple, routing_params>{found, found_BP, match_params}; //Called after all the recursions have been done + } + + //This functions assumes any blueprint info passed is valid + void add(const std::string& url, uint16_t rule_index, unsigned bp_prefix_length = 0, uint16_t blueprint_index = INVALID_BP_ID) + { + Node* idx = &head_; + + bool has_blueprint = bp_prefix_length != 0 && blueprint_index != INVALID_BP_ID; + + for (unsigned i = 0; i < url.size(); i++) + { + char c = url[i]; + if (c == '<') + { + static struct ParamTraits + { + ParamType type; + std::string name; + } paramTraits[] = + { + {ParamType::INT, ""}, + {ParamType::UINT, ""}, + {ParamType::DOUBLE, ""}, + {ParamType::DOUBLE, ""}, + {ParamType::STRING, ""}, + {ParamType::STRING, ""}, + {ParamType::PATH, ""}, + }; + + for (auto& x : paramTraits) + { + if (url.compare(i, x.name.size(), x.name) == 0) + { + bool found = false; + for (Node* child : idx->children) + { + if (child->param == x.type) + { + idx = child; + i += x.name.size(); + found = true; + break; + } + } + if (found) + break; + + auto new_node_idx = new_node(idx); + new_node_idx->param = x.type; + idx = new_node_idx; + i += x.name.size(); + break; + } + } + + i--; + } + else + { + //This part assumes the tree is unoptimized (every node has a max 1 character key) + bool piece_found = false; + for (auto& child : idx->children) + { + if (child->key[0] == c) + { + idx = child; + piece_found = true; + break; + } + } + if (!piece_found) + { + auto new_node_idx = new_node(idx); + new_node_idx->key = c; + //The assumption here is that you'd only need to add a blueprint index if the tree didn't have the BP prefix. + if (has_blueprint && i == bp_prefix_length) + new_node_idx->blueprint_index = blueprint_index; + idx = new_node_idx; + } + } + } + + //check if the last node already has a value (exact url already in Trie) + if (idx->rule_index) + throw std::runtime_error("handler already exists for " + url); + idx->rule_index = rule_index; + } + + size_t get_size() + { + return get_size(&head_); + } + + size_t get_size(Node* node) + { + unsigned size = 5; //rule_index, blueprint_index, and param + size += (node->key.size()); //each character in the key is 1 byte + for (auto child : node->children) + { + size += get_size(child); + } + return size; + } + + + private: + Node* new_node(Node* parent) + { + auto& children = parent->children; + children.resize(children.size() + 1); + children[children.size() - 1] = new Node(); + return children[children.size() - 1]; + } + + + Node head_; + }; + + /// A blueprint can be considered a smaller section of a Crow app, specifically where the router is conecerned. + + /// + /// You can use blueprints to assign a common prefix to rules' prefix, set custom static and template folders, and set a custom catchall route. + /// You can also assign nest blueprints for maximum Compartmentalization. + class Blueprint + { + public: + Blueprint(const std::string& prefix): + prefix_(prefix){}; + + Blueprint(const std::string& prefix, const std::string& static_dir): + prefix_(prefix), static_dir_(static_dir){}; + + Blueprint(const std::string& prefix, const std::string& static_dir, const std::string& templates_dir): + prefix_(prefix), static_dir_(static_dir), templates_dir_(templates_dir){}; + + /* + Blueprint(Blueprint& other) + { + prefix_ = std::move(other.prefix_); + all_rules_ = std::move(other.all_rules_); + } + + Blueprint(const Blueprint& other) + { + prefix_ = other.prefix_; + all_rules_ = other.all_rules_; + } +*/ + Blueprint(Blueprint&& value) + { + *this = std::move(value); + } + + Blueprint& operator=(const Blueprint& value) = delete; + + Blueprint& operator=(Blueprint&& value) noexcept + { + prefix_ = std::move(value.prefix_); + all_rules_ = std::move(value.all_rules_); + catchall_rule_ = std::move(value.catchall_rule_); + return *this; + } + + bool operator==(const Blueprint& value) + { + return value.prefix() == prefix_; + } + + bool operator!=(const Blueprint& value) + { + return value.prefix() != prefix_; + } + + std::string prefix() const + { + return prefix_; + } + + std::string static_dir() const + { + return static_dir_; + } + + DynamicRule& new_rule_dynamic(std::string&& rule) + { + std::string new_rule = std::move(rule); + new_rule = '/' + prefix_ + new_rule; + auto ruleObject = new DynamicRule(new_rule); + ruleObject->custom_templates_base = templates_dir_; + all_rules_.emplace_back(ruleObject); + + return *ruleObject; + } + + template + typename black_magic::arguments::type::template rebind& new_rule_tagged(std::string&& rule) + { + std::string new_rule = std::move(rule); + new_rule = '/' + prefix_ + new_rule; + using RuleT = typename black_magic::arguments::type::template rebind; + + auto ruleObject = new RuleT(new_rule); + ruleObject->custom_templates_base = templates_dir_; + all_rules_.emplace_back(ruleObject); + + return *ruleObject; + } + + void register_blueprint(Blueprint& blueprint) + { + if (blueprints_.empty() || std::find(blueprints_.begin(), blueprints_.end(), &blueprint) == blueprints_.end()) + { + apply_blueprint(blueprint); + blueprints_.emplace_back(&blueprint); + } + else + throw std::runtime_error("blueprint \"" + blueprint.prefix_ + "\" already exists in blueprint \"" + prefix_ + '\"'); + } + + + CatchallRule& catchall_rule() + { + return catchall_rule_; + } + + private: + void apply_blueprint(Blueprint& blueprint) + { + + blueprint.prefix_ = prefix_ + '/' + blueprint.prefix_; + blueprint.static_dir_ = static_dir_ + '/' + blueprint.static_dir_; + blueprint.templates_dir_ = templates_dir_ + '/' + blueprint.templates_dir_; + for (auto& rule : blueprint.all_rules_) + { + std::string new_rule = '/' + prefix_ + rule->rule_; + rule->rule_ = new_rule; + } + for (Blueprint* bp_child : blueprint.blueprints_) + { + Blueprint& bp_ref = *bp_child; + apply_blueprint(bp_ref); + } + } + + std::string prefix_; + std::string static_dir_; + std::string templates_dir_; + std::vector> all_rules_; + CatchallRule catchall_rule_; + std::vector blueprints_; + + friend class Router; + }; + + /// Handles matching requests to existing rules and upgrade requests. + class Router + { + public: + Router() + {} + + DynamicRule& new_rule_dynamic(const std::string& rule) + { + auto ruleObject = new DynamicRule(rule); + all_rules_.emplace_back(ruleObject); + + return *ruleObject; + } + + template + typename black_magic::arguments::type::template rebind& new_rule_tagged(const std::string& rule) + { + using RuleT = typename black_magic::arguments::type::template rebind; + + auto ruleObject = new RuleT(rule); + all_rules_.emplace_back(ruleObject); + + return *ruleObject; + } + + CatchallRule& catchall_rule() + { + return catchall_rule_; + } + + void internal_add_rule_object(const std::string& rule, BaseRule* ruleObject, const uint16_t& BP_index, std::vector& blueprints) + { + bool has_trailing_slash = false; + std::string rule_without_trailing_slash; + if (rule.size() > 1 && rule.back() == '/') + { + has_trailing_slash = true; + rule_without_trailing_slash = rule; + rule_without_trailing_slash.pop_back(); + } + + ruleObject->foreach_method([&](int method) { + per_methods_[method].rules.emplace_back(ruleObject); + per_methods_[method].trie.add(rule, per_methods_[method].rules.size() - 1, BP_index != INVALID_BP_ID ? blueprints[BP_index]->prefix().length() : 0, BP_index); + + // directory case: + // request to '/about' url matches '/about/' rule + if (has_trailing_slash) + { + per_methods_[method].trie.add(rule_without_trailing_slash, RULE_SPECIAL_REDIRECT_SLASH, BP_index != INVALID_BP_ID ? blueprints_[BP_index]->prefix().length() : 0, BP_index); + } + }); + } + + void register_blueprint(Blueprint& blueprint) + { + if (std::find(blueprints_.begin(), blueprints_.end(), &blueprint) == blueprints_.end()) + { + blueprints_.emplace_back(&blueprint); + } + else + throw std::runtime_error("blueprint \"" + blueprint.prefix_ + "\" already exists in router"); + } + + void get_recursive_child_methods(Blueprint* blueprint, std::vector& methods) + { + //we only need to deal with children if the blueprint has absolutely no methods (meaning its index won't be added to the trie) + if (blueprint->static_dir_.empty() && blueprint->all_rules_.empty()) + { + for (Blueprint* bp : blueprint->blueprints_) + { + get_recursive_child_methods(bp, methods); + } + } + else if (!blueprint->static_dir_.empty()) + methods.emplace_back(HTTPMethod::Get); + for (auto& rule : blueprint->all_rules_) + { + rule->foreach_method([&methods](unsigned method) { + HTTPMethod method_final = static_cast(method); + if (std::find(methods.begin(), methods.end(), method_final) == methods.end()) + methods.emplace_back(method_final); + }); + } + } + + void validate_bp(std::vector blueprints) + { + for (unsigned i = 0; i < blueprints.size(); i++) + { + Blueprint* blueprint = blueprints[i]; + if (blueprint->static_dir_ == "" && blueprint->all_rules_.empty()) + { + std::vector methods; + get_recursive_child_methods(blueprint, methods); + for (HTTPMethod x : methods) + { + int i = static_cast(x); + per_methods_[i].trie.add(blueprint->prefix(), 0, blueprint->prefix().length(), i); + } + } + for (auto& rule : blueprint->all_rules_) + { + if (rule) + { + auto upgraded = rule->upgrade(); + if (upgraded) + rule = std::move(upgraded); + rule->validate(); + internal_add_rule_object(rule->rule(), rule.get(), i, blueprints); + } + } + validate_bp(blueprint->blueprints_); + } + } + + void validate() + { + //Take all the routes from the registered blueprints and add them to `all_rules_` to be processed. + validate_bp(blueprints_); + + for (auto& rule : all_rules_) + { + if (rule) + { + auto upgraded = rule->upgrade(); + if (upgraded) + rule = std::move(upgraded); + rule->validate(); + internal_add_rule_object(rule->rule(), rule.get(), INVALID_BP_ID, blueprints_); + } + } + for (auto& per_method : per_methods_) + { + per_method.trie.validate(); + } + } + + // TODO maybe add actual_method + template + void handle_upgrade(const request& req, response& res, Adaptor&& adaptor) + { + if (req.method >= HTTPMethod::InternalMethodCount) + return; + + auto& per_method = per_methods_[static_cast(req.method)]; + auto& rules = per_method.rules; + unsigned rule_index = std::get<0>(per_method.trie.find(req.url)); + + if (!rule_index) + { + for (auto& per_method : per_methods_) + { + if (std::get<0>(per_method.trie.find(req.url))) + { + CROW_LOG_DEBUG << "Cannot match method " << req.url << " " << method_name(req.method); + res = response(405); + res.end(); + return; + } + } + + CROW_LOG_INFO << "Cannot match rules " << req.url; + res = response(404); + res.end(); + return; + } + + if (rule_index >= rules.size()) + throw std::runtime_error("Trie internal structure corrupted!"); + + if (rule_index == RULE_SPECIAL_REDIRECT_SLASH) + { + CROW_LOG_INFO << "Redirecting to a url with trailing slash: " << req.url; + res = response(301); + + // TODO(ipkn) absolute url building + if (req.get_header_value("Host").empty()) + { + res.add_header("Location", req.url + "/"); + } + else + { + res.add_header("Location", "http://" + req.get_header_value("Host") + req.url + "/"); + } + res.end(); + return; + } + + CROW_LOG_DEBUG << "Matched rule (upgrade) '" << rules[rule_index]->rule_ << "' " << static_cast(req.method) << " / " << rules[rule_index]->get_methods(); + + // any uncaught exceptions become 500s + try + { + rules[rule_index]->handle_upgrade(req, res, std::move(adaptor)); + } + catch (std::exception& e) + { + CROW_LOG_ERROR << "An uncaught exception occurred: " << e.what(); + res = response(500); + res.end(); + return; + } + catch (...) + { + CROW_LOG_ERROR << "An uncaught exception occurred. The type was unknown so no information was available."; + res = response(500); + res.end(); + return; + } + } + + void get_found_bp(std::vector& bp_i, std::vector& blueprints, std::vector& found_bps, uint16_t index = 0) + { + // This statement makes 3 assertions: + // 1. The index is above 0. + // 2. The index does not lie outside the given blueprint list. + // 3. The next blueprint we're adding has a prefix that starts the same as the already added blueprint + a slash (the rest is irrelevant). + // + // This is done to prevent a blueprint that has a prefix of "bp_prefix2" to be assumed as a child of one that has "bp_prefix". + // + // If any of the assertions is untrue, we delete the last item added, and continue using the blueprint list of the blueprint found before, the topmost being the router's list + auto verify_prefix = [&bp_i, &index, &blueprints, &found_bps]() { + return index > 0 && + bp_i[index] < blueprints.size() && + blueprints[bp_i[index]]->prefix().substr(0, found_bps[index - 1]->prefix().length() + 1).compare(std::string(found_bps[index - 1]->prefix() + '/')) == 0; + }; + if (index < bp_i.size()) + { + + if (verify_prefix()) + { + found_bps.push_back(blueprints[bp_i[index]]); + get_found_bp(bp_i, found_bps.back()->blueprints_, found_bps, ++index); + } + else + { + if (found_bps.size() < 2) + { + found_bps.clear(); + found_bps.push_back(blueprints_[bp_i[index]]); + } + else + { + found_bps.pop_back(); + Blueprint* last_element = found_bps.back(); + found_bps.push_back(last_element->blueprints_[bp_i[index]]); + } + get_found_bp(bp_i, found_bps.back()->blueprints_, found_bps, ++index); + } + } + } + + /// Is used to handle errors, you insert the error code, found route, request, and response. and it'll either call the appropriate catchall route (considering the blueprint system) and send you a status string (which is mainly used for debug messages), or just set the response code to the proper error code. + std::string get_error(unsigned short code, std::tuple, routing_params>& found, const request& req, response& res) + { + res.code = code; + std::vector bps_found; + get_found_bp(std::get<1>(found), blueprints_, bps_found); + for (int i = bps_found.size() - 1; i > 0; i--) + { + std::vector bpi = std::get<1>(found); + if (bps_found[i]->catchall_rule().has_handler()) + { + bps_found[i]->catchall_rule().handler_(req, res); +#ifdef CROW_ENABLE_DEBUG + return std::string("Redirected to Blueprint \"" + bps_found[i]->prefix() + "\" Catchall rule"); +#else + return std::string(); +#endif + } + } + if (catchall_rule_.has_handler()) + { + catchall_rule_.handler_(req, res); +#ifdef CROW_ENABLE_DEBUG + return std::string("Redirected to global Catchall rule"); +#else + return std::string(); +#endif + } + return std::string(); + } + + void handle(request& req, response& res) + { + HTTPMethod method_actual = req.method; + if (req.method >= HTTPMethod::InternalMethodCount) + return; + else if (req.method == HTTPMethod::Head) + { + method_actual = HTTPMethod::Get; + res.skip_body = true; + } + else if (req.method == HTTPMethod::Options) + { + std::string allow = "OPTIONS, HEAD, "; + + if (req.url == "/*") + { + for (int i = 0; i < static_cast(HTTPMethod::InternalMethodCount); i++) + { + if (!per_methods_[i].trie.is_empty()) + { + allow += method_name(static_cast(i)) + ", "; + } + } + allow = allow.substr(0, allow.size() - 2); + res = response(204); + res.set_header("Allow", allow); + res.end(); + return; + } + else + { + for (int i = 0; i < static_cast(HTTPMethod::InternalMethodCount); i++) + { + if (std::get<0>(per_methods_[i].trie.find(req.url))) + { + allow += method_name(static_cast(i)) + ", "; + } + } + if (allow != "OPTIONS, HEAD, ") + { + allow = allow.substr(0, allow.size() - 2); + res = response(204); + res.set_header("Allow", allow); + res.end(); + return; + } + else + { + CROW_LOG_DEBUG << "Cannot match rules " << req.url; + res = response(404); + res.end(); + return; + } + } + } + + auto& per_method = per_methods_[static_cast(method_actual)]; + auto& trie = per_method.trie; + auto& rules = per_method.rules; + + auto found = trie.find(req.url); + + unsigned rule_index = std::get<0>(found); + + if (!rule_index) + { + for (auto& per_method : per_methods_) + { + if (std::get<0>(per_method.trie.find(req.url))) //Route found, but in another method + { + const std::string error_message(get_error(405, found, req, res)); + CROW_LOG_DEBUG << "Cannot match method " << req.url << " " << method_name(method_actual) << ". " << error_message; + res.end(); + return; + } + } + //Route does not exist anywhere + + const std::string error_message(get_error(404, found, req, res)); + CROW_LOG_DEBUG << "Cannot match rules " << req.url << ". " << error_message; + res.end(); + return; + } + + if (rule_index >= rules.size()) + throw std::runtime_error("Trie internal structure corrupted!"); + + if (rule_index == RULE_SPECIAL_REDIRECT_SLASH) + { + CROW_LOG_INFO << "Redirecting to a url with trailing slash: " << req.url; + res = response(301); + + // TODO(ipkn) absolute url building + if (req.get_header_value("Host").empty()) + { + res.add_header("Location", req.url + "/"); + } + else + { + res.add_header("Location", "http://" + req.get_header_value("Host") + req.url + "/"); + } + res.end(); + return; + } + + CROW_LOG_DEBUG << "Matched rule '" << rules[rule_index]->rule_ << "' " << static_cast(req.method) << " / " << rules[rule_index]->get_methods(); + + // any uncaught exceptions become 500s + try + { + rules[rule_index]->handle(req, res, std::get<2>(found)); + } + catch (std::exception& e) + { + CROW_LOG_ERROR << "An uncaught exception occurred: " << e.what(); + res = response(500); + res.end(); + return; + } + catch (...) + { + CROW_LOG_ERROR << "An uncaught exception occurred. The type was unknown so no information was available."; + res = response(500); + res.end(); + return; + } + } + + void debug_print() + { + for (int i = 0; i < static_cast(HTTPMethod::InternalMethodCount); i++) + { + CROW_LOG_DEBUG << method_name(static_cast(i)); + per_methods_[i].trie.debug_print(); + } + } + + std::vector& blueprints() + { + return blueprints_; + } + + private: + CatchallRule catchall_rule_; + + struct PerMethod + { + std::vector rules; + Trie trie; + + // rule index 0, 1 has special meaning; preallocate it to avoid duplication. + PerMethod(): + rules(2) {} + }; + std::array(HTTPMethod::InternalMethodCount)> per_methods_; + std::vector> all_rules_; + std::vector blueprints_; + }; +} // namespace crow + + + +#pragma once + + + + + + + +namespace crow +{ + struct CORSHandler; + + /// Used for tuning CORS policies + struct CORSRules + { + friend struct crow::CORSHandler; + + /// Set Access-Control-Allow-Origin. Default is "*" + CORSRules& origin(const std::string& origin) + { + origin_ = origin; + return *this; + } + + /// Set Access-Control-Allow-Methods. Default is "*" + CORSRules& methods(crow::HTTPMethod method) + { + add_list_item(methods_, crow::method_name(method)); + return *this; + } + + /// Set Access-Control-Allow-Methods. Default is "*" + template + CORSRules& methods(crow::HTTPMethod method, Methods... method_list) + { + add_list_item(methods_, crow::method_name(method)); + methods(method_list...); + return *this; + } + + /// Set Access-Control-Allow-Headers. Default is "*" + CORSRules& headers(const std::string& header) + { + add_list_item(headers_, header); + return *this; + } + + /// Set Access-Control-Allow-Headers. Default is "*" + template + CORSRules& headers(const std::string& header, Headers... header_list) + { + add_list_item(headers_, header); + headers(header_list...); + return *this; + } + + /// Set Access-Control-Max-Age. Default is none + CORSRules& max_age(int max_age) + { + max_age_ = std::to_string(max_age); + return *this; + } + + /// Enable Access-Control-Allow-Credentials + CORSRules& allow_credentials() + { + allow_credentials_ = true; + return *this; + } + + /// Ignore CORS and don't send any headers + void ignore() + { + ignore_ = true; + } + + /// Handle CORS on specific prefix path + CORSRules& prefix(const std::string& prefix); + + /// Handle CORS for specific blueprint + CORSRules& blueprint(const Blueprint& bp); + + /// Global CORS policy + CORSRules& global(); + + private: + CORSRules() = delete; + CORSRules(CORSHandler* handler): + handler_(handler) {} + + /// build comma separated list + void add_list_item(std::string& list, const std::string& val) + { + if (list == "*") list = ""; + if (list.size() > 0) list += ", "; + list += val; + } + + /// Set header `key` to `value` if it is not set + void set_header_no_override(const std::string& key, const std::string& value, crow::response& res) + { + if (value.size() == 0) return; + if (!get_header_value(res.headers, key).empty()) return; + res.add_header(key, value); + } + + /// Set response headers + void apply(crow::response& res) + { + if (ignore_) return; + set_header_no_override("Access-Control-Allow-Origin", origin_, res); + set_header_no_override("Access-Control-Allow-Methods", methods_, res); + set_header_no_override("Access-Control-Allow-Headers", headers_, res); + set_header_no_override("Access-Control-Max-Age", max_age_, res); + if (allow_credentials_) set_header_no_override("Access-Control-Allow-Credentials", "true", res); + } + + bool ignore_ = false; + // TODO: support multiple origins that are dynamically selected + std::string origin_ = "*"; + std::string methods_ = "*"; + std::string headers_ = "*"; + std::string max_age_; + bool allow_credentials_ = false; + + CORSHandler* handler_; + }; + + /// CORSHandler is a global middleware for setting CORS headers. + + /// + /// By default, it sets Access-Control-Allow-Origin/Methods/Headers to "*". + /// The default behaviour can be changed with the `global()` cors rule. + /// Additional rules for prexies can be added with `prefix()`. + struct CORSHandler + { + struct context + {}; + + void before_handle(crow::request& /*req*/, crow::response& /*res*/, context& /*ctx*/) + {} + + void after_handle(crow::request& req, crow::response& res, context& /*ctx*/) + { + auto& rule = find_rule(req.url); + rule.apply(res); + } + + /// Handle CORS on a specific prefix path + CORSRules& prefix(const std::string& prefix) + { + rules.emplace_back(prefix, CORSRules(this)); + return rules.back().second; + } + + /// Handle CORS for a specific blueprint + CORSRules& blueprint(const Blueprint& bp) + { + rules.emplace_back(bp.prefix(), CORSRules(this)); + return rules.back().second; + } + + /// Get the global CORS policy + CORSRules& global() + { + return default_; + } + + private: + CORSRules& find_rule(const std::string& path) + { + // TODO: use a trie in case of many rules + for (auto& rule : rules) + { + // Check if path starts with a rules prefix + if (path.rfind(rule.first, 0) == 0) + { + return rule.second; + } + } + return default_; + } + + std::vector> rules; + CORSRules default_ = CORSRules(this); + }; + + inline CORSRules& CORSRules::prefix(const std::string& prefix) + { + return handler_->prefix(prefix); + } + + inline CORSRules& CORSRules::blueprint(const Blueprint& bp) + { + return handler_->blueprint(bp); + } + + inline CORSRules& CORSRules::global() + { + return handler_->global(); + } + +} // namespace crow + + + +#ifdef CROW_ENABLE_COMPRESSION +#pragma once + +#include +#include + +// http://zlib.net/manual.html +namespace crow +{ + namespace compression + { + // Values used in the 'windowBits' parameter for deflateInit2. + enum algorithm + { + // 15 is the default value for deflate + DEFLATE = 15, + // windowBits can also be greater than 15 for optional gzip encoding. + // Add 16 to windowBits to write a simple gzip header and trailer around the compressed data instead of a zlib wrapper. + GZIP = 15 | 16, + }; + + inline std::string compress_string(std::string const& str, algorithm algo) + { + std::string compressed_str; + z_stream stream{}; + // Initialize with the default values + if (::deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, algo, 8, Z_DEFAULT_STRATEGY) == Z_OK) + { + char buffer[8192]; + + stream.avail_in = str.size(); + // zlib does not take a const pointer. The data is not altered. + stream.next_in = const_cast(reinterpret_cast(str.c_str())); + + int code = Z_OK; + do + { + stream.avail_out = sizeof(buffer); + stream.next_out = reinterpret_cast(&buffer[0]); + + code = ::deflate(&stream, Z_FINISH); + // Successful and non-fatal error code returned by deflate when used with Z_FINISH flush + if (code == Z_OK || code == Z_STREAM_END) + { + std::copy(&buffer[0], &buffer[sizeof(buffer) - stream.avail_out], std::back_inserter(compressed_str)); + } + + } while (code == Z_OK); + + if (code != Z_STREAM_END) + compressed_str.clear(); + + ::deflateEnd(&stream); + } + + return compressed_str; + } + + inline std::string decompress_string(std::string const& deflated_string) + { + std::string inflated_string; + Bytef tmp[8192]; + + z_stream zstream{}; + zstream.avail_in = deflated_string.size(); + // Nasty const_cast but zlib won't alter its contents + zstream.next_in = const_cast(reinterpret_cast(deflated_string.c_str())); + // Initialize with automatic header detection, for gzip support + if (::inflateInit2(&zstream, MAX_WBITS | 32) == Z_OK) + { + do + { + zstream.avail_out = sizeof(tmp); + zstream.next_out = &tmp[0]; + + auto ret = ::inflate(&zstream, Z_NO_FLUSH); + if (ret == Z_OK || ret == Z_STREAM_END) + { + std::copy(&tmp[0], &tmp[sizeof(tmp) - zstream.avail_out], std::back_inserter(inflated_string)); + } + else + { + // Something went wrong with inflate; make sure we return an empty string + inflated_string.clear(); + break; + } + + } while (zstream.avail_out == 0); + + // Free zlib's internal memory + ::inflateEnd(&zstream); + } + + return inflated_string; + } + } // namespace compression +} // namespace crow + +#endif + + + +#pragma once +#include +#include +#include +#include +#include +#include +#include + + + + + + + + + + + + + + + + + + + + + + + + +namespace crow +{ + using namespace boost; + using tcp = asio::ip::tcp; + + +#ifdef CROW_ENABLE_DEBUG + static std::atomic connectionCount; +#endif + + /// An HTTP connection. + template + class Connection + { + friend struct crow::response; + + public: + Connection( + boost::asio::io_service& io_service, + Handler* handler, + const std::string& server_name, + std::tuple* middlewares, + std::function& get_cached_date_str_f, + detail::task_timer& task_timer, + typename Adaptor::context* adaptor_ctx_, + std::atomic& queue_length): + adaptor_(io_service, adaptor_ctx_), + handler_(handler), + parser_(this), + server_name_(server_name), + middlewares_(middlewares), + get_cached_date_str(get_cached_date_str_f), + task_timer_(task_timer), + res_stream_threshold_(handler->stream_threshold()), + queue_length_(queue_length) + { +#ifdef CROW_ENABLE_DEBUG + connectionCount++; + CROW_LOG_DEBUG << "Connection (" << this << ") allocated, total: " << connectionCount; +#endif + } + + ~Connection() + { + res.complete_request_handler_ = nullptr; + cancel_deadline_timer(); +#ifdef CROW_ENABLE_DEBUG + connectionCount--; + CROW_LOG_DEBUG << "Connection (" << this << ") freed, total: " << connectionCount; +#endif + } + + /// The TCP socket on top of which the connection is established. + decltype(std::declval().raw_socket())& socket() + { + return adaptor_.raw_socket(); + } + + void start() + { + adaptor_.start([this](const boost::system::error_code& ec) { + if (!ec) + { + start_deadline(); + parser_.clear(); + + do_read(); + } + else + { + CROW_LOG_ERROR << "Could not start adaptor: " << ec.message(); + check_destroy(); + } + }); + } + + void handle_header() + { + // HTTP 1.1 Expect: 100-continue + if (parser_.http_major == 1 && parser_.http_minor == 1 && get_header_value(parser_.headers, "expect") == "100-continue") // Using the parser because the request isn't made yet. + { + buffers_.clear(); + static std::string expect_100_continue = "HTTP/1.1 100 Continue\r\n\r\n"; + buffers_.emplace_back(expect_100_continue.data(), expect_100_continue.size()); + do_write(); + } + } + + void handle() + { + cancel_deadline_timer(); + bool is_invalid_request = false; + add_keep_alive_ = false; + + req_ = std::move(parser_.to_request()); + request& req = req_; + + req.remote_ip_address = adaptor_.remote_endpoint().address().to_string(); + + add_keep_alive_ = req.keep_alive; + close_connection_ = req.close_connection; + + if (req.check_version(1, 1)) // HTTP/1.1 + { + if (!req.headers.count("host")) + { + is_invalid_request = true; + res = response(400); + } + else if (req.upgrade) + { + // h2 or h2c headers + if (req.get_header_value("upgrade").substr(0, 2) == "h2") + { + // TODO(ipkn): HTTP/2 + // currently, ignore upgrade header + } + else + { + close_connection_ = true; + handler_->handle_upgrade(req, res, std::move(adaptor_)); + return; + } + } + } + + CROW_LOG_INFO << "Request: " << boost::lexical_cast(adaptor_.remote_endpoint()) << " " << this << " HTTP/" << (char)(req.http_ver_major + '0') << "." << (char)(req.http_ver_minor + '0') << ' ' << method_name(req.method) << " " << req.url; + + + need_to_call_after_handlers_ = false; + if (!is_invalid_request) + { + res.complete_request_handler_ = [] {}; + res.is_alive_helper_ = [this]() -> bool { + return adaptor_.is_open(); + }; + + ctx_ = detail::context(); + req.middleware_context = static_cast(&ctx_); + req.middleware_container = static_cast(middlewares_); + req.io_service = &adaptor_.get_io_service(); + + detail::middleware_call_helper(*middlewares_, req, res, ctx_); + + if (!res.completed_) + { + res.complete_request_handler_ = [this] { + this->complete_request(); + }; + need_to_call_after_handlers_ = true; + handler_->handle(req, res); + if (add_keep_alive_) + res.set_header("connection", "Keep-Alive"); + } + else + { + complete_request(); + } + } + else + { + complete_request(); + } + } + + /// Call the after handle middleware and send the write the response to the connection. + void complete_request() + { + CROW_LOG_INFO << "Response: " << this << ' ' << req_.raw_url << ' ' << res.code << ' ' << close_connection_; + + if (need_to_call_after_handlers_) + { + need_to_call_after_handlers_ = false; + + // call all after_handler of middlewares + detail::after_handlers_call_helper< + detail::middleware_call_criteria_only_global, + (static_cast(sizeof...(Middlewares)) - 1), + decltype(ctx_), + decltype(*middlewares_)>(*middlewares_, ctx_, req_, res); + } +#ifdef CROW_ENABLE_COMPRESSION + if (handler_->compression_used()) + { + std::string accept_encoding = req_.get_header_value("Accept-Encoding"); + if (!accept_encoding.empty() && res.compressed) + { + switch (handler_->compression_algorithm()) + { + case compression::DEFLATE: + if (accept_encoding.find("deflate") != std::string::npos) + { + res.body = compression::compress_string(res.body, compression::algorithm::DEFLATE); + res.set_header("Content-Encoding", "deflate"); + } + break; + case compression::GZIP: + if (accept_encoding.find("gzip") != std::string::npos) + { + res.body = compression::compress_string(res.body, compression::algorithm::GZIP); + res.set_header("Content-Encoding", "gzip"); + } + break; + default: + break; + } + } + } +#endif + //if there is a redirection with a partial URL, treat the URL as a route. + std::string location = res.get_header_value("Location"); + if (!location.empty() && location.find("://", 0) == std::string::npos) + { +#ifdef CROW_ENABLE_SSL + if (handler_->ssl_used()) + location.insert(0, "https://" + req_.get_header_value("Host")); + else +#endif + location.insert(0, "http://" + req_.get_header_value("Host")); + res.set_header("location", location); + } + + prepare_buffers(); + + if (res.is_static_type()) + { + do_write_static(); + } + else + { + do_write_general(); + } + } + + private: + void prepare_buffers() + { + //auto self = this->shared_from_this(); + res.complete_request_handler_ = nullptr; + + if (!adaptor_.is_open()) + { + //CROW_LOG_DEBUG << this << " delete (socket is closed) " << is_reading << ' ' << is_writing; + //delete this; + return; + } + // TODO(EDev): HTTP version in status codes should be dynamic + // Keep in sync with common.h/status + static std::unordered_map statusCodes = { + {status::CONTINUE, "HTTP/1.1 100 Continue\r\n"}, + {status::SWITCHING_PROTOCOLS, "HTTP/1.1 101 Switching Protocols\r\n"}, + + {status::OK, "HTTP/1.1 200 OK\r\n"}, + {status::CREATED, "HTTP/1.1 201 Created\r\n"}, + {status::ACCEPTED, "HTTP/1.1 202 Accepted\r\n"}, + {status::NON_AUTHORITATIVE_INFORMATION, "HTTP/1.1 203 Non-Authoritative Information\r\n"}, + {status::NO_CONTENT, "HTTP/1.1 204 No Content\r\n"}, + {status::RESET_CONTENT, "HTTP/1.1 205 Reset Content\r\n"}, + {status::PARTIAL_CONTENT, "HTTP/1.1 206 Partial Content\r\n"}, + + {status::MULTIPLE_CHOICES, "HTTP/1.1 300 Multiple Choices\r\n"}, + {status::MOVED_PERMANENTLY, "HTTP/1.1 301 Moved Permanently\r\n"}, + {status::FOUND, "HTTP/1.1 302 Found\r\n"}, + {status::SEE_OTHER, "HTTP/1.1 303 See Other\r\n"}, + {status::NOT_MODIFIED, "HTTP/1.1 304 Not Modified\r\n"}, + {status::TEMPORARY_REDIRECT, "HTTP/1.1 307 Temporary Redirect\r\n"}, + {status::PERMANENT_REDIRECT, "HTTP/1.1 308 Permanent Redirect\r\n"}, + + {status::BAD_REQUEST, "HTTP/1.1 400 Bad Request\r\n"}, + {status::UNAUTHORIZED, "HTTP/1.1 401 Unauthorized\r\n"}, + {status::FORBIDDEN, "HTTP/1.1 403 Forbidden\r\n"}, + {status::NOT_FOUND, "HTTP/1.1 404 Not Found\r\n"}, + {status::METHOD_NOT_ALLOWED, "HTTP/1.1 405 Method Not Allowed\r\n"}, + {status::PROXY_AUTHENTICATION_REQUIRED, "HTTP/1.1 407 Proxy Authentication Required\r\n"}, + {status::CONFLICT, "HTTP/1.1 409 Conflict\r\n"}, + {status::GONE, "HTTP/1.1 410 Gone\r\n"}, + {status::PAYLOAD_TOO_LARGE, "HTTP/1.1 413 Payload Too Large\r\n"}, + {status::UNSUPPORTED_MEDIA_TYPE, "HTTP/1.1 415 Unsupported Media Type\r\n"}, + {status::RANGE_NOT_SATISFIABLE, "HTTP/1.1 416 Range Not Satisfiable\r\n"}, + {status::EXPECTATION_FAILED, "HTTP/1.1 417 Expectation Failed\r\n"}, + {status::PRECONDITION_REQUIRED, "HTTP/1.1 428 Precondition Required\r\n"}, + {status::TOO_MANY_REQUESTS, "HTTP/1.1 429 Too Many Requests\r\n"}, + {status::UNAVAILABLE_FOR_LEGAL_REASONS, "HTTP/1.1 451 Unavailable For Legal Reasons\r\n"}, + + {status::INTERNAL_SERVER_ERROR, "HTTP/1.1 500 Internal Server Error\r\n"}, + {status::NOT_IMPLEMENTED, "HTTP/1.1 501 Not Implemented\r\n"}, + {status::BAD_GATEWAY, "HTTP/1.1 502 Bad Gateway\r\n"}, + {status::SERVICE_UNAVAILABLE, "HTTP/1.1 503 Service Unavailable\r\n"}, + {status::GATEWAY_TIMEOUT, "HTTP/1.1 504 Gateway Timeout\r\n"}, + {status::VARIANT_ALSO_NEGOTIATES, "HTTP/1.1 506 Variant Also Negotiates\r\n"}, + }; + + static const std::string seperator = ": "; + + buffers_.clear(); + buffers_.reserve(4 * (res.headers.size() + 5) + 3); + + if (!statusCodes.count(res.code)) + res.code = 500; + { + auto& status = statusCodes.find(res.code)->second; + buffers_.emplace_back(status.data(), status.size()); + } + + if (res.code >= 400 && res.body.empty()) + res.body = statusCodes[res.code].substr(9); + + for (auto& kv : res.headers) + { + buffers_.emplace_back(kv.first.data(), kv.first.size()); + buffers_.emplace_back(seperator.data(), seperator.size()); + buffers_.emplace_back(kv.second.data(), kv.second.size()); + buffers_.emplace_back(crlf.data(), crlf.size()); + } + + if (!res.manual_length_header && !res.headers.count("content-length")) + { + content_length_ = std::to_string(res.body.size()); + static std::string content_length_tag = "Content-Length: "; + buffers_.emplace_back(content_length_tag.data(), content_length_tag.size()); + buffers_.emplace_back(content_length_.data(), content_length_.size()); + buffers_.emplace_back(crlf.data(), crlf.size()); + } + if (!res.headers.count("server")) + { + static std::string server_tag = "Server: "; + buffers_.emplace_back(server_tag.data(), server_tag.size()); + buffers_.emplace_back(server_name_.data(), server_name_.size()); + buffers_.emplace_back(crlf.data(), crlf.size()); + } + if (!res.headers.count("date")) + { + static std::string date_tag = "Date: "; + date_str_ = get_cached_date_str(); + buffers_.emplace_back(date_tag.data(), date_tag.size()); + buffers_.emplace_back(date_str_.data(), date_str_.size()); + buffers_.emplace_back(crlf.data(), crlf.size()); + } + if (add_keep_alive_) + { + static std::string keep_alive_tag = "Connection: Keep-Alive"; + buffers_.emplace_back(keep_alive_tag.data(), keep_alive_tag.size()); + buffers_.emplace_back(crlf.data(), crlf.size()); + } + + buffers_.emplace_back(crlf.data(), crlf.size()); + } + + void do_write_static() + { + is_writing = true; + boost::asio::write(adaptor_.socket(), buffers_); + + if (res.file_info.statResult == 0) + { + std::ifstream is(res.file_info.path.c_str(), std::ios::in | std::ios::binary); + std::vector buffers{1}; + char buf[16384]; + is.read(buf, sizeof(buf)); + while (is.gcount() > 0) + { + buffers[0] = boost::asio::buffer(buf, is.gcount()); + do_write_sync(buffers); + is.read(buf, sizeof(buf)); + } + } + is_writing = false; + if (close_connection_) + { + adaptor_.shutdown_readwrite(); + adaptor_.close(); + CROW_LOG_DEBUG << this << " from write (static)"; + check_destroy(); + } + + res.end(); + res.clear(); + buffers_.clear(); + parser_.clear(); + } + + void do_write_general() + { + if (res.body.length() < res_stream_threshold_) + { + res_body_copy_.swap(res.body); + buffers_.emplace_back(res_body_copy_.data(), res_body_copy_.size()); + + do_write(); + + if (need_to_start_read_after_complete_) + { + need_to_start_read_after_complete_ = false; + start_deadline(); + do_read(); + } + } + else + { + is_writing = true; + boost::asio::write(adaptor_.socket(), buffers_); // Write the response start / headers + if (res.body.length() > 0) + { + std::string buf; + std::vector buffers; + + while (res.body.length() > 16384) + { + //buf.reserve(16385); + buf = res.body.substr(0, 16384); + res.body = res.body.substr(16384); + buffers.clear(); + buffers.push_back(boost::asio::buffer(buf)); + do_write_sync(buffers); + } + // Collect whatever is left (less than 16KB) and send it down the socket + // buf.reserve(is.length()); + buf = res.body; + res.body.clear(); + + buffers.clear(); + buffers.push_back(boost::asio::buffer(buf)); + do_write_sync(buffers); + } + is_writing = false; + if (close_connection_) + { + adaptor_.shutdown_readwrite(); + adaptor_.close(); + CROW_LOG_DEBUG << this << " from write (res_stream)"; + check_destroy(); + } + + res.end(); + res.clear(); + buffers_.clear(); + parser_.clear(); + } + } + + void do_read() + { + //auto self = this->shared_from_this(); + is_reading = true; + adaptor_.socket().async_read_some( + boost::asio::buffer(buffer_), + [this](const boost::system::error_code& ec, std::size_t bytes_transferred) { + bool error_while_reading = true; + if (!ec) + { + bool ret = parser_.feed(buffer_.data(), bytes_transferred); + if (ret && adaptor_.is_open()) + { + error_while_reading = false; + } + } + + if (error_while_reading) + { + cancel_deadline_timer(); + parser_.done(); + adaptor_.shutdown_read(); + adaptor_.close(); + is_reading = false; + CROW_LOG_DEBUG << this << " from read(1) with description: \"" << http_errno_description(static_cast(parser_.http_errno)) << '\"'; + check_destroy(); + } + else if (close_connection_) + { + cancel_deadline_timer(); + parser_.done(); + is_reading = false; + check_destroy(); + // adaptor will close after write + } + else if (!need_to_call_after_handlers_) + { + start_deadline(); + do_read(); + } + else + { + // res will be completed later by user + need_to_start_read_after_complete_ = true; + } + }); + } + + void do_write() + { + //auto self = this->shared_from_this(); + is_writing = true; + boost::asio::async_write( + adaptor_.socket(), buffers_, + [&](const boost::system::error_code& ec, std::size_t /*bytes_transferred*/) { + is_writing = false; + res.clear(); + res_body_copy_.clear(); + parser_.clear(); + if (!ec) + { + if (close_connection_) + { + adaptor_.shutdown_write(); + adaptor_.close(); + CROW_LOG_DEBUG << this << " from write(1)"; + check_destroy(); + } + } + else + { + CROW_LOG_DEBUG << this << " from write(2)"; + check_destroy(); + } + }); + } + + inline void do_write_sync(std::vector& buffers) + { + + boost::asio::write(adaptor_.socket(), buffers, [&](std::error_code ec, std::size_t) { + if (!ec) + { + return false; + } + else + { + CROW_LOG_ERROR << ec << " - happened while sending buffers"; + CROW_LOG_DEBUG << this << " from write (sync)(2)"; + check_destroy(); + return true; + } + }); + } + + void check_destroy() + { + CROW_LOG_DEBUG << this << " is_reading " << is_reading << " is_writing " << is_writing; + if (!is_reading && !is_writing) + { + queue_length_--; + CROW_LOG_DEBUG << this << " delete (idle) (queue length: " << queue_length_ << ')'; + delete this; + } + } + + void cancel_deadline_timer() + { + CROW_LOG_DEBUG << this << " timer cancelled: " << &task_timer_ << ' ' << task_id_; + task_timer_.cancel(task_id_); + } + + void start_deadline(/*int timeout = 5*/) + { + cancel_deadline_timer(); + + task_id_ = task_timer_.schedule([this] { + if (!adaptor_.is_open()) + { + return; + } + adaptor_.shutdown_readwrite(); + adaptor_.close(); + }); + CROW_LOG_DEBUG << this << " timer added: " << &task_timer_ << ' ' << task_id_; + } + + private: + Adaptor adaptor_; + Handler* handler_; + + boost::array buffer_; + + HTTPParser parser_; + request req_; + response res; + + bool close_connection_ = false; + + const std::string& server_name_; + std::vector buffers_; + + std::string content_length_; + std::string date_str_; + std::string res_body_copy_; + + detail::task_timer::identifier_type task_id_; + + bool is_reading{}; + bool is_writing{}; + bool need_to_call_after_handlers_{}; + bool need_to_start_read_after_complete_{}; + bool add_keep_alive_{}; + + std::tuple* middlewares_; + detail::context ctx_; + + std::function& get_cached_date_str; + detail::task_timer& task_timer_; + + size_t res_stream_threshold_; + + std::atomic& queue_length_; + }; + +} // namespace crow + + + +#pragma once + +#include +#include +#include +#ifdef CROW_ENABLE_SSL +#include +#endif +#include +#include +#include +#include +#include + + + + + + + + + + +namespace crow +{ + using namespace boost; + using tcp = asio::ip::tcp; + + template + class Server + { + public: + Server(Handler* handler, std::string bindaddr, uint16_t port, std::string server_name = std::string("Crow/") + VERSION, std::tuple* middlewares = nullptr, uint16_t concurrency = 1, uint8_t timeout = 5, typename Adaptor::context* adaptor_ctx = nullptr): + acceptor_(io_service_, tcp::endpoint(boost::asio::ip::address::from_string(bindaddr), port)), + signals_(io_service_), + tick_timer_(io_service_), + handler_(handler), + concurrency_(concurrency), + timeout_(timeout), + server_name_(server_name), + port_(port), + bindaddr_(bindaddr), + task_queue_length_pool_(concurrency_ - 1), + middlewares_(middlewares), + adaptor_ctx_(adaptor_ctx) + {} + + void set_tick_function(std::chrono::milliseconds d, std::function f) + { + tick_interval_ = d; + tick_function_ = f; + } + + void on_tick() + { + tick_function_(); + tick_timer_.expires_from_now(boost::posix_time::milliseconds(tick_interval_.count())); + tick_timer_.async_wait([this](const boost::system::error_code& ec) { + if (ec) + return; + on_tick(); + }); + } + + void run() + { + uint16_t worker_thread_count = concurrency_ - 1; + for (int i = 0; i < worker_thread_count; i++) + io_service_pool_.emplace_back(new boost::asio::io_service()); + get_cached_date_str_pool_.resize(worker_thread_count); + task_timer_pool_.resize(worker_thread_count); + + std::vector> v; + std::atomic init_count(0); + for (uint16_t i = 0; i < worker_thread_count; i++) + v.push_back( + std::async( + std::launch::async, [this, i, &init_count] { + // thread local date string get function + auto last = std::chrono::steady_clock::now(); + + std::string date_str; + auto update_date_str = [&] { + auto last_time_t = time(0); + tm my_tm; + +#if defined(_MSC_VER) || defined(__MINGW32__) + gmtime_s(&my_tm, &last_time_t); +#else + gmtime_r(&last_time_t, &my_tm); +#endif + date_str.resize(100); + size_t date_str_sz = strftime(&date_str[0], 99, "%a, %d %b %Y %H:%M:%S GMT", &my_tm); + date_str.resize(date_str_sz); + }; + update_date_str(); + get_cached_date_str_pool_[i] = [&]() -> std::string { + if (std::chrono::steady_clock::now() - last >= std::chrono::seconds(1)) + { + last = std::chrono::steady_clock::now(); + update_date_str(); + } + return date_str; + }; + + // initializing task timers + detail::task_timer task_timer(*io_service_pool_[i]); + task_timer.set_default_timeout(timeout_); + task_timer_pool_[i] = &task_timer; + task_queue_length_pool_[i] = 0; + + init_count++; + while (1) + { + try + { + if (io_service_pool_[i]->run() == 0) + { + // when io_service.run returns 0, there are no more works to do. + break; + } + } + catch (std::exception& e) + { + CROW_LOG_ERROR << "Worker Crash: An uncaught exception occurred: " << e.what(); + } + } + })); + + if (tick_function_ && tick_interval_.count() > 0) + { + tick_timer_.expires_from_now(boost::posix_time::milliseconds(tick_interval_.count())); + tick_timer_.async_wait( + [this](const boost::system::error_code& ec) { + if (ec) + return; + on_tick(); + }); + } + + port_ = acceptor_.local_endpoint().port(); + handler_->port(port_); + + + CROW_LOG_INFO << server_name_ << " server is running at " << (handler_->ssl_used() ? "https://" : "http://") << bindaddr_ << ":" << acceptor_.local_endpoint().port() << " using " << concurrency_ << " threads"; + CROW_LOG_INFO << "Call `app.loglevel(crow::LogLevel::Warning)` to hide Info level logs."; + + signals_.async_wait( + [&](const boost::system::error_code& /*error*/, int /*signal_number*/) { + stop(); + }); + + while (worker_thread_count != init_count) + std::this_thread::yield(); + + do_accept(); + + std::thread( + [this] { + io_service_.run(); + CROW_LOG_INFO << "Exiting."; + }) + .join(); + } + + void stop() + { + io_service_.stop(); + for (auto& io_service : io_service_pool_) + io_service->stop(); + } + + void signal_clear() + { + signals_.clear(); + } + + void signal_add(int signal_number) + { + signals_.add(signal_number); + } + + private: + uint16_t pick_io_service_idx() + { + uint16_t min_queue_idx = 0; + + // TODO improve load balancing + for (uint16_t i = 1; i < task_queue_length_pool_.size() && task_queue_length_pool_[min_queue_idx] > 0; i++) + // No need to check other io_services if the current one has no tasks + { + if (task_queue_length_pool_[i] < task_queue_length_pool_[min_queue_idx]) + min_queue_idx = i; + } + return min_queue_idx; + } + + void do_accept() + { + uint16_t service_idx = pick_io_service_idx(); + asio::io_service& is = *io_service_pool_[service_idx]; + task_queue_length_pool_[service_idx]++; + CROW_LOG_DEBUG << &is << " {" << service_idx << "} queue length: " << task_queue_length_pool_[service_idx]; + + auto p = new Connection( + is, handler_, server_name_, middlewares_, + get_cached_date_str_pool_[service_idx], *task_timer_pool_[service_idx], adaptor_ctx_, task_queue_length_pool_[service_idx]); + + acceptor_.async_accept( + p->socket(), + [this, p, &is, service_idx](boost::system::error_code ec) { + if (!ec) + { + is.post( + [p] { + p->start(); + }); + } + else + { + task_queue_length_pool_[service_idx]--; + CROW_LOG_DEBUG << &is << " {" << service_idx << "} queue length: " << task_queue_length_pool_[service_idx]; + delete p; + } + do_accept(); + }); + } + + private: + asio::io_service io_service_; + std::vector> io_service_pool_; + std::vector task_timer_pool_; + std::vector> get_cached_date_str_pool_; + tcp::acceptor acceptor_; + boost::asio::signal_set signals_; + boost::asio::deadline_timer tick_timer_; + + Handler* handler_; + uint16_t concurrency_{2}; + std::uint8_t timeout_; + std::string server_name_; + uint16_t port_; + std::string bindaddr_; + std::vector> task_queue_length_pool_; + + std::chrono::milliseconds tick_interval_; + std::function tick_function_; + + std::tuple* middlewares_; + + typename Adaptor::context* adaptor_ctx_; + }; +} // namespace crow + + + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + + + + + + + + + + + + + + + + + +#ifdef CROW_ENABLE_COMPRESSION + + +#endif + +#ifdef CROW_MSVC_WORKAROUND +#define CROW_ROUTE(app, url) app.route_dynamic(url) +#define CROW_BP_ROUTE(blueprint, url) blueprint.new_rule_dynamic(url) +#else +#define CROW_ROUTE(app, url) app.route(url) +#define CROW_BP_ROUTE(blueprint, url) blueprint.new_rule_tagged(url) +#define CROW_MIDDLEWARES(app, ...) middlewares::type, __VA_ARGS__>() +#endif +#define CROW_CATCHALL_ROUTE(app) app.catchall_route() +#define CROW_BP_CATCHALL_ROUTE(blueprint) blueprint.catchall_rule() + +namespace crow +{ +#ifdef CROW_ENABLE_SSL + using ssl_context_t = boost::asio::ssl::context; +#endif + /// The main server application + + /// + /// Use `SimpleApp` or `App` + template + class Crow + { + public: + /// This crow application + using self_t = Crow; + /// The HTTP server + using server_t = Server; +#ifdef CROW_ENABLE_SSL + /// An HTTP server that runs on SSL with an SSLAdaptor + using ssl_server_t = Server; +#endif + Crow() + {} + + /// Process an Upgrade request + + /// + /// Currently used to upgrade an HTTP connection to a WebSocket connection + template + void handle_upgrade(const request& req, response& res, Adaptor&& adaptor) + { + router_.handle_upgrade(req, res, adaptor); + } + + /// Process the request and generate a response for it + void handle(request& req, response& res) + { + router_.handle(req, res); + } + + /// Create a dynamic route using a rule (**Use CROW_ROUTE instead**) + DynamicRule& route_dynamic(std::string&& rule) + { + return router_.new_rule_dynamic(std::move(rule)); + } + + ///Create a route using a rule (**Use CROW_ROUTE instead**) + template +#ifdef CROW_GCC83_WORKAROUND + auto& route(std::string&& rule) +#else + auto route(std::string&& rule) +#endif +#if defined CROW_CAN_USE_CPP17 && !defined CROW_GCC83_WORKAROUND + -> typename std::invoke_result), Router, std::string&&>::type +#elif !defined CROW_GCC83_WORKAROUND + -> typename std::result_of)(Router, std::string&&)>::type +#endif + { + return router_.new_rule_tagged(std::move(rule)); + } + + /// Create a route for any requests without a proper route (**Use CROW_CATCHALL_ROUTE instead**) + CatchallRule& catchall_route() + { + return router_.catchall_rule(); + } + + self_t& signal_clear() + { + signals_.clear(); + return *this; + } + + self_t& signal_add(int signal_number) + { + signals_.push_back(signal_number); + return *this; + } + + /// Set the port that Crow will handle requests on + self_t& port(std::uint16_t port) + { + port_ = port; + return *this; + } + + /// Get the port that Crow will handle requests on + std::uint16_t port() + { + return port_; + } + + + /// Set the connection timeout in seconds (default is 5) + self_t& timeout(std::uint8_t timeout) + { + timeout_ = timeout; + return *this; + } + + /// Set the server name + self_t& server_name(std::string server_name) + { + server_name_ = server_name; + return *this; + } + + /// The IP address that Crow will handle requests on (default is 0.0.0.0) + self_t& bindaddr(std::string bindaddr) + { + bindaddr_ = bindaddr; + return *this; + } + + /// Run the server on multiple threads using all available threads + self_t& multithreaded() + { + return concurrency(std::thread::hardware_concurrency()); + } + + /// Run the server on multiple threads using a specific number + self_t& concurrency(std::uint16_t concurrency) + { + if (concurrency < 2) // Crow can have a minimum of 2 threads running + concurrency = 2; + concurrency_ = concurrency; + return *this; + } + + /// Set the server's log level + + /// + /// Possible values are:
+ /// crow::LogLevel::Debug (0)
+ /// crow::LogLevel::Info (1)
+ /// crow::LogLevel::Warning (2)
+ /// crow::LogLevel::Error (3)
+ /// crow::LogLevel::Critical (4)
+ self_t& loglevel(LogLevel level) + { + crow::logger::setLogLevel(level); + return *this; + } + + /// Set the response body size (in bytes) beyond which Crow automatically streams responses (Default is 1MiB) + + /// + /// Any streamed response is unaffected by Crow's timer, and therefore won't timeout before a response is fully sent. + self_t& stream_threshold(size_t threshold) + { + res_stream_threshold_ = threshold; + return *this; + } + + /// Get the response body size (in bytes) beyond which Crow automatically streams responses + size_t& stream_threshold() + { + return res_stream_threshold_; + } + + self_t& register_blueprint(Blueprint& blueprint) + { + router_.register_blueprint(blueprint); + return *this; + } + + /// Set a custom duration and function to run on every tick + template + self_t& tick(Duration d, Func f) + { + tick_interval_ = std::chrono::duration_cast(d); + tick_function_ = f; + return *this; + } + +#ifdef CROW_ENABLE_COMPRESSION + self_t& use_compression(compression::algorithm algorithm) + { + comp_algorithm_ = algorithm; + compression_used_ = true; + return *this; + } + + compression::algorithm compression_algorithm() + { + return comp_algorithm_; + } + + bool compression_used() const + { + return compression_used_; + } +#endif + /// A wrapper for `validate()` in the router + + /// + /// Go through the rules, upgrade them if possible, and add them to the list of rules + void validate() + { + if (!validated_) + { + +#ifndef CROW_DISABLE_STATIC_DIR + route(CROW_STATIC_ENDPOINT)([](crow::response& res, std::string file_path_partial) { + utility::sanitize_filename(file_path_partial); + res.set_static_file_info_unsafe(CROW_STATIC_DIRECTORY + file_path_partial); + res.end(); + }); + +#if defined(__APPLE__) || defined(__MACH__) + if (!router_.blueprints().empty()) +#endif + { + for (Blueprint* bp : router_.blueprints()) + { + if (!bp->static_dir().empty()) + { + bp->new_rule_tagged(CROW_STATIC_ENDPOINT)([bp](crow::response& res, std::string file_path_partial) { + utility::sanitize_filename(file_path_partial); + res.set_static_file_info_unsafe(bp->static_dir() + '/' + file_path_partial); + res.end(); + }); + } + } + } +#endif + + router_.validate(); + validated_ = true; + } + } + + /// Notify anything using `wait_for_server_start()` to proceed + void notify_server_start() + { + std::unique_lock lock(start_mutex_); + server_started_ = true; + cv_started_.notify_all(); + } + + /// Run the server + void run() + { + + validate(); + +#ifdef CROW_ENABLE_SSL + if (ssl_used_) + { + ssl_server_ = std::move(std::unique_ptr(new ssl_server_t(this, bindaddr_, port_, server_name_, &middlewares_, concurrency_, timeout_, &ssl_context_))); + ssl_server_->set_tick_function(tick_interval_, tick_function_); + ssl_server_->signal_clear(); + for (auto snum : signals_) + { + ssl_server_->signal_add(snum); + } + notify_server_start(); + ssl_server_->run(); + } + else +#endif + { + server_ = std::move(std::unique_ptr(new server_t(this, bindaddr_, port_, server_name_, &middlewares_, concurrency_, timeout_, nullptr))); + server_->set_tick_function(tick_interval_, tick_function_); + server_->signal_clear(); + for (auto snum : signals_) + { + server_->signal_add(snum); + } + notify_server_start(); + server_->run(); + } + } + + /// Non-blocking version of \ref run() + std::future run_async() + { + return std::async(std::launch::async, [&] { + this->run(); + }); + } + + /// Stop the server + void stop() + { +#ifdef CROW_ENABLE_SSL + if (ssl_used_) + { + if (ssl_server_) { ssl_server_->stop(); } + } + else +#endif + { + if (server_) { server_->stop(); } + } + } + + /// Print the routing paths defined for each HTTP method + void debug_print() + { + CROW_LOG_DEBUG << "Routing:"; + router_.debug_print(); + } + + +#ifdef CROW_ENABLE_SSL + + /// Use certificate and key files for SSL + self_t& ssl_file(const std::string& crt_filename, const std::string& key_filename) + { + ssl_used_ = true; + ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer); + ssl_context_.set_verify_mode(boost::asio::ssl::verify_client_once); + ssl_context_.use_certificate_file(crt_filename, ssl_context_t::pem); + ssl_context_.use_private_key_file(key_filename, ssl_context_t::pem); + ssl_context_.set_options( + boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::no_sslv3); + return *this; + } + + /// Use .pem file for SSL + self_t& ssl_file(const std::string& pem_filename) + { + ssl_used_ = true; + ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer); + ssl_context_.set_verify_mode(boost::asio::ssl::verify_client_once); + ssl_context_.load_verify_file(pem_filename); + ssl_context_.set_options( + boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::no_sslv3); + return *this; + } + + /// Use certificate chain and key files for SSL + self_t& ssl_chainfile(const std::string& crt_filename, const std::string& key_filename) + { + ssl_used_ = true; + ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer); + ssl_context_.set_verify_mode(boost::asio::ssl::verify_client_once); + ssl_context_.use_certificate_chain_file(crt_filename); + ssl_context_.use_private_key_file(key_filename, ssl_context_t::pem); + ssl_context_.set_options( + boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::no_sslv3); + return *this; + } + + self_t& ssl(boost::asio::ssl::context&& ctx) + { + ssl_used_ = true; + ssl_context_ = std::move(ctx); + return *this; + } + + bool ssl_used() const + { + return ssl_used_; + } +#else + template + self_t& ssl_file(T&&, Remain&&...) + { + // We can't call .ssl() member function unless CROW_ENABLE_SSL is defined. + static_assert( + // make static_assert dependent to T; always false + std::is_base_of::value, + "Define CROW_ENABLE_SSL to enable ssl support."); + return *this; + } + + template + self_t& ssl_chainfile(T&&, Remain&&...) + { + // We can't call .ssl() member function unless CROW_ENABLE_SSL is defined. + static_assert( + // make static_assert dependent to T; always false + std::is_base_of::value, + "Define CROW_ENABLE_SSL to enable ssl support."); + return *this; + } + + template + self_t& ssl(T&&) + { + // We can't call .ssl() member function unless CROW_ENABLE_SSL is defined. + static_assert( + // make static_assert dependent to T; always false + std::is_base_of::value, + "Define CROW_ENABLE_SSL to enable ssl support."); + return *this; + } + + bool ssl_used() const + { + return false; + } +#endif + + // middleware + using context_t = detail::context; + using mw_container_t = std::tuple; + template + typename T::context& get_context(const request& req) + { + static_assert(black_magic::contains::value, "App doesn't have the specified middleware type."); + auto& ctx = *reinterpret_cast(req.middleware_context); + return ctx.template get(); + } + + template + T& get_middleware() + { + return utility::get_element_by_type(middlewares_); + } + + /// Wait until the server has properly started + void wait_for_server_start() + { + std::unique_lock lock(start_mutex_); + if (server_started_) + return; + cv_started_.wait(lock); + } + + private: + std::uint8_t timeout_{5}; + uint16_t port_ = 80; + uint16_t concurrency_ = 2; + bool validated_ = false; + std::string server_name_ = std::string("Crow/") + VERSION; + std::string bindaddr_ = "0.0.0.0"; + size_t res_stream_threshold_ = 1048576; + Router router_; + +#ifdef CROW_ENABLE_COMPRESSION + compression::algorithm comp_algorithm_; + bool compression_used_{false}; +#endif + + std::chrono::milliseconds tick_interval_; + std::function tick_function_; + + std::tuple middlewares_; + +#ifdef CROW_ENABLE_SSL + std::unique_ptr ssl_server_; + bool ssl_used_{false}; + ssl_context_t ssl_context_{boost::asio::ssl::context::sslv23}; +#endif + + std::unique_ptr server_; + + std::vector signals_{SIGINT, SIGTERM}; + + bool server_started_{false}; + std::condition_variable cv_started_; + std::mutex start_mutex_; + }; + template + using App = Crow; + using SimpleApp = Crow<>; +} // namespace crow + + + +#pragma once + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index dcb63c7..fbba207 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -24,7 +24,5 @@ target_include_directories(${TURBOPILOT_TARGET} PRIVATE target_link_libraries(${TURBOPILOT_TARGET} PRIVATE ggml argparse) -target_link_libraries(${TURBOPILOT_TARGET} PUBLIC Crow::Crow) - #target_link_libraries(${TURBOPILOT_TARGET} PRIVATE spdlog::spdlog_header_only) \ No newline at end of file diff --git a/src/main.cpp b/src/main.cpp index d951c63..d8435b5 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -4,7 +4,7 @@ #include -#include +#include #include