moneroexamples
2 years ago
committed by
GitHub
commit
aa96ce2927
@ -1,23 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include "crow/query_string.h"
|
|
||||||
#include "crow/http_parser_merged.h"
|
|
||||||
#include "crow/ci_map.h"
|
|
||||||
#include "crow/TinySHA1.hpp"
|
|
||||||
#include "crow/settings.h"
|
|
||||||
#include "crow/socket_adaptors.h"
|
|
||||||
#include "crow/json.h"
|
|
||||||
#include "crow/mustache.h"
|
|
||||||
#include "crow/logging.h"
|
|
||||||
#include "crow/dumb_timer_queue.h"
|
|
||||||
#include "crow/utility.h"
|
|
||||||
#include "crow/common.h"
|
|
||||||
#include "crow/http_request.h"
|
|
||||||
#include "crow/websocket.h"
|
|
||||||
#include "crow/parser.h"
|
|
||||||
#include "crow/http_response.h"
|
|
||||||
#include "crow/middleware.h"
|
|
||||||
#include "crow/routing.h"
|
|
||||||
#include "crow/middleware_context.h"
|
|
||||||
#include "crow/http_connection.h"
|
|
||||||
#include "crow/http_server.h"
|
|
||||||
#include "crow/app.h"
|
|
||||||
@ -1,196 +0,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 <mohaps@gmail.com>
|
|
||||||
*
|
|
||||||
* 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 <cstdio>
|
|
||||||
#include <cstdlib>
|
|
||||||
#include <cstring>
|
|
||||||
#include <stdint.h>
|
|
||||||
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<const uint8_t*>(start);
|
|
||||||
const uint8_t* finish = static_cast<const uint8_t*>(end);
|
|
||||||
while(begin != finish) {
|
|
||||||
processByte(*begin);
|
|
||||||
begin++;
|
|
||||||
}
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
SHA1& processBytes(const void* const data, size_t len) {
|
|
||||||
const uint8_t* block = static_cast<const uint8_t*>(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<unsigned char>((bitCount>>24) & 0xFF));
|
|
||||||
processByte( static_cast<unsigned char>((bitCount>>16) & 0xFF));
|
|
||||||
processByte( static_cast<unsigned char>((bitCount>>8 ) & 0xFF));
|
|
||||||
processByte( static_cast<unsigned char>((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
|
|
||||||
@ -1,248 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <chrono>
|
|
||||||
#include <string>
|
|
||||||
#include <functional>
|
|
||||||
#include <memory>
|
|
||||||
#include <future>
|
|
||||||
#include <cstdint>
|
|
||||||
#include <type_traits>
|
|
||||||
#include <thread>
|
|
||||||
|
|
||||||
#include "crow/settings.h"
|
|
||||||
#include "crow/logging.h"
|
|
||||||
#include "crow/utility.h"
|
|
||||||
#include "crow/routing.h"
|
|
||||||
#include "crow/middleware_context.h"
|
|
||||||
#include "crow/http_request.h"
|
|
||||||
#include "crow/http_server.h"
|
|
||||||
|
|
||||||
|
|
||||||
#ifdef CROW_MSVC_WORKAROUND
|
|
||||||
#define CROW_ROUTE(app, url) app.route_dynamic(url)
|
|
||||||
#else
|
|
||||||
#define CROW_ROUTE(app, url) app.route<crow::black_magic::get_parameter_tag(url)>(url)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
using ssl_context_t = boost::asio::ssl::context;
|
|
||||||
#endif
|
|
||||||
template <typename ... Middlewares>
|
|
||||||
class Crow
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
using self_t = Crow;
|
|
||||||
using server_t = Server<Crow, SocketAdaptor, Middlewares...>;
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
using ssl_server_t = Server<Crow, SSLAdaptor, Middlewares...>;
|
|
||||||
#endif
|
|
||||||
Crow()
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename Adaptor>
|
|
||||||
void handle_upgrade(const request& req, response& res, Adaptor&& adaptor)
|
|
||||||
{
|
|
||||||
router_.handle_upgrade(req, res, adaptor);
|
|
||||||
}
|
|
||||||
|
|
||||||
void handle(const request& req, response& res)
|
|
||||||
{
|
|
||||||
router_.handle(req, res);
|
|
||||||
}
|
|
||||||
|
|
||||||
DynamicRule& route_dynamic(std::string&& rule)
|
|
||||||
{
|
|
||||||
return router_.new_rule_dynamic(std::move(rule));
|
|
||||||
}
|
|
||||||
|
|
||||||
template <uint64_t Tag>
|
|
||||||
auto route(std::string&& rule)
|
|
||||||
-> typename std::result_of<decltype(&Router::new_rule_tagged<Tag>)(Router, std::string&&)>::type
|
|
||||||
{
|
|
||||||
return router_.new_rule_tagged<Tag>(std::move(rule));
|
|
||||||
}
|
|
||||||
|
|
||||||
self_t& port(std::uint16_t port)
|
|
||||||
{
|
|
||||||
port_ = port;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
self_t& bindaddr(std::string bindaddr)
|
|
||||||
{
|
|
||||||
bindaddr_ = bindaddr;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
self_t& multithreaded()
|
|
||||||
{
|
|
||||||
return concurrency(std::thread::hardware_concurrency());
|
|
||||||
}
|
|
||||||
|
|
||||||
self_t& concurrency(std::uint16_t concurrency)
|
|
||||||
{
|
|
||||||
if (concurrency < 1)
|
|
||||||
concurrency = 1;
|
|
||||||
concurrency_ = concurrency;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
void validate()
|
|
||||||
{
|
|
||||||
router_.validate();
|
|
||||||
}
|
|
||||||
|
|
||||||
void run()
|
|
||||||
{
|
|
||||||
validate();
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
if (use_ssl_)
|
|
||||||
{
|
|
||||||
ssl_server_ = std::move(std::unique_ptr<ssl_server_t>(new ssl_server_t(this, bindaddr_, port_, &middlewares_, concurrency_, &ssl_context_)));
|
|
||||||
ssl_server_->set_tick_function(tick_interval_, tick_function_);
|
|
||||||
ssl_server_->run();
|
|
||||||
}
|
|
||||||
else
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
server_ = std::move(std::unique_ptr<server_t>(new server_t(this, bindaddr_, port_, &middlewares_, concurrency_, nullptr)));
|
|
||||||
server_->set_tick_function(tick_interval_, tick_function_);
|
|
||||||
server_->run();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void stop()
|
|
||||||
{
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
if (use_ssl_)
|
|
||||||
{
|
|
||||||
ssl_server_->stop();
|
|
||||||
}
|
|
||||||
else
|
|
||||||
#endif
|
|
||||||
{
|
|
||||||
server_->stop();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void debug_print()
|
|
||||||
{
|
|
||||||
CROW_LOG_DEBUG << "Routing:";
|
|
||||||
router_.debug_print();
|
|
||||||
}
|
|
||||||
|
|
||||||
self_t& loglevel(crow::LogLevel level)
|
|
||||||
{
|
|
||||||
crow::logger::setLogLevel(level);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
self_t& ssl_file(const std::string& crt_filename, const std::string& key_filename)
|
|
||||||
{
|
|
||||||
use_ssl_ = true;
|
|
||||||
ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer);
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
|
|
||||||
self_t& ssl_file(const std::string& pem_filename)
|
|
||||||
{
|
|
||||||
use_ssl_ = true;
|
|
||||||
ssl_context_.set_verify_mode(boost::asio::ssl::verify_peer);
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
|
|
||||||
self_t& ssl(boost::asio::ssl::context&& ctx)
|
|
||||||
{
|
|
||||||
use_ssl_ = true;
|
|
||||||
ssl_context_ = std::move(ctx);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
bool use_ssl_{false};
|
|
||||||
ssl_context_t ssl_context_{boost::asio::ssl::context::sslv23};
|
|
||||||
|
|
||||||
#else
|
|
||||||
template <typename T, typename ... Remain>
|
|
||||||
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<T, void>::value,
|
|
||||||
"Define CROW_ENABLE_SSL to enable ssl support.");
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
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<T, void>::value,
|
|
||||||
"Define CROW_ENABLE_SSL to enable ssl support.");
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
// middleware
|
|
||||||
using context_t = detail::context<Middlewares...>;
|
|
||||||
template <typename T>
|
|
||||||
typename T::context& get_context(const request& req)
|
|
||||||
{
|
|
||||||
static_assert(black_magic::contains<T, Middlewares...>::value, "App doesn't have the specified middleware type.");
|
|
||||||
auto& ctx = *reinterpret_cast<context_t*>(req.middleware_context);
|
|
||||||
return ctx.template get<T>();
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
T& get_middleware()
|
|
||||||
{
|
|
||||||
return utility::get_element_by_type<T, Middlewares...>(middlewares_);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename Duration, typename Func>
|
|
||||||
self_t& tick(Duration d, Func f) {
|
|
||||||
tick_interval_ = std::chrono::duration_cast<std::chrono::milliseconds>(d);
|
|
||||||
tick_function_ = f;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
uint16_t port_ = 80;
|
|
||||||
uint16_t concurrency_ = 1;
|
|
||||||
std::string bindaddr_ = "0.0.0.0";
|
|
||||||
Router router_;
|
|
||||||
|
|
||||||
std::chrono::milliseconds tick_interval_;
|
|
||||||
std::function<void()> tick_function_;
|
|
||||||
|
|
||||||
std::tuple<Middlewares...> middlewares_;
|
|
||||||
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
std::unique_ptr<ssl_server_t> ssl_server_;
|
|
||||||
#endif
|
|
||||||
std::unique_ptr<server_t> server_;
|
|
||||||
};
|
|
||||||
template <typename ... Middlewares>
|
|
||||||
using App = Crow<Middlewares...>;
|
|
||||||
using SimpleApp = Crow<>;
|
|
||||||
}
|
|
||||||
@ -1,34 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <boost/algorithm/string/predicate.hpp>
|
|
||||||
#include <boost/functional/hash.hpp>
|
|
||||||
#include <unordered_map>
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
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<std::string, std::string, ci_hash, ci_key_eq>;
|
|
||||||
}
|
|
||||||
@ -1,142 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <vector>
|
|
||||||
#include <string>
|
|
||||||
#include <stdexcept>
|
|
||||||
#include <iostream>
|
|
||||||
#include "crow/utility.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
enum class HTTPMethod
|
|
||||||
{
|
|
||||||
#ifndef DELETE
|
|
||||||
DELETE = 0,
|
|
||||||
GET,
|
|
||||||
HEAD,
|
|
||||||
POST,
|
|
||||||
PUT,
|
|
||||||
CONNECT,
|
|
||||||
OPTIONS,
|
|
||||||
TRACE,
|
|
||||||
PATCH = 24,
|
|
||||||
#endif
|
|
||||||
|
|
||||||
Delete = 0,
|
|
||||||
Get,
|
|
||||||
Head,
|
|
||||||
Post,
|
|
||||||
Put,
|
|
||||||
Connect,
|
|
||||||
Options,
|
|
||||||
Trace,
|
|
||||||
Patch = 24,
|
|
||||||
};
|
|
||||||
|
|
||||||
inline std::string method_name(HTTPMethod method)
|
|
||||||
{
|
|
||||||
switch(method)
|
|
||||||
{
|
|
||||||
case HTTPMethod::Delete:
|
|
||||||
return "DELETE";
|
|
||||||
case HTTPMethod::Get:
|
|
||||||
return "GET";
|
|
||||||
case HTTPMethod::Head:
|
|
||||||
return "HEAD";
|
|
||||||
case HTTPMethod::Post:
|
|
||||||
return "POST";
|
|
||||||
case HTTPMethod::Put:
|
|
||||||
return "PUT";
|
|
||||||
case HTTPMethod::Connect:
|
|
||||||
return "CONNECT";
|
|
||||||
case HTTPMethod::Options:
|
|
||||||
return "OPTIONS";
|
|
||||||
case HTTPMethod::Trace:
|
|
||||||
return "TRACE";
|
|
||||||
case HTTPMethod::Patch:
|
|
||||||
return "PATCH";
|
|
||||||
}
|
|
||||||
return "invalid";
|
|
||||||
}
|
|
||||||
|
|
||||||
enum class ParamType
|
|
||||||
{
|
|
||||||
INT,
|
|
||||||
UINT,
|
|
||||||
DOUBLE,
|
|
||||||
STRING,
|
|
||||||
PATH,
|
|
||||||
|
|
||||||
MAX
|
|
||||||
};
|
|
||||||
|
|
||||||
struct routing_params
|
|
||||||
{
|
|
||||||
std::vector<int64_t> int_params;
|
|
||||||
std::vector<uint64_t> uint_params;
|
|
||||||
std::vector<double> double_params;
|
|
||||||
std::vector<std::string> 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 <typename T>
|
|
||||||
T get(unsigned) const;
|
|
||||||
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
inline int64_t routing_params::get<int64_t>(unsigned index) const
|
|
||||||
{
|
|
||||||
return int_params[index];
|
|
||||||
}
|
|
||||||
|
|
||||||
template<>
|
|
||||||
inline uint64_t routing_params::get<uint64_t>(unsigned index) const
|
|
||||||
{
|
|
||||||
return uint_params[index];
|
|
||||||
}
|
|
||||||
|
|
||||||
template<>
|
|
||||||
inline double routing_params::get<double>(unsigned index) const
|
|
||||||
{
|
|
||||||
return double_params[index];
|
|
||||||
}
|
|
||||||
|
|
||||||
template<>
|
|
||||||
inline std::string routing_params::get<std::string>(unsigned index) const
|
|
||||||
{
|
|
||||||
return string_params[index];
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifndef CROW_MSVC_WORKAROUND
|
|
||||||
constexpr crow::HTTPMethod operator "" _method(const char* str, size_t /*len*/)
|
|
||||||
{
|
|
||||||
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 :
|
|
||||||
throw std::runtime_error("invalid http method");
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
@ -1,81 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <boost/asio.hpp>
|
|
||||||
#include <deque>
|
|
||||||
#include <functional>
|
|
||||||
#include <chrono>
|
|
||||||
#include <thread>
|
|
||||||
|
|
||||||
#include "crow/logging.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
namespace detail
|
|
||||||
{
|
|
||||||
// fast timer queue for fixed tick value.
|
|
||||||
class dumb_timer_queue
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
using key = std::pair<dumb_timer_queue*, int>;
|
|
||||||
|
|
||||||
void cancel(key& k)
|
|
||||||
{
|
|
||||||
auto self = k.first;
|
|
||||||
k.first = nullptr;
|
|
||||||
if (!self)
|
|
||||||
return;
|
|
||||||
|
|
||||||
unsigned int index = (unsigned int)(k.second - self->step_);
|
|
||||||
if (index < self->dq_.size())
|
|
||||||
self->dq_[index].second = nullptr;
|
|
||||||
}
|
|
||||||
|
|
||||||
key add(std::function<void()> f)
|
|
||||||
{
|
|
||||||
dq_.emplace_back(std::chrono::steady_clock::now(), std::move(f));
|
|
||||||
int ret = step_+dq_.size()-1;
|
|
||||||
|
|
||||||
CROW_LOG_DEBUG << "timer add inside: " << this << ' ' << ret ;
|
|
||||||
return {this, ret};
|
|
||||||
}
|
|
||||||
|
|
||||||
void process()
|
|
||||||
{
|
|
||||||
if (!io_service_)
|
|
||||||
return;
|
|
||||||
|
|
||||||
auto now = std::chrono::steady_clock::now();
|
|
||||||
while(!dq_.empty())
|
|
||||||
{
|
|
||||||
auto& x = dq_.front();
|
|
||||||
if (now - x.first < std::chrono::seconds(tick))
|
|
||||||
break;
|
|
||||||
if (x.second)
|
|
||||||
{
|
|
||||||
CROW_LOG_DEBUG << "timer call: " << this << ' ' << step_;
|
|
||||||
// we know that timer handlers are very simple currenty; call here
|
|
||||||
x.second();
|
|
||||||
}
|
|
||||||
dq_.pop_front();
|
|
||||||
step_++;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void set_io_service(boost::asio::io_service& io_service)
|
|
||||||
{
|
|
||||||
io_service_ = &io_service;
|
|
||||||
}
|
|
||||||
|
|
||||||
dumb_timer_queue() noexcept
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
|
|
||||||
int tick{5};
|
|
||||||
boost::asio::io_service* io_service_{};
|
|
||||||
std::deque<std::pair<decltype(std::chrono::steady_clock::now()), std::function<void()>>> dq_;
|
|
||||||
int step_{};
|
|
||||||
};
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,602 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include <boost/asio.hpp>
|
|
||||||
#include <boost/algorithm/string/predicate.hpp>
|
|
||||||
#include <boost/lexical_cast.hpp>
|
|
||||||
#include <boost/array.hpp>
|
|
||||||
#include <atomic>
|
|
||||||
#include <chrono>
|
|
||||||
#include <vector>
|
|
||||||
|
|
||||||
#include "crow/http_parser_merged.h"
|
|
||||||
|
|
||||||
#include "crow/parser.h"
|
|
||||||
#include "crow/http_response.h"
|
|
||||||
#include "crow/logging.h"
|
|
||||||
#include "crow/settings.h"
|
|
||||||
#include "crow/dumb_timer_queue.h"
|
|
||||||
#include "crow/middleware_context.h"
|
|
||||||
#include "crow/socket_adaptors.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
using namespace boost;
|
|
||||||
using tcp = asio::ip::tcp;
|
|
||||||
|
|
||||||
namespace detail
|
|
||||||
{
|
|
||||||
template <typename MW>
|
|
||||||
struct check_before_handle_arity_3_const
|
|
||||||
{
|
|
||||||
template <typename T,
|
|
||||||
void (T::*)(request&, response&, typename MW::context&) const = &T::before_handle
|
|
||||||
>
|
|
||||||
struct get
|
|
||||||
{ };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename MW>
|
|
||||||
struct check_before_handle_arity_3
|
|
||||||
{
|
|
||||||
template <typename T,
|
|
||||||
void (T::*)(request&, response&, typename MW::context&) = &T::before_handle
|
|
||||||
>
|
|
||||||
struct get
|
|
||||||
{ };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename MW>
|
|
||||||
struct check_after_handle_arity_3_const
|
|
||||||
{
|
|
||||||
template <typename T,
|
|
||||||
void (T::*)(request&, response&, typename MW::context&) const = &T::after_handle
|
|
||||||
>
|
|
||||||
struct get
|
|
||||||
{ };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename MW>
|
|
||||||
struct check_after_handle_arity_3
|
|
||||||
{
|
|
||||||
template <typename T,
|
|
||||||
void (T::*)(request&, response&, typename MW::context&) = &T::after_handle
|
|
||||||
>
|
|
||||||
struct get
|
|
||||||
{ };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct is_before_handle_arity_3_impl
|
|
||||||
{
|
|
||||||
template <typename C>
|
|
||||||
static std::true_type f(typename check_before_handle_arity_3_const<T>::template get<C>*);
|
|
||||||
|
|
||||||
template <typename C>
|
|
||||||
static std::true_type f(typename check_before_handle_arity_3<T>::template get<C>*);
|
|
||||||
|
|
||||||
template <typename C>
|
|
||||||
static std::false_type f(...);
|
|
||||||
|
|
||||||
public:
|
|
||||||
static const bool value = decltype(f<T>(nullptr))::value;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct is_after_handle_arity_3_impl
|
|
||||||
{
|
|
||||||
template <typename C>
|
|
||||||
static std::true_type f(typename check_after_handle_arity_3_const<T>::template get<C>*);
|
|
||||||
|
|
||||||
template <typename C>
|
|
||||||
static std::true_type f(typename check_after_handle_arity_3<T>::template get<C>*);
|
|
||||||
|
|
||||||
template <typename C>
|
|
||||||
static std::false_type f(...);
|
|
||||||
|
|
||||||
public:
|
|
||||||
static const bool value = decltype(f<T>(nullptr))::value;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename MW, typename Context, typename ParentContext>
|
|
||||||
typename std::enable_if<!is_before_handle_arity_3_impl<MW>::value>::type
|
|
||||||
before_handler_call(MW& mw, request& req, response& res, Context& ctx, ParentContext& /*parent_ctx*/)
|
|
||||||
{
|
|
||||||
mw.before_handle(req, res, ctx.template get<MW>(), ctx);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename MW, typename Context, typename ParentContext>
|
|
||||||
typename std::enable_if<is_before_handle_arity_3_impl<MW>::value>::type
|
|
||||||
before_handler_call(MW& mw, request& req, response& res, Context& ctx, ParentContext& /*parent_ctx*/)
|
|
||||||
{
|
|
||||||
mw.before_handle(req, res, ctx.template get<MW>());
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename MW, typename Context, typename ParentContext>
|
|
||||||
typename std::enable_if<!is_after_handle_arity_3_impl<MW>::value>::type
|
|
||||||
after_handler_call(MW& mw, request& req, response& res, Context& ctx, ParentContext& /*parent_ctx*/)
|
|
||||||
{
|
|
||||||
mw.after_handle(req, res, ctx.template get<MW>(), ctx);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename MW, typename Context, typename ParentContext>
|
|
||||||
typename std::enable_if<is_after_handle_arity_3_impl<MW>::value>::type
|
|
||||||
after_handler_call(MW& mw, request& req, response& res, Context& ctx, ParentContext& /*parent_ctx*/)
|
|
||||||
{
|
|
||||||
mw.after_handle(req, res, ctx.template get<MW>());
|
|
||||||
}
|
|
||||||
|
|
||||||
template <int N, typename Context, typename Container, typename CurrentMW, typename ... Middlewares>
|
|
||||||
bool middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx)
|
|
||||||
{
|
|
||||||
using parent_context_t = typename Context::template partial<N-1>;
|
|
||||||
before_handler_call<CurrentMW, Context, parent_context_t>(std::get<N>(middlewares), req, res, ctx, static_cast<parent_context_t&>(ctx));
|
|
||||||
|
|
||||||
if (res.is_completed())
|
|
||||||
{
|
|
||||||
after_handler_call<CurrentMW, Context, parent_context_t>(std::get<N>(middlewares), req, res, ctx, static_cast<parent_context_t&>(ctx));
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (middleware_call_helper<N+1, Context, Container, Middlewares...>(middlewares, req, res, ctx))
|
|
||||||
{
|
|
||||||
after_handler_call<CurrentMW, Context, parent_context_t>(std::get<N>(middlewares), req, res, ctx, static_cast<parent_context_t&>(ctx));
|
|
||||||
return true;
|
|
||||||
}
|
|
||||||
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <int N, typename Context, typename Container>
|
|
||||||
bool middleware_call_helper(Container& /*middlewares*/, request& /*req*/, response& /*res*/, Context& /*ctx*/)
|
|
||||||
{
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <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 <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<N-1>;
|
|
||||||
using CurrentMW = typename std::tuple_element<N, typename std::remove_reference<Container>::type>::type;
|
|
||||||
after_handler_call<CurrentMW, Context, parent_context_t>(std::get<N>(middlewares), req, res, ctx, static_cast<parent_context_t&>(ctx));
|
|
||||||
}
|
|
||||||
|
|
||||||
template <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<N-1>;
|
|
||||||
using CurrentMW = typename std::tuple_element<N, typename std::remove_reference<Container>::type>::type;
|
|
||||||
after_handler_call<CurrentMW, Context, parent_context_t>(std::get<N>(middlewares), req, res, ctx, static_cast<parent_context_t&>(ctx));
|
|
||||||
after_handlers_call_helper<N-1, Context, Container>(middlewares, ctx, req, res);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef CROW_ENABLE_DEBUG
|
|
||||||
static std::atomic<int> connectionCount;
|
|
||||||
#endif
|
|
||||||
template <typename Adaptor, typename Handler, typename ... Middlewares>
|
|
||||||
class Connection
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
Connection(
|
|
||||||
boost::asio::io_service& io_service,
|
|
||||||
Handler* handler,
|
|
||||||
const std::string& server_name,
|
|
||||||
std::tuple<Middlewares...>* middlewares,
|
|
||||||
std::function<std::string()>& get_cached_date_str_f,
|
|
||||||
detail::dumb_timer_queue& timer_queue,
|
|
||||||
typename Adaptor::context* adaptor_ctx_
|
|
||||||
)
|
|
||||||
: adaptor_(io_service, adaptor_ctx_),
|
|
||||||
handler_(handler),
|
|
||||||
parser_(this),
|
|
||||||
server_name_(server_name),
|
|
||||||
middlewares_(middlewares),
|
|
||||||
get_cached_date_str(get_cached_date_str_f),
|
|
||||||
timer_queue(timer_queue)
|
|
||||||
{
|
|
||||||
#ifdef CROW_ENABLE_DEBUG
|
|
||||||
connectionCount ++;
|
|
||||||
CROW_LOG_DEBUG << "Connection open, total " << connectionCount << ", " << this;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
~Connection()
|
|
||||||
{
|
|
||||||
res.complete_request_handler_ = nullptr;
|
|
||||||
cancel_deadline_timer();
|
|
||||||
#ifdef CROW_ENABLE_DEBUG
|
|
||||||
connectionCount --;
|
|
||||||
CROW_LOG_DEBUG << "Connection closed, total " << connectionCount << ", " << this;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
decltype(std::declval<Adaptor>().raw_socket())& socket()
|
|
||||||
{
|
|
||||||
return adaptor_.raw_socket();
|
|
||||||
}
|
|
||||||
|
|
||||||
void start()
|
|
||||||
{
|
|
||||||
adaptor_.start([this](const boost::system::error_code& ec) {
|
|
||||||
if (!ec)
|
|
||||||
{
|
|
||||||
start_deadline();
|
|
||||||
|
|
||||||
do_read();
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
check_destroy();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
void handle_header()
|
|
||||||
{
|
|
||||||
// HTTP 1.1 Expect: 100-continue
|
|
||||||
if (parser_.check_version(1, 1) && parser_.headers.count("expect") && get_header_value(parser_.headers, "expect") == "100-continue")
|
|
||||||
{
|
|
||||||
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_;
|
|
||||||
|
|
||||||
if (parser_.check_version(1, 0))
|
|
||||||
{
|
|
||||||
// HTTP/1.0
|
|
||||||
if (req.headers.count("connection"))
|
|
||||||
{
|
|
||||||
if (boost::iequals(req.get_header_value("connection"),"Keep-Alive"))
|
|
||||||
add_keep_alive_ = true;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
close_connection_ = true;
|
|
||||||
}
|
|
||||||
else if (parser_.check_version(1, 1))
|
|
||||||
{
|
|
||||||
// HTTP/1.1
|
|
||||||
if (req.headers.count("connection"))
|
|
||||||
{
|
|
||||||
if (req.get_header_value("connection") == "close")
|
|
||||||
close_connection_ = true;
|
|
||||||
else if (boost::iequals(req.get_header_value("connection"),"Keep-Alive"))
|
|
||||||
add_keep_alive_ = true;
|
|
||||||
}
|
|
||||||
if (!req.headers.count("host"))
|
|
||||||
{
|
|
||||||
is_invalid_request = true;
|
|
||||||
res = response(400);
|
|
||||||
}
|
|
||||||
if (parser_.is_upgrade())
|
|
||||||
{
|
|
||||||
if (req.get_header_value("upgrade") == "h2c")
|
|
||||||
{
|
|
||||||
// TODO 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<std::string>(adaptor_.remote_endpoint()) << " " << this << " HTTP/" << parser_.http_major << "." << parser_.http_minor << ' '
|
|
||||||
<< 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<Middlewares...>();
|
|
||||||
req.middleware_context = (void*)&ctx_;
|
|
||||||
req.io_service = &adaptor_.get_io_service();
|
|
||||||
detail::middleware_call_helper<0, decltype(ctx_), decltype(*middlewares_), Middlewares...>(*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();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
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<
|
|
||||||
((int)sizeof...(Middlewares)-1),
|
|
||||||
decltype(ctx_),
|
|
||||||
decltype(*middlewares_)>
|
|
||||||
(*middlewares_, ctx_, req_, res);
|
|
||||||
}
|
|
||||||
|
|
||||||
//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;
|
|
||||||
}
|
|
||||||
|
|
||||||
static std::unordered_map<int, std::string> statusCodes = {
|
|
||||||
{200, "HTTP/1.1 200 OK\r\n"},
|
|
||||||
{201, "HTTP/1.1 201 Created\r\n"},
|
|
||||||
{202, "HTTP/1.1 202 Accepted\r\n"},
|
|
||||||
{204, "HTTP/1.1 204 No Content\r\n"},
|
|
||||||
|
|
||||||
{300, "HTTP/1.1 300 Multiple Choices\r\n"},
|
|
||||||
{301, "HTTP/1.1 301 Moved Permanently\r\n"},
|
|
||||||
{302, "HTTP/1.1 302 Moved Temporarily\r\n"},
|
|
||||||
{304, "HTTP/1.1 304 Not Modified\r\n"},
|
|
||||||
|
|
||||||
{400, "HTTP/1.1 400 Bad Request\r\n"},
|
|
||||||
{401, "HTTP/1.1 401 Unauthorized\r\n"},
|
|
||||||
{403, "HTTP/1.1 403 Forbidden\r\n"},
|
|
||||||
{404, "HTTP/1.1 404 Not Found\r\n"},
|
|
||||||
{413, "HTTP/1.1 413 Payload Too Large\r\n"},
|
|
||||||
{422, "HTTP/1.1 422 Unprocessable Entity\r\n"},
|
|
||||||
{429, "HTTP/1.1 429 Too Many Requests\r\n"},
|
|
||||||
|
|
||||||
{500, "HTTP/1.1 500 Internal Server Error\r\n"},
|
|
||||||
{501, "HTTP/1.1 501 Not Implemented\r\n"},
|
|
||||||
{502, "HTTP/1.1 502 Bad Gateway\r\n"},
|
|
||||||
{503, "HTTP/1.1 503 Service Unavailable\r\n"},
|
|
||||||
};
|
|
||||||
|
|
||||||
static std::string seperator = ": ";
|
|
||||||
static std::string crlf = "\r\n";
|
|
||||||
|
|
||||||
buffers_.clear();
|
|
||||||
buffers_.reserve(4*(res.headers.size()+5)+3);
|
|
||||||
|
|
||||||
if (res.body.empty() && res.json_value.t() == json::type::Object)
|
|
||||||
{
|
|
||||||
res.body = json::dump(res.json_value);
|
|
||||||
}
|
|
||||||
|
|
||||||
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.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());
|
|
||||||
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();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
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_.close();
|
|
||||||
is_reading = false;
|
|
||||||
CROW_LOG_DEBUG << this << " from read(1)";
|
|
||||||
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();
|
|
||||||
if (!ec)
|
|
||||||
{
|
|
||||||
if (close_connection_)
|
|
||||||
{
|
|
||||||
adaptor_.close();
|
|
||||||
CROW_LOG_DEBUG << this << " from write(1)";
|
|
||||||
check_destroy();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
CROW_LOG_DEBUG << this << " from write(2)";
|
|
||||||
check_destroy();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
void check_destroy()
|
|
||||||
{
|
|
||||||
CROW_LOG_DEBUG << this << " is_reading " << is_reading << " is_writing " << is_writing;
|
|
||||||
if (!is_reading && !is_writing)
|
|
||||||
{
|
|
||||||
CROW_LOG_DEBUG << this << " delete (idle) ";
|
|
||||||
delete this;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void cancel_deadline_timer()
|
|
||||||
{
|
|
||||||
CROW_LOG_DEBUG << this << " timer cancelled: " << timer_cancel_key_.first << ' ' << timer_cancel_key_.second;
|
|
||||||
timer_queue.cancel(timer_cancel_key_);
|
|
||||||
}
|
|
||||||
|
|
||||||
void start_deadline(/*int timeout = 5*/)
|
|
||||||
{
|
|
||||||
cancel_deadline_timer();
|
|
||||||
|
|
||||||
timer_cancel_key_ = timer_queue.add([this]
|
|
||||||
{
|
|
||||||
if (!adaptor_.is_open())
|
|
||||||
{
|
|
||||||
return;
|
|
||||||
}
|
|
||||||
adaptor_.close();
|
|
||||||
});
|
|
||||||
CROW_LOG_DEBUG << this << " timer added: " << timer_cancel_key_.first << ' ' << timer_cancel_key_.second;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
Adaptor adaptor_;
|
|
||||||
Handler* handler_;
|
|
||||||
|
|
||||||
boost::array<char, 4096> buffer_;
|
|
||||||
|
|
||||||
HTTPParser<Connection> parser_;
|
|
||||||
request req_;
|
|
||||||
response res;
|
|
||||||
|
|
||||||
bool close_connection_ = false;
|
|
||||||
|
|
||||||
const std::string& server_name_;
|
|
||||||
std::vector<boost::asio::const_buffer> buffers_;
|
|
||||||
|
|
||||||
std::string content_length_;
|
|
||||||
std::string date_str_;
|
|
||||||
std::string res_body_copy_;
|
|
||||||
|
|
||||||
//boost::asio::deadline_timer deadline_;
|
|
||||||
detail::dumb_timer_queue::key timer_cancel_key_;
|
|
||||||
|
|
||||||
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...>* middlewares_;
|
|
||||||
detail::context<Middlewares...> ctx_;
|
|
||||||
|
|
||||||
std::function<std::string()>& get_cached_date_str;
|
|
||||||
detail::dumb_timer_queue& timer_queue;
|
|
||||||
};
|
|
||||||
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,69 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <boost/asio.hpp>
|
|
||||||
|
|
||||||
#include "crow/common.h"
|
|
||||||
#include "crow/ci_map.h"
|
|
||||||
#include "crow/query_string.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
template <typename T>
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
|
|
||||||
struct DetachHelper;
|
|
||||||
|
|
||||||
struct request
|
|
||||||
{
|
|
||||||
HTTPMethod method;
|
|
||||||
std::string raw_url;
|
|
||||||
std::string url;
|
|
||||||
query_string url_params;
|
|
||||||
ci_map headers;
|
|
||||||
std::string body;
|
|
||||||
|
|
||||||
void* middleware_context{};
|
|
||||||
boost::asio::io_service* io_service{};
|
|
||||||
|
|
||||||
request()
|
|
||||||
: method(HTTPMethod::Get)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
request(HTTPMethod method, std::string raw_url, std::string url, query_string url_params, ci_map headers, std::string body)
|
|
||||||
: 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))
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename CompletionHandler>
|
|
||||||
void post(CompletionHandler handler)
|
|
||||||
{
|
|
||||||
io_service->post(handler);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename CompletionHandler>
|
|
||||||
void dispatch(CompletionHandler handler)
|
|
||||||
{
|
|
||||||
io_service->dispatch(handler);
|
|
||||||
}
|
|
||||||
|
|
||||||
};
|
|
||||||
}
|
|
||||||
@ -1,135 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include <string>
|
|
||||||
#include <unordered_map>
|
|
||||||
|
|
||||||
#include "crow/json.h"
|
|
||||||
#include "crow/http_request.h"
|
|
||||||
#include "crow/ci_map.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
template <typename Adaptor, typename Handler, typename ... Middlewares>
|
|
||||||
class Connection;
|
|
||||||
struct response
|
|
||||||
{
|
|
||||||
template <typename Adaptor, typename Handler, typename ... Middlewares>
|
|
||||||
friend class crow::Connection;
|
|
||||||
|
|
||||||
int code{200};
|
|
||||||
std::string body;
|
|
||||||
json::wvalue json_value;
|
|
||||||
|
|
||||||
// `headers' stores HTTP headers.
|
|
||||||
ci_map headers;
|
|
||||||
|
|
||||||
void set_header(std::string key, std::string value)
|
|
||||||
{
|
|
||||||
headers.erase(key);
|
|
||||||
headers.emplace(std::move(key), std::move(value));
|
|
||||||
}
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
response() {}
|
|
||||||
explicit response(int code) : code(code) {}
|
|
||||||
response(std::string body) : body(std::move(body)) {}
|
|
||||||
response(json::wvalue&& json_value) : json_value(std::move(json_value))
|
|
||||||
{
|
|
||||||
json_mode();
|
|
||||||
}
|
|
||||||
response(int code, std::string body) : code(code), body(std::move(body)) {}
|
|
||||||
response(const json::wvalue& json_value) : body(json::dump(json_value))
|
|
||||||
{
|
|
||||||
json_mode();
|
|
||||||
}
|
|
||||||
response(int code, const json::wvalue& json_value) : code(code), body(json::dump(json_value))
|
|
||||||
{
|
|
||||||
json_mode();
|
|
||||||
}
|
|
||||||
|
|
||||||
response(response&& r)
|
|
||||||
{
|
|
||||||
*this = std::move(r);
|
|
||||||
}
|
|
||||||
|
|
||||||
response& operator = (const response& r) = delete;
|
|
||||||
|
|
||||||
response& operator = (response&& r) noexcept
|
|
||||||
{
|
|
||||||
body = std::move(r.body);
|
|
||||||
json_value = std::move(r.json_value);
|
|
||||||
code = r.code;
|
|
||||||
headers = std::move(r.headers);
|
|
||||||
completed_ = r.completed_;
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_completed() const noexcept
|
|
||||||
{
|
|
||||||
return completed_;
|
|
||||||
}
|
|
||||||
|
|
||||||
void clear()
|
|
||||||
{
|
|
||||||
body.clear();
|
|
||||||
json_value.clear();
|
|
||||||
code = 200;
|
|
||||||
headers.clear();
|
|
||||||
completed_ = false;
|
|
||||||
}
|
|
||||||
|
|
||||||
void redirect(const std::string& location)
|
|
||||||
{
|
|
||||||
code = 301;
|
|
||||||
set_header("Location", location);
|
|
||||||
}
|
|
||||||
|
|
||||||
void write(const std::string& body_part)
|
|
||||||
{
|
|
||||||
body += body_part;
|
|
||||||
}
|
|
||||||
|
|
||||||
void end()
|
|
||||||
{
|
|
||||||
if (!completed_)
|
|
||||||
{
|
|
||||||
completed_ = true;
|
|
||||||
|
|
||||||
if (complete_request_handler_)
|
|
||||||
{
|
|
||||||
complete_request_handler_();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void end(const std::string& body_part)
|
|
||||||
{
|
|
||||||
body += body_part;
|
|
||||||
end();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_alive()
|
|
||||||
{
|
|
||||||
return is_alive_helper_ && is_alive_helper_();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
bool completed_{};
|
|
||||||
std::function<void()> complete_request_handler_;
|
|
||||||
std::function<bool()> is_alive_helper_;
|
|
||||||
|
|
||||||
//In case of a JSON object, set the Content-Type header
|
|
||||||
void json_mode()
|
|
||||||
{
|
|
||||||
set_header("Content-Type", "application/json");
|
|
||||||
}
|
|
||||||
};
|
|
||||||
}
|
|
||||||
@ -1,240 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <chrono>
|
|
||||||
#include <boost/date_time/posix_time/posix_time.hpp>
|
|
||||||
#include <boost/asio.hpp>
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
#include <boost/asio/ssl.hpp>
|
|
||||||
#endif
|
|
||||||
#include <cstdint>
|
|
||||||
#include <atomic>
|
|
||||||
#include <future>
|
|
||||||
#include <vector>
|
|
||||||
|
|
||||||
#include <memory>
|
|
||||||
|
|
||||||
#include "crow/http_connection.h"
|
|
||||||
#include "crow/logging.h"
|
|
||||||
#include "crow/dumb_timer_queue.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
using namespace boost;
|
|
||||||
using tcp = asio::ip::tcp;
|
|
||||||
|
|
||||||
template <typename Handler, typename Adaptor = SocketAdaptor, typename ... Middlewares>
|
|
||||||
class Server
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
Server(Handler* handler, std::string bindaddr, uint16_t port, std::tuple<Middlewares...>* middlewares = nullptr, uint16_t concurrency = 1, typename Adaptor::context* adaptor_ctx = nullptr)
|
|
||||||
: acceptor_(io_service_, tcp::endpoint(boost::asio::ip::address::from_string(bindaddr), port)),
|
|
||||||
signals_(io_service_, SIGINT, SIGTERM),
|
|
||||||
tick_timer_(io_service_),
|
|
||||||
handler_(handler),
|
|
||||||
concurrency_(concurrency),
|
|
||||||
port_(port),
|
|
||||||
bindaddr_(bindaddr),
|
|
||||||
middlewares_(middlewares),
|
|
||||||
adaptor_ctx_(adaptor_ctx)
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
void set_tick_function(std::chrono::milliseconds d, std::function<void()> 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()
|
|
||||||
{
|
|
||||||
if (concurrency_ < 0)
|
|
||||||
concurrency_ = 1;
|
|
||||||
|
|
||||||
for(int i = 0; i < concurrency_; i++)
|
|
||||||
io_service_pool_.emplace_back(new boost::asio::io_service());
|
|
||||||
get_cached_date_str_pool_.resize(concurrency_);
|
|
||||||
timer_queue_pool_.resize(concurrency_);
|
|
||||||
|
|
||||||
std::vector<std::future<void>> v;
|
|
||||||
std::atomic<int> init_count(0);
|
|
||||||
for(uint16_t i = 0; i < concurrency_; 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;
|
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
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 timer queue
|
|
||||||
detail::dumb_timer_queue timer_queue;
|
|
||||||
timer_queue_pool_[i] = &timer_queue;
|
|
||||||
|
|
||||||
timer_queue.set_io_service(*io_service_pool_[i]);
|
|
||||||
boost::asio::deadline_timer timer(*io_service_pool_[i]);
|
|
||||||
timer.expires_from_now(boost::posix_time::seconds(1));
|
|
||||||
|
|
||||||
std::function<void(const boost::system::error_code& ec)> handler;
|
|
||||||
handler = [&](const boost::system::error_code& ec){
|
|
||||||
if (ec)
|
|
||||||
return;
|
|
||||||
timer_queue.process();
|
|
||||||
timer.expires_from_now(boost::posix_time::seconds(1));
|
|
||||||
timer.async_wait(handler);
|
|
||||||
};
|
|
||||||
timer.async_wait(handler);
|
|
||||||
|
|
||||||
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();
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
CROW_LOG_INFO << server_name_ << " server is running at " << bindaddr_ <<":" << 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(concurrency_ != 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();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
asio::io_service& pick_io_service()
|
|
||||||
{
|
|
||||||
// TODO load balancing
|
|
||||||
roundrobin_index_++;
|
|
||||||
if (roundrobin_index_ >= io_service_pool_.size())
|
|
||||||
roundrobin_index_ = 0;
|
|
||||||
return *io_service_pool_[roundrobin_index_];
|
|
||||||
}
|
|
||||||
|
|
||||||
void do_accept()
|
|
||||||
{
|
|
||||||
asio::io_service& is = pick_io_service();
|
|
||||||
auto p = new Connection<Adaptor, Handler, Middlewares...>(
|
|
||||||
is, handler_, server_name_, middlewares_,
|
|
||||||
get_cached_date_str_pool_[roundrobin_index_], *timer_queue_pool_[roundrobin_index_],
|
|
||||||
adaptor_ctx_);
|
|
||||||
acceptor_.async_accept(p->socket(),
|
|
||||||
[this, p, &is](boost::system::error_code ec)
|
|
||||||
{
|
|
||||||
if (!ec)
|
|
||||||
{
|
|
||||||
is.post([p]
|
|
||||||
{
|
|
||||||
p->start();
|
|
||||||
});
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
delete p;
|
|
||||||
}
|
|
||||||
do_accept();
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
asio::io_service io_service_;
|
|
||||||
std::vector<std::unique_ptr<asio::io_service>> io_service_pool_;
|
|
||||||
std::vector<detail::dumb_timer_queue*> timer_queue_pool_;
|
|
||||||
std::vector<std::function<std::string()>> get_cached_date_str_pool_;
|
|
||||||
tcp::acceptor acceptor_;
|
|
||||||
boost::asio::signal_set signals_;
|
|
||||||
boost::asio::deadline_timer tick_timer_;
|
|
||||||
|
|
||||||
Handler* handler_;
|
|
||||||
uint16_t concurrency_{1};
|
|
||||||
std::string server_name_ = "Crow/0.1";
|
|
||||||
uint16_t port_;
|
|
||||||
std::string bindaddr_;
|
|
||||||
unsigned int roundrobin_index_{};
|
|
||||||
|
|
||||||
std::chrono::milliseconds tick_interval_;
|
|
||||||
std::function<void()> tick_function_;
|
|
||||||
|
|
||||||
std::tuple<Middlewares...>* middlewares_;
|
|
||||||
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
bool use_ssl_{false};
|
|
||||||
boost::asio::ssl::context ssl_context_{boost::asio::ssl::context::sslv23};
|
|
||||||
#endif
|
|
||||||
typename Adaptor::context* adaptor_ctx_;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,142 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <string>
|
|
||||||
#include <cstdio>
|
|
||||||
#include <cstdlib>
|
|
||||||
#include <ctime>
|
|
||||||
#include <iostream>
|
|
||||||
#include <sstream>
|
|
||||||
|
|
||||||
#include "crow/settings.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
enum class LogLevel
|
|
||||||
{
|
|
||||||
#ifndef ERROR
|
|
||||||
DEBUG = 0,
|
|
||||||
INFO,
|
|
||||||
WARNING,
|
|
||||||
ERROR,
|
|
||||||
CRITICAL,
|
|
||||||
#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::cerr << message;
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
class logger {
|
|
||||||
|
|
||||||
private:
|
|
||||||
//
|
|
||||||
static std::string timestamp()
|
|
||||||
{
|
|
||||||
char date[32];
|
|
||||||
time_t t = time(0);
|
|
||||||
|
|
||||||
tm my_tm;
|
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
gmtime_s(&my_tm, &t);
|
|
||||||
#else
|
|
||||||
gmtime_r(&t, &my_tm);
|
|
||||||
#endif
|
|
||||||
|
|
||||||
size_t sz = strftime(date, sizeof(date), "%Y-%m-%d %H:%M:%S", &my_tm);
|
|
||||||
return std::string(date, date+sz);
|
|
||||||
}
|
|
||||||
|
|
||||||
public:
|
|
||||||
|
|
||||||
|
|
||||||
logger(std::string prefix, LogLevel level) : level_(level) {
|
|
||||||
#ifdef CROW_ENABLE_LOGGING
|
|
||||||
stringstream_ << "(" << timestamp() << ") [" << prefix << "] ";
|
|
||||||
#endif
|
|
||||||
|
|
||||||
}
|
|
||||||
~logger() {
|
|
||||||
#ifdef CROW_ENABLE_LOGGING
|
|
||||||
if(level_ >= get_current_log_level()) {
|
|
||||||
stringstream_ << std::endl;
|
|
||||||
get_handler_ref()->log(stringstream_.str(), level_);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
//
|
|
||||||
template <typename T>
|
|
||||||
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 = (LogLevel)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_;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
#define CROW_LOG_CRITICAL \
|
|
||||||
if (crow::logger::get_current_log_level() <= crow::LogLevel::Critical) \
|
|
||||||
crow::logger("CRITICAL", crow::LogLevel::Critical)
|
|
||||||
#define CROW_LOG_ERROR \
|
|
||||||
if (crow::logger::get_current_log_level() <= crow::LogLevel::Error) \
|
|
||||||
crow::logger("ERROR ", crow::LogLevel::Error)
|
|
||||||
#define CROW_LOG_WARNING \
|
|
||||||
if (crow::logger::get_current_log_level() <= crow::LogLevel::Warning) \
|
|
||||||
crow::logger("WARNING ", crow::LogLevel::Warning)
|
|
||||||
#define CROW_LOG_INFO \
|
|
||||||
if (crow::logger::get_current_log_level() <= crow::LogLevel::Info) \
|
|
||||||
crow::logger("INFO ", crow::LogLevel::Info)
|
|
||||||
#define CROW_LOG_DEBUG \
|
|
||||||
if (crow::logger::get_current_log_level() <= crow::LogLevel::Debug) \
|
|
||||||
crow::logger("DEBUG ", crow::LogLevel::Debug)
|
|
||||||
|
|
||||||
@ -1,131 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include <boost/algorithm/string/trim.hpp>
|
|
||||||
#include "crow/http_request.h"
|
|
||||||
#include "crow/http_response.h"
|
|
||||||
|
|
||||||
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 <typename AllContext>
|
|
||||||
// void before_handle(request& req, response& res, context& ctx, AllContext& all_ctx)
|
|
||||||
// you can access another middlewares' context by calling `all_ctx.template get<MW>()'
|
|
||||||
// ctx == all_ctx.template get<CurrentMiddleware>()
|
|
||||||
|
|
||||||
// after_handle
|
|
||||||
// called after handling the request.
|
|
||||||
// void after_handle(request& req, response& res, context& ctx)
|
|
||||||
// template <typename AllContext>
|
|
||||||
// void after_handle(request& req, response& res, context& ctx, AllContext& all_ctx)
|
|
||||||
|
|
||||||
struct CookieParser
|
|
||||||
{
|
|
||||||
struct context
|
|
||||||
{
|
|
||||||
std::unordered_map<std::string, std::string> jar;
|
|
||||||
std::unordered_map<std::string, std::string> 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<CookieParser, AnotherJarMW> 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
|
|
||||||
*/
|
|
||||||
}
|
|
||||||
@ -1,59 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include "crow/utility.h"
|
|
||||||
#include "crow/http_request.h"
|
|
||||||
#include "crow/http_response.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
namespace detail
|
|
||||||
{
|
|
||||||
template <typename ... Middlewares>
|
|
||||||
struct partial_context
|
|
||||||
: public black_magic::pop_back<Middlewares...>::template rebind<partial_context>
|
|
||||||
, public black_magic::last_element_type<Middlewares...>::type::context
|
|
||||||
{
|
|
||||||
using parent_context = typename black_magic::pop_back<Middlewares...>::template rebind<::crow::detail::partial_context>;
|
|
||||||
template <int N>
|
|
||||||
using partial = typename std::conditional<N == sizeof...(Middlewares)-1, partial_context, typename parent_context::template partial<N>>::type;
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
typename T::context& get()
|
|
||||||
{
|
|
||||||
return static_cast<typename T::context&>(*this);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct partial_context<>
|
|
||||||
{
|
|
||||||
template <int>
|
|
||||||
using partial = partial_context;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <int N, typename Context, typename Container, typename CurrentMW, typename ... Middlewares>
|
|
||||||
bool middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx);
|
|
||||||
|
|
||||||
template <typename ... Middlewares>
|
|
||||||
struct context : private partial_context<Middlewares...>
|
|
||||||
//struct context : private Middlewares::context... // simple but less type-safe
|
|
||||||
{
|
|
||||||
template <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 <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 <int N, typename Context, typename Container, typename CurrentMW, typename ... Middlewares2>
|
|
||||||
friend bool middleware_call_helper(Container& middlewares, request& req, response& res, Context& ctx);
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
typename T::context& get()
|
|
||||||
{
|
|
||||||
return static_cast<typename T::context&>(*this);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <int N>
|
|
||||||
using partial = typename partial_context<Middlewares...>::template partial<N>;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,568 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include <string>
|
|
||||||
#include <vector>
|
|
||||||
#include <fstream>
|
|
||||||
#include <iterator>
|
|
||||||
#include <functional>
|
|
||||||
#include "crow/json.h"
|
|
||||||
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;
|
|
||||||
};
|
|
||||||
|
|
||||||
enum class ActionType
|
|
||||||
{
|
|
||||||
Ignore,
|
|
||||||
Tag,
|
|
||||||
UnescapeTag,
|
|
||||||
OpenBlock,
|
|
||||||
CloseBlock,
|
|
||||||
ElseBlock,
|
|
||||||
Partial,
|
|
||||||
};
|
|
||||||
|
|
||||||
struct Action
|
|
||||||
{
|
|
||||||
int start;
|
|
||||||
int end;
|
|
||||||
int pos;
|
|
||||||
ActionType t;
|
|
||||||
Action(ActionType t, int start, int end, int pos = 0)
|
|
||||||
: start(start), end(end), pos(pos), t(t)
|
|
||||||
{}
|
|
||||||
};
|
|
||||||
|
|
||||||
class template_t
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
template_t(std::string body)
|
|
||||||
: body_(std::move(body))
|
|
||||||
{
|
|
||||||
// {{ {{# {{/ {{^ {{! {{> {{=
|
|
||||||
parse();
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
std::string tag_name(const Action& action)
|
|
||||||
{
|
|
||||||
return body_.substr(action.start, action.end - action.start);
|
|
||||||
}
|
|
||||||
auto find_context(const std::string& name, const std::vector<context*>& stack)->std::pair<bool, context&>
|
|
||||||
{
|
|
||||||
if (name == ".")
|
|
||||||
{
|
|
||||||
return {true, *stack.back()};
|
|
||||||
}
|
|
||||||
int dotPosition = name.find(".");
|
|
||||||
if (dotPosition == (int)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<int> dotPositions;
|
|
||||||
dotPositions.push_back(-1);
|
|
||||||
while(dotPosition != (int)name.npos)
|
|
||||||
{
|
|
||||||
dotPositions.push_back(dotPosition);
|
|
||||||
dotPosition = name.find(".", dotPosition+1);
|
|
||||||
}
|
|
||||||
dotPositions.push_back(name.size());
|
|
||||||
std::vector<std::string> names;
|
|
||||||
names.reserve(dotPositions.size()-1);
|
|
||||||
for(int i = 1; i < (int)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
|
|
||||||
{
|
|
||||||
found = false;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (found)
|
|
||||||
return {true, *view};
|
|
||||||
}
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
static json::wvalue empty_str;
|
|
||||||
empty_str = "";
|
|
||||||
return {false, empty_str};
|
|
||||||
}
|
|
||||||
|
|
||||||
void escape(const std::string& in, std::string& out)
|
|
||||||
{
|
|
||||||
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;
|
|
||||||
default: out += *it; break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
void render_internal(int actionBegin, int actionEnd, std::vector<context*>& stack, std::string& out, int indent)
|
|
||||||
{
|
|
||||||
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:
|
|
||||||
{
|
|
||||||
auto optional_ctx = find_context(tag_name(action), stack);
|
|
||||||
auto& ctx = optional_ctx.second;
|
|
||||||
switch(ctx.t())
|
|
||||||
{
|
|
||||||
case json::type::Number:
|
|
||||||
out += json::dump(ctx);
|
|
||||||
break;
|
|
||||||
case json::type::String:
|
|
||||||
if (action.t == ActionType::Tag)
|
|
||||||
escape(ctx.s, out);
|
|
||||||
else
|
|
||||||
out += ctx.s;
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
throw std::runtime_error("not implemented tag type" + boost::lexical_cast<std::string>((int)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<std::string>((int)ctx.t()));
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case ActionType::CloseBlock:
|
|
||||||
stack.pop_back();
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
throw std::runtime_error("not implemented " + boost::lexical_cast<std::string>((int)action.t));
|
|
||||||
}
|
|
||||||
current++;
|
|
||||||
}
|
|
||||||
auto& fragment = fragments_[actionEnd];
|
|
||||||
render_fragment(fragment, indent, out);
|
|
||||||
}
|
|
||||||
void render_fragment(const std::pair<int, int> fragment, int indent, std::string& out)
|
|
||||||
{
|
|
||||||
if (indent)
|
|
||||||
{
|
|
||||||
for(int i = fragment.first; i < fragment.second; i ++)
|
|
||||||
{
|
|
||||||
out += body_[i];
|
|
||||||
if (body_[i] == '\n' && i+1 != (int)body_.size())
|
|
||||||
out.insert(out.size(), indent, ' ');
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else
|
|
||||||
out.insert(out.size(), body_, fragment.first, fragment.second-fragment.first);
|
|
||||||
}
|
|
||||||
public:
|
|
||||||
std::string render()
|
|
||||||
{
|
|
||||||
context empty_ctx;
|
|
||||||
std::vector<context*> stack;
|
|
||||||
stack.emplace_back(&empty_ctx);
|
|
||||||
|
|
||||||
std::string ret;
|
|
||||||
render_internal(0, fragments_.size()-1, stack, ret, 0);
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
std::string render(context& ctx)
|
|
||||||
{
|
|
||||||
std::vector<context*> 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<int> blockPositions;
|
|
||||||
|
|
||||||
size_t current = 0;
|
|
||||||
while(1)
|
|
||||||
{
|
|
||||||
size_t idx = body_.find(tag_open, current);
|
|
||||||
if (idx == body_.npos)
|
|
||||||
{
|
|
||||||
fragments_.emplace_back(current, body_.size());
|
|
||||||
actions_.emplace_back(ActionType::Ignore, 0, 0);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
fragments_.emplace_back(current, 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(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(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 == (int)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 < (int)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 < (int)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<std::pair<int,int>> fragments_;
|
|
||||||
std::vector<Action> 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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
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)
|
|
||||||
return {};
|
|
||||||
return {std::istreambuf_iterator<char>(inf), std::istreambuf_iterator<char>()};
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace detail
|
|
||||||
{
|
|
||||||
inline std::function<std::string (std::string)>& get_loader_ref()
|
|
||||||
{
|
|
||||||
static std::function<std::string (std::string)> loader = default_loader;
|
|
||||||
return loader;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
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_loader(std::function<std::string(std::string)> loader)
|
|
||||||
{
|
|
||||||
detail::get_loader_ref() = std::move(loader);
|
|
||||||
}
|
|
||||||
|
|
||||||
inline std::string load_text(const std::string& filename)
|
|
||||||
{
|
|
||||||
return detail::get_loader_ref()(filename);
|
|
||||||
}
|
|
||||||
|
|
||||||
inline template_t load(const std::string& filename)
|
|
||||||
{
|
|
||||||
return compile(detail::get_loader_ref()(filename));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,167 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <string>
|
|
||||||
#include <unordered_map>
|
|
||||||
#include <boost/algorithm/string.hpp>
|
|
||||||
#include <algorithm>
|
|
||||||
|
|
||||||
#include "crow/http_parser_merged.h"
|
|
||||||
#include "crow/http_request.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
template <typename Handler>
|
|
||||||
struct HTTPParser : public http_parser
|
|
||||||
{
|
|
||||||
static int on_message_begin(http_parser* self_)
|
|
||||||
{
|
|
||||||
HTTPParser* self = static_cast<HTTPParser*>(self_);
|
|
||||||
self->clear();
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
static int on_url(http_parser* self_, const char* at, size_t length)
|
|
||||||
{
|
|
||||||
HTTPParser* self = static_cast<HTTPParser*>(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<HTTPParser*>(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<HTTPParser*>(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<HTTPParser*>(self_);
|
|
||||||
if (!self->header_field.empty())
|
|
||||||
{
|
|
||||||
self->headers.emplace(std::move(self->header_field), std::move(self->header_value));
|
|
||||||
}
|
|
||||||
self->process_header();
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
static int on_body(http_parser* self_, const char* at, size_t length)
|
|
||||||
{
|
|
||||||
HTTPParser* self = static_cast<HTTPParser*>(self_);
|
|
||||||
self->body.insert(self->body.end(), at, at+length);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
static int on_message_complete(http_parser* self_)
|
|
||||||
{
|
|
||||||
HTTPParser* self = static_cast<HTTPParser*>(self_);
|
|
||||||
|
|
||||||
// url params
|
|
||||||
self->url = self->raw_url.substr(0, self->raw_url.find("?"));
|
|
||||||
self->url_params = query_string(self->raw_url);
|
|
||||||
|
|
||||||
self->process_message();
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
HTTPParser(Handler* handler) :
|
|
||||||
handler_(handler)
|
|
||||||
{
|
|
||||||
http_parser_init(this, HTTP_REQUEST);
|
|
||||||
}
|
|
||||||
|
|
||||||
// return false on error
|
|
||||||
bool feed(const char* buffer, int length)
|
|
||||||
{
|
|
||||||
const static http_parser_settings settings_{
|
|
||||||
on_message_begin,
|
|
||||||
on_url,
|
|
||||||
nullptr,
|
|
||||||
on_header_field,
|
|
||||||
on_header_value,
|
|
||||||
on_headers_complete,
|
|
||||||
on_body,
|
|
||||||
on_message_complete,
|
|
||||||
};
|
|
||||||
|
|
||||||
int nparsed = http_parser_execute(this, &settings_, buffer, length);
|
|
||||||
return nparsed == length;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool done()
|
|
||||||
{
|
|
||||||
return feed(nullptr, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
void clear()
|
|
||||||
{
|
|
||||||
url.clear();
|
|
||||||
raw_url.clear();
|
|
||||||
header_building_state = 0;
|
|
||||||
header_field.clear();
|
|
||||||
header_value.clear();
|
|
||||||
headers.clear();
|
|
||||||
url_params.clear();
|
|
||||||
body.clear();
|
|
||||||
}
|
|
||||||
|
|
||||||
void process_header()
|
|
||||||
{
|
|
||||||
handler_->handle_header();
|
|
||||||
}
|
|
||||||
|
|
||||||
void process_message()
|
|
||||||
{
|
|
||||||
handler_->handle();
|
|
||||||
}
|
|
||||||
|
|
||||||
request to_request() const
|
|
||||||
{
|
|
||||||
return request{(HTTPMethod)method, std::move(raw_url), std::move(url), std::move(url_params), std::move(headers), std::move(body)};
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_upgrade() const
|
|
||||||
{
|
|
||||||
return upgrade;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool check_version(int major, int minor) const
|
|
||||||
{
|
|
||||||
return http_major == major && http_minor == minor;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::string raw_url;
|
|
||||||
std::string url;
|
|
||||||
|
|
||||||
int header_building_state = 0;
|
|
||||||
std::string header_field;
|
|
||||||
std::string header_value;
|
|
||||||
ci_map headers;
|
|
||||||
query_string url_params;
|
|
||||||
std::string body;
|
|
||||||
|
|
||||||
Handler* handler_;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
@ -1,407 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include <string>
|
|
||||||
#include <vector>
|
|
||||||
#include <unordered_map>
|
|
||||||
#include <iostream>
|
|
||||||
#include <boost/optional.hpp>
|
|
||||||
|
|
||||||
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 <ctype.h>, 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 = (unsigned char) *s++;
|
|
||||||
u2 = (unsigned char) *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 = (unsigned char) *s++;
|
|
||||||
lnyb = (unsigned char) *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 = (unsigned char) *qs++;
|
|
||||||
lnyb = (unsigned char) *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<qs_kv_size; i++) qs_kv[i] = NULL;
|
|
||||||
|
|
||||||
// find the beginning of the k/v substrings or the fragment
|
|
||||||
substr_ptr = qs + strcspn(qs, "?#");
|
|
||||||
if (substr_ptr[0] != '\0')
|
|
||||||
substr_ptr++;
|
|
||||||
else
|
|
||||||
return 0; // no query or fragment
|
|
||||||
|
|
||||||
i=0;
|
|
||||||
while(i<qs_kv_size)
|
|
||||||
{
|
|
||||||
qs_kv[i] = substr_ptr;
|
|
||||||
j = strcspn(substr_ptr, "&");
|
|
||||||
if ( substr_ptr[j] == '\0' ) { break; }
|
|
||||||
substr_ptr += j + 1;
|
|
||||||
i++;
|
|
||||||
}
|
|
||||||
i++; // x &'s -> means x iterations of this loop -> means *x+1* k/v pairs
|
|
||||||
|
|
||||||
// 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<i; j++)
|
|
||||||
{
|
|
||||||
substr_ptr = qs_kv[j] + strcspn(qs_kv[j], "=&#");
|
|
||||||
if ( substr_ptr[0] == '&' || substr_ptr[0] == '\0') // blank value: skip decoding
|
|
||||||
substr_ptr[0] = '\0';
|
|
||||||
else
|
|
||||||
qs_decode(++substr_ptr);
|
|
||||||
}
|
|
||||||
|
|
||||||
#ifdef _qsSORTING
|
|
||||||
// TODO: qsort qs_kv, using qs_strncmp() for the comparison
|
|
||||||
#endif
|
|
||||||
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
inline int qs_decode(char * qs)
|
|
||||||
{
|
|
||||||
int i=0, j=0;
|
|
||||||
|
|
||||||
while( CROW_QS_ISQSCHR(qs[j]) )
|
|
||||||
{
|
|
||||||
if ( qs[j] == '+' ) { qs[i] = ' '; }
|
|
||||||
else if ( qs[j] == '%' ) // easier/safer than scanf
|
|
||||||
{
|
|
||||||
if ( ! CROW_QS_ISHEX(qs[j+1]) || ! CROW_QS_ISHEX(qs[j+2]) )
|
|
||||||
{
|
|
||||||
qs[i] = '\0';
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
qs[i] = (CROW_QS_HEX2DEC(qs[j+1]) * 16) + CROW_QS_HEX2DEC(qs[j+2]);
|
|
||||||
j+=2;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
qs[i] = qs[j];
|
|
||||||
}
|
|
||||||
i++; j++;
|
|
||||||
}
|
|
||||||
qs[i] = '\0';
|
|
||||||
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
inline char * qs_k2v(const char * key, char * const * qs_kv, int qs_kv_size, int nth = 0)
|
|
||||||
{
|
|
||||||
int i;
|
|
||||||
size_t key_len, skip;
|
|
||||||
|
|
||||||
key_len = strlen(key);
|
|
||||||
|
|
||||||
#ifdef _qsSORTING
|
|
||||||
// TODO: binary search for key in the sorted qs_kv
|
|
||||||
#else // _qsSORTING
|
|
||||||
for(i=0; i<qs_kv_size; i++)
|
|
||||||
{
|
|
||||||
// we rely on the unambiguous '=' to find the value in our k/v pair
|
|
||||||
if ( qs_strncmp(key, qs_kv[i], key_len) == 0 )
|
|
||||||
{
|
|
||||||
skip = strcspn(qs_kv[i], "=");
|
|
||||||
if ( qs_kv[i][skip] == '=' )
|
|
||||||
skip++;
|
|
||||||
// return (zero-char value) ? ptr to trailing '\0' : ptr to value
|
|
||||||
if(nth == 0)
|
|
||||||
return qs_kv[i] + skip;
|
|
||||||
else
|
|
||||||
--nth;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
#endif // _qsSORTING
|
|
||||||
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline boost::optional<std::pair<std::string, std::string>> 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<qs_kv_size; i++)
|
|
||||||
{
|
|
||||||
if ( strncmp(dict_name, qs_kv[i], name_len) == 0 )
|
|
||||||
{
|
|
||||||
skip_to_eq = strcspn(qs_kv[i], "=");
|
|
||||||
if ( qs_kv[i][skip_to_eq] == '=' )
|
|
||||||
skip_to_eq++;
|
|
||||||
skip_to_brace_open = strcspn(qs_kv[i], "[");
|
|
||||||
if ( qs_kv[i][skip_to_brace_open] == '[' )
|
|
||||||
skip_to_brace_open++;
|
|
||||||
skip_to_brace_close = strcspn(qs_kv[i], "]");
|
|
||||||
|
|
||||||
if ( skip_to_brace_open <= skip_to_brace_close &&
|
|
||||||
skip_to_brace_open > 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
|
|
||||||
{
|
|
||||||
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;
|
|
||||||
|
|
||||||
}
|
|
||||||
|
|
||||||
char* get (const std::string& name) const
|
|
||||||
{
|
|
||||||
char* ret = qs_k2v(name.c_str(), key_value_pairs_.data(), key_value_pairs_.size());
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::vector<char*> get_list (const std::string& name) const
|
|
||||||
{
|
|
||||||
std::vector<char*> ret;
|
|
||||||
std::string plus = name + "[]";
|
|
||||||
char* element = nullptr;
|
|
||||||
|
|
||||||
int count = 0;
|
|
||||||
while(1)
|
|
||||||
{
|
|
||||||
element = qs_k2v(plus.c_str(), key_value_pairs_.data(), key_value_pairs_.size(), count++);
|
|
||||||
if (!element)
|
|
||||||
break;
|
|
||||||
ret.push_back(element);
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
std::unordered_map<std::string, std::string> get_dict (const std::string& name) const
|
|
||||||
{
|
|
||||||
std::unordered_map<std::string, std::string> 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;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
std::string url_;
|
|
||||||
std::vector<char*> key_value_pairs_;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // end namespace
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,38 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
// settings for crow
|
|
||||||
// TODO - 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
|
|
||||||
|
|
||||||
/* #define - specifies log level */
|
|
||||||
/*
|
|
||||||
Debug = 0
|
|
||||||
Info = 1
|
|
||||||
Warning = 2
|
|
||||||
Error = 3
|
|
||||||
Critical = 4
|
|
||||||
|
|
||||||
default to INFO
|
|
||||||
*/
|
|
||||||
#define CROW_LOG_LEVEL 1
|
|
||||||
|
|
||||||
|
|
||||||
// compiler flags
|
|
||||||
#if __cplusplus >= 201402L
|
|
||||||
#define CROW_CAN_USE_CPP14
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(_MSC_VER)
|
|
||||||
#if _MSC_VER < 1900
|
|
||||||
#define CROW_MSVC_WORKAROUND
|
|
||||||
#define constexpr const
|
|
||||||
#define noexcept throw()
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
@ -1,117 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include <boost/asio.hpp>
|
|
||||||
#ifdef CROW_ENABLE_SSL
|
|
||||||
#include <boost/asio/ssl.hpp>
|
|
||||||
#endif
|
|
||||||
#include "crow/settings.h"
|
|
||||||
#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;
|
|
||||||
|
|
||||||
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_);
|
|
||||||
}
|
|
||||||
|
|
||||||
tcp::socket& raw_socket()
|
|
||||||
{
|
|
||||||
return socket_;
|
|
||||||
}
|
|
||||||
|
|
||||||
tcp::socket& socket()
|
|
||||||
{
|
|
||||||
return socket_;
|
|
||||||
}
|
|
||||||
|
|
||||||
tcp::endpoint remote_endpoint()
|
|
||||||
{
|
|
||||||
return socket_.remote_endpoint();
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_open()
|
|
||||||
{
|
|
||||||
return socket_.is_open();
|
|
||||||
}
|
|
||||||
|
|
||||||
void close()
|
|
||||||
{
|
|
||||||
socket_.close();
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename F>
|
|
||||||
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<tcp::socket>;
|
|
||||||
SSLAdaptor(boost::asio::io_service& io_service, context* ctx)
|
|
||||||
: ssl_socket_(new ssl_socket_t(io_service, *ctx))
|
|
||||||
{
|
|
||||||
}
|
|
||||||
|
|
||||||
boost::asio::ssl::stream<tcp::socket>& 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 raw_socket().is_open();
|
|
||||||
}
|
|
||||||
|
|
||||||
void close()
|
|
||||||
{
|
|
||||||
raw_socket().close();
|
|
||||||
}
|
|
||||||
|
|
||||||
boost::asio::io_service& get_io_service()
|
|
||||||
{
|
|
||||||
return GET_IO_SERVICE(raw_socket());
|
|
||||||
}
|
|
||||||
|
|
||||||
template <typename F>
|
|
||||||
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<boost::asio::ssl::stream<tcp::socket>> ssl_socket_;
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
@ -1,548 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
|
|
||||||
#include <cstdint>
|
|
||||||
#include <stdexcept>
|
|
||||||
#include <tuple>
|
|
||||||
#include <type_traits>
|
|
||||||
#include <cstring>
|
|
||||||
#include <functional>
|
|
||||||
#include <string>
|
|
||||||
|
|
||||||
#include "crow/settings.h"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
namespace black_magic
|
|
||||||
{
|
|
||||||
#ifndef CROW_MSVC_WORKAROUND
|
|
||||||
struct OutOfRange
|
|
||||||
{
|
|
||||||
OutOfRange(unsigned /*pos*/, unsigned /*length*/) {}
|
|
||||||
};
|
|
||||||
constexpr unsigned requires_in_range( unsigned i, unsigned len )
|
|
||||||
{
|
|
||||||
return i >= len ? throw OutOfRange(i, len) : i;
|
|
||||||
}
|
|
||||||
|
|
||||||
class const_str
|
|
||||||
{
|
|
||||||
const char * const begin_;
|
|
||||||
unsigned size_;
|
|
||||||
|
|
||||||
public:
|
|
||||||
template< unsigned N >
|
|
||||||
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);
|
|
||||||
}
|
|
||||||
|
|
||||||
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, "<int>", 0, 5);
|
|
||||||
}
|
|
||||||
|
|
||||||
constexpr bool is_uint(const_str s, unsigned i)
|
|
||||||
{
|
|
||||||
return is_equ_n(s, i, "<uint>", 0, 6);
|
|
||||||
}
|
|
||||||
|
|
||||||
constexpr bool is_float(const_str s, unsigned i)
|
|
||||||
{
|
|
||||||
return is_equ_n(s, i, "<float>", 0, 7) ||
|
|
||||||
is_equ_n(s, i, "<double>", 0, 8);
|
|
||||||
}
|
|
||||||
|
|
||||||
constexpr bool is_str(const_str s, unsigned i)
|
|
||||||
{
|
|
||||||
return is_equ_n(s, i, "<str>", 0, 5) ||
|
|
||||||
is_equ_n(s, i, "<string>", 0, 8);
|
|
||||||
}
|
|
||||||
|
|
||||||
constexpr bool is_path(const_str s, unsigned i)
|
|
||||||
{
|
|
||||||
return is_equ_n(s, i, "<path>", 0, 6);
|
|
||||||
}
|
|
||||||
#endif
|
|
||||||
template <typename T>
|
|
||||||
struct parameter_tag
|
|
||||||
{
|
|
||||||
static const int value = 0;
|
|
||||||
};
|
|
||||||
#define CROW_INTERNAL_PARAMETER_TAG(t, i) \
|
|
||||||
template <> \
|
|
||||||
struct parameter_tag<t> \
|
|
||||||
{ \
|
|
||||||
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 <typename ... Args>
|
|
||||||
struct compute_parameter_tag_from_args_list;
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct compute_parameter_tag_from_args_list<>
|
|
||||||
{
|
|
||||||
static const int value = 0;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename Arg, typename ... Args>
|
|
||||||
struct compute_parameter_tag_from_args_list<Arg, Args...>
|
|
||||||
{
|
|
||||||
static const int sub_value =
|
|
||||||
compute_parameter_tag_from_args_list<Args...>::value;
|
|
||||||
static const int value =
|
|
||||||
parameter_tag<typename std::decay<Arg>::type>::value
|
|
||||||
? sub_value* 6 + parameter_tag<typename std::decay<Arg>::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, "<int>", 5) == 0
|
|
||||||
? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 1 :
|
|
||||||
std::strncmp(s+p, "<uint>", 6) == 0
|
|
||||||
? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 2 :
|
|
||||||
(std::strncmp(s+p, "<float>", 7) == 0 ||
|
|
||||||
std::strncmp(s+p, "<double>", 8) == 0)
|
|
||||||
? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 3 :
|
|
||||||
(std::strncmp(s+p, "<str>", 5) == 0 ||
|
|
||||||
std::strncmp(s+p, "<string>", 8) == 0)
|
|
||||||
? get_parameter_tag_runtime(s, find_closing_tag_runtime(s, p)) * 6 + 4 :
|
|
||||||
std::strncmp(s+p, "<path>", 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 <typename ... T>
|
|
||||||
struct S
|
|
||||||
{
|
|
||||||
template <typename U>
|
|
||||||
using push = S<U, T...>;
|
|
||||||
template <typename U>
|
|
||||||
using push_back = S<T..., U>;
|
|
||||||
template <template<typename ... Args> class U>
|
|
||||||
using rebind = U<T...>;
|
|
||||||
};
|
|
||||||
template <typename F, typename Set>
|
|
||||||
struct CallHelper;
|
|
||||||
template <typename F, typename ...Args>
|
|
||||||
struct CallHelper<F, S<Args...>>
|
|
||||||
{
|
|
||||||
template <typename F1, typename ...Args1, typename =
|
|
||||||
decltype(std::declval<F1>()(std::declval<Args1>()...))
|
|
||||||
>
|
|
||||||
static char __test(int);
|
|
||||||
|
|
||||||
template <typename ...>
|
|
||||||
static int __test(...);
|
|
||||||
|
|
||||||
static constexpr bool value = sizeof(__test<F, Args...>(0)) == sizeof(char);
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
template <int N>
|
|
||||||
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 <uint64_t Tag>
|
|
||||||
struct arguments
|
|
||||||
{
|
|
||||||
using subarguments = typename arguments<Tag/6>::type;
|
|
||||||
using type =
|
|
||||||
typename subarguments::template push<typename single_tag_to_type<Tag%6>::type>;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct arguments<0>
|
|
||||||
{
|
|
||||||
using type = S<>;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename ... T>
|
|
||||||
struct last_element_type
|
|
||||||
{
|
|
||||||
using type = typename std::tuple_element<sizeof...(T)-1, std::tuple<T...>>::type;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct last_element_type<>
|
|
||||||
{
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
// from http://stackoverflow.com/questions/13072359/c11-compile-time-array-with-logarithmic-evaluation-depth
|
|
||||||
template<class T> using Invoke = typename T::type;
|
|
||||||
|
|
||||||
template<unsigned...> struct seq{ using type = seq; };
|
|
||||||
|
|
||||||
template<class S1, class S2> struct concat;
|
|
||||||
|
|
||||||
template<unsigned... I1, unsigned... I2>
|
|
||||||
struct concat<seq<I1...>, seq<I2...>>
|
|
||||||
: seq<I1..., (sizeof...(I1)+I2)...>{};
|
|
||||||
|
|
||||||
template<class S1, class S2>
|
|
||||||
using Concat = Invoke<concat<S1, S2>>;
|
|
||||||
|
|
||||||
template<unsigned N> struct gen_seq;
|
|
||||||
template<unsigned N> using GenSeq = Invoke<gen_seq<N>>;
|
|
||||||
|
|
||||||
template<unsigned N>
|
|
||||||
struct gen_seq : Concat<GenSeq<N/2>, GenSeq<N - N/2>>{};
|
|
||||||
|
|
||||||
template<> struct gen_seq<0> : seq<>{};
|
|
||||||
template<> struct gen_seq<1> : seq<0>{};
|
|
||||||
|
|
||||||
template <typename Seq, typename Tuple>
|
|
||||||
struct pop_back_helper;
|
|
||||||
|
|
||||||
template <unsigned ... N, typename Tuple>
|
|
||||||
struct pop_back_helper<seq<N...>, Tuple>
|
|
||||||
{
|
|
||||||
template <template <typename ... Args> class U>
|
|
||||||
using rebind = U<typename std::tuple_element<N, Tuple>::type...>;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename ... T>
|
|
||||||
struct pop_back //: public pop_back_helper<typename gen_seq<sizeof...(T)-1>::type, std::tuple<T...>>
|
|
||||||
{
|
|
||||||
template <template <typename ... Args> class U>
|
|
||||||
using rebind = typename pop_back_helper<typename gen_seq<sizeof...(T)-1>::type, std::tuple<T...>>::template rebind<U>;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <>
|
|
||||||
struct pop_back<>
|
|
||||||
{
|
|
||||||
template <template <typename ... Args> class U>
|
|
||||||
using rebind = U<>;
|
|
||||||
};
|
|
||||||
|
|
||||||
// from http://stackoverflow.com/questions/2118541/check-if-c0x-parameter-pack-contains-a-type
|
|
||||||
template < typename Tp, typename... List >
|
|
||||||
struct contains : std::true_type {};
|
|
||||||
|
|
||||||
template < typename Tp, typename Head, typename... Rest >
|
|
||||||
struct contains<Tp, Head, Rest...>
|
|
||||||
: std::conditional< std::is_same<Tp, Head>::value,
|
|
||||||
std::true_type,
|
|
||||||
contains<Tp, Rest...>
|
|
||||||
>::type {};
|
|
||||||
|
|
||||||
template < typename Tp >
|
|
||||||
struct contains<Tp> : std::false_type {};
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct empty_context
|
|
||||||
{
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct promote
|
|
||||||
{
|
|
||||||
using type = T;
|
|
||||||
};
|
|
||||||
|
|
||||||
#define CROW_INTERNAL_PROMOTE_TYPE(t1, t2) \
|
|
||||||
template<> \
|
|
||||||
struct promote<t1> \
|
|
||||||
{ \
|
|
||||||
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 <typename T>
|
|
||||||
using promote_t = typename promote<T>::type;
|
|
||||||
|
|
||||||
} // namespace black_magic
|
|
||||||
|
|
||||||
namespace detail
|
|
||||||
{
|
|
||||||
|
|
||||||
template <class T, std::size_t N, class... Args>
|
|
||||||
struct get_index_of_element_from_tuple_by_type_impl
|
|
||||||
{
|
|
||||||
static constexpr auto value = N;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, std::size_t N, class... Args>
|
|
||||||
struct get_index_of_element_from_tuple_by_type_impl<T, N, T, Args...>
|
|
||||||
{
|
|
||||||
static constexpr auto value = N;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class T, std::size_t N, class U, class... Args>
|
|
||||||
struct get_index_of_element_from_tuple_by_type_impl<T, N, U, Args...>
|
|
||||||
{
|
|
||||||
static constexpr auto value = get_index_of_element_from_tuple_by_type_impl<T, N + 1, Args...>::value;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace detail
|
|
||||||
|
|
||||||
namespace utility
|
|
||||||
{
|
|
||||||
template <class T, class... Args>
|
|
||||||
T& get_element_by_type(std::tuple<Args...>& t)
|
|
||||||
{
|
|
||||||
return std::get<detail::get_index_of_element_from_tuple_by_type_impl<T, 0, Args...>::value>(t);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
struct function_traits;
|
|
||||||
|
|
||||||
#ifndef CROW_MSVC_WORKAROUND
|
|
||||||
template<typename T>
|
|
||||||
struct function_traits : public function_traits<decltype(&T::operator())>
|
|
||||||
{
|
|
||||||
using parent_t = function_traits<decltype(&T::operator())>;
|
|
||||||
static const size_t arity = parent_t::arity;
|
|
||||||
using result_type = typename parent_t::result_type;
|
|
||||||
template <size_t i>
|
|
||||||
using arg = typename parent_t::template arg<i>;
|
|
||||||
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
template<typename ClassType, typename R, typename ...Args>
|
|
||||||
struct function_traits<R(ClassType::*)(Args...) const>
|
|
||||||
{
|
|
||||||
static const size_t arity = sizeof...(Args);
|
|
||||||
|
|
||||||
typedef R result_type;
|
|
||||||
|
|
||||||
template <size_t i>
|
|
||||||
using arg = typename std::tuple_element<i, std::tuple<Args...>>::type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename ClassType, typename R, typename ...Args>
|
|
||||||
struct function_traits<R(ClassType::*)(Args...)>
|
|
||||||
{
|
|
||||||
static const size_t arity = sizeof...(Args);
|
|
||||||
|
|
||||||
typedef R result_type;
|
|
||||||
|
|
||||||
template <size_t i>
|
|
||||||
using arg = typename std::tuple_element<i, std::tuple<Args...>>::type;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename R, typename ...Args>
|
|
||||||
struct function_traits<std::function<R(Args...)>>
|
|
||||||
{
|
|
||||||
static const size_t arity = sizeof...(Args);
|
|
||||||
|
|
||||||
typedef R result_type;
|
|
||||||
|
|
||||||
template <size_t i>
|
|
||||||
using arg = typename std::tuple_element<i, std::tuple<Args...>>::type;
|
|
||||||
};
|
|
||||||
|
|
||||||
inline static std::string base64encode(const 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[(((unsigned char)*data)&0xFC)>>2];
|
|
||||||
unsigned char h = (((unsigned char)*data++) & 0x03) << 4;
|
|
||||||
*it++ = key[h|((((unsigned char)*data)&0xF0)>>4)];
|
|
||||||
h = (((unsigned char)*data++) & 0x0F) << 2;
|
|
||||||
*it++ = key[h|((((unsigned char)*data)&0xC0)>>6)];
|
|
||||||
*it++ = key[((unsigned char)*data++)&0x3F];
|
|
||||||
|
|
||||||
size -= 3;
|
|
||||||
}
|
|
||||||
if (size == 1)
|
|
||||||
{
|
|
||||||
*it++ = key[(((unsigned char)*data)&0xFC)>>2];
|
|
||||||
unsigned char h = (((unsigned char)*data++) & 0x03) << 4;
|
|
||||||
*it++ = key[h];
|
|
||||||
*it++ = '=';
|
|
||||||
*it++ = '=';
|
|
||||||
}
|
|
||||||
else if (size == 2)
|
|
||||||
{
|
|
||||||
*it++ = key[(((unsigned char)*data)&0xFC)>>2];
|
|
||||||
unsigned char h = (((unsigned char)*data++) & 0x03) << 4;
|
|
||||||
*it++ = key[h|((((unsigned char)*data)&0xF0)>>4)];
|
|
||||||
h = (((unsigned char)*data++) & 0x0F) << 2;
|
|
||||||
*it++ = key[h];
|
|
||||||
*it++ = '=';
|
|
||||||
}
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline static std::string base64encode_urlsafe(const char* data, size_t size)
|
|
||||||
{
|
|
||||||
return base64encode(data, size, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
} // namespace utility
|
|
||||||
}
|
|
||||||
@ -1,523 +0,0 @@
|
|||||||
#pragma once
|
|
||||||
#include <boost/algorithm/string/predicate.hpp>
|
|
||||||
#include <boost/array.hpp>
|
|
||||||
#include "crow/socket_adaptors.h"
|
|
||||||
#include "crow/http_request.h"
|
|
||||||
#include "crow/TinySHA1.hpp"
|
|
||||||
|
|
||||||
namespace crow
|
|
||||||
{
|
|
||||||
namespace websocket
|
|
||||||
{
|
|
||||||
enum class WebSocketReadState
|
|
||||||
{
|
|
||||||
MiniHeader,
|
|
||||||
Len16,
|
|
||||||
Len64,
|
|
||||||
Mask,
|
|
||||||
Payload,
|
|
||||||
};
|
|
||||||
|
|
||||||
struct connection
|
|
||||||
{
|
|
||||||
virtual void send_binary(const std::string& msg) = 0;
|
|
||||||
virtual void send_text(const std::string& msg) = 0;
|
|
||||||
virtual void close(const std::string& msg = "quit") = 0;
|
|
||||||
virtual ~connection(){}
|
|
||||||
|
|
||||||
void userdata(void* u) { userdata_ = u; }
|
|
||||||
void* userdata() { return userdata_; }
|
|
||||||
|
|
||||||
private:
|
|
||||||
void* userdata_;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename Adaptor>
|
|
||||||
class Connection : public connection
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
Connection(const crow::request& req, Adaptor&& adaptor,
|
|
||||||
std::function<void(crow::websocket::connection&)> open_handler,
|
|
||||||
std::function<void(crow::websocket::connection&, const std::string&, bool)> message_handler,
|
|
||||||
std::function<void(crow::websocket::connection&, const std::string&)> close_handler,
|
|
||||||
std::function<void(crow::websocket::connection&)> error_handler,
|
|
||||||
std::function<bool(const crow::request&)> 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((char*)digest, 20));
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename CompletionHandler>
|
|
||||||
void dispatch(CompletionHandler handler)
|
|
||||||
{
|
|
||||||
adaptor_.get_io_service().dispatch(handler);
|
|
||||||
}
|
|
||||||
|
|
||||||
template<typename CompletionHandler>
|
|
||||||
void post(CompletionHandler handler)
|
|
||||||
{
|
|
||||||
adaptor_.get_io_service().post(handler);
|
|
||||||
}
|
|
||||||
|
|
||||||
void send_pong(const std::string& msg)
|
|
||||||
{
|
|
||||||
dispatch([this, msg]{
|
|
||||||
char buf[3] = "\x8A\x00";
|
|
||||||
buf[1] += msg.size();
|
|
||||||
write_buffers_.emplace_back(buf, buf+2);
|
|
||||||
write_buffers_.emplace_back(msg);
|
|
||||||
do_write();
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
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();
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
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();
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
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();
|
|
||||||
});
|
|
||||||
}
|
|
||||||
|
|
||||||
protected:
|
|
||||||
|
|
||||||
std::string build_header(int opcode, size_t size)
|
|
||||||
{
|
|
||||||
char buf[2+8] = "\x80\x00";
|
|
||||||
buf[0] += opcode;
|
|
||||||
if (size < 126)
|
|
||||||
{
|
|
||||||
buf[1] += size;
|
|
||||||
return {buf, buf+2};
|
|
||||||
}
|
|
||||||
else if (size < 0x10000)
|
|
||||||
{
|
|
||||||
buf[1] += 126;
|
|
||||||
*(uint16_t*)(buf+2) = htons((uint16_t)size);
|
|
||||||
return {buf, buf+4};
|
|
||||||
}
|
|
||||||
else
|
|
||||||
{
|
|
||||||
buf[1] += 127;
|
|
||||||
*(uint64_t*)(buf+2) = ((1==htonl(1)) ? (uint64_t)size : ((uint64_t)htonl((size) & 0xFFFFFFFF) << 32) | htonl((size) >> 32));
|
|
||||||
return {buf, buf+10};
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
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: ";
|
|
||||||
static std::string crlf = "\r\n";
|
|
||||||
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();
|
|
||||||
}
|
|
||||||
|
|
||||||
void do_read()
|
|
||||||
{
|
|
||||||
is_reading = true;
|
|
||||||
switch(state_)
|
|
||||||
{
|
|
||||||
case WebSocketReadState::MiniHeader:
|
|
||||||
{
|
|
||||||
//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_ = htons(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 && ((mini_header_ & 0x80) == 0x80))
|
|
||||||
{
|
|
||||||
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;
|
|
||||||
uint16_t remaining_length16_ = 0;
|
|
||||||
boost::asio::async_read(adaptor_.socket(), boost::asio::buffer(&remaining_length16_, 2),
|
|
||||||
[this,&remaining_length16_](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_) : ((uint64_t)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:
|
|
||||||
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();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
break;
|
|
||||||
case WebSocketReadState::Payload:
|
|
||||||
{
|
|
||||||
size_t to_read = buffer_.size();
|
|
||||||
if (remaining_length_ < to_read)
|
|
||||||
to_read = remaining_length_;
|
|
||||||
adaptor_.socket().async_read_some( boost::asio::buffer(buffer_, 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
|
|
||||||
{
|
|
||||||
close_connection_ = true;
|
|
||||||
if (error_handler_)
|
|
||||||
error_handler_(*this);
|
|
||||||
adaptor_.close();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bool is_FIN()
|
|
||||||
{
|
|
||||||
return mini_header_ & 0x8000;
|
|
||||||
}
|
|
||||||
|
|
||||||
int opcode()
|
|
||||||
{
|
|
||||||
return (mini_header_ & 0x0f00) >> 8;
|
|
||||||
}
|
|
||||||
|
|
||||||
void handle_fragment()
|
|
||||||
{
|
|
||||||
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();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
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();
|
|
||||||
}
|
|
||||||
|
|
||||||
void do_write()
|
|
||||||
{
|
|
||||||
if (sending_buffers_.empty())
|
|
||||||
{
|
|
||||||
sending_buffers_.swap(write_buffers_);
|
|
||||||
std::vector<boost::asio::const_buffer> 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();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
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<std::string> sending_buffers_;
|
|
||||||
std::vector<std::string> write_buffers_;
|
|
||||||
|
|
||||||
boost::array<char, 4096> buffer_;
|
|
||||||
bool is_binary_;
|
|
||||||
std::string message_;
|
|
||||||
std::string fragment_;
|
|
||||||
WebSocketReadState state_{WebSocketReadState::MiniHeader};
|
|
||||||
uint64_t remaining_length_{0};
|
|
||||||
bool close_connection_{false};
|
|
||||||
bool is_reading{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<void(crow::websocket::connection&)> open_handler_;
|
|
||||||
std::function<void(crow::websocket::connection&, const std::string&, bool)> message_handler_;
|
|
||||||
std::function<void(crow::websocket::connection&, const std::string&)> close_handler_;
|
|
||||||
std::function<void(crow::websocket::connection&)> error_handler_;
|
|
||||||
std::function<bool(const crow::request&)> accept_handler_;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue