mirror of
https://github.com/Xahau/xahaud.git
synced 2025-12-06 17:27:52 +00:00
8b62c23ab6
New classes are introduced to represent HTTP messages and their associated bodies. The parser interface is reworked to use CRTP, error codes, and trait checks. New classes: * basic_headers Models field/value pairs in a HTTP message. * message Models a HTTP message, body behavior defined by template argument. Parsed message carries metadata generated during parsing. * parser Produces parsed messages. * empty_body, string_body, basic_streambuf_body Classes used to represent content bodies in various ways. New functions: * read, async_read, write, async_write Read and write HTTP messages on a socket. New concepts: * Body: Represents the HTTP Content-Body. * Field: A HTTP header field. * FieldSequence: A forward sequence of fields. * Reader: Parses a Body from a stream of bytes. * Writer: Serializes a Body to buffers. basic_parser changes: * add write methods which throw exceptions instead * error_code passed via parameter instead of return value * fold private member calls into existing callbacks * basic_parser uses CRTP instead of virtual members * add documentation on Derived requirements for CRTP impl/http-parser changes: * joyent renamed to nodejs to reflect upstream changes
420 lines
11 KiB
C++
420 lines
11 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of Beast: https://github.com/vinniefalco/Beast
|
|
Copyright 2013, Vinnie Falco <vinnie.falco@gmail.com>
|
|
|
|
Permission to use, copy, modify, and/or 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 BEAST_HTTP_STREAM_IPP_INCLUDED
|
|
#define BEAST_HTTP_STREAM_IPP_INCLUDED
|
|
|
|
#include <beast/asio/async_completion.h>
|
|
#include <beast/asio/bind_handler.h>
|
|
#include <beast/asio/handler_alloc.h>
|
|
#include <beast/http/read.h>
|
|
#include <beast/http/type_check.h>
|
|
#include <beast/http/write.h>
|
|
#include <cassert>
|
|
|
|
namespace beast {
|
|
namespace http {
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers,
|
|
class Handler>
|
|
class stream<NextLayer, Allocator>::read_op
|
|
{
|
|
using alloc_type =
|
|
handler_alloc<char, Handler>;
|
|
|
|
struct data
|
|
{
|
|
stream<NextLayer>& s;
|
|
message<isRequest, Body, Headers>& m;
|
|
Handler h;
|
|
bool cont;
|
|
int state = 0;
|
|
|
|
template<class DeducedHandler>
|
|
data(DeducedHandler&& h_, stream<NextLayer>& s_,
|
|
message<isRequest, Body, Headers>& m_)
|
|
: s(s_)
|
|
, m(m_)
|
|
, h(std::forward<DeducedHandler>(h_))
|
|
, cont(boost_asio_handler_cont_helpers::
|
|
is_continuation(h))
|
|
{
|
|
}
|
|
};
|
|
|
|
std::shared_ptr<data> d_;
|
|
|
|
public:
|
|
read_op(read_op&&) = default;
|
|
read_op(read_op const&) = default;
|
|
|
|
template<class DeducedHandler, class... Args>
|
|
read_op(DeducedHandler&& h,
|
|
stream<NextLayer>& s, Args&&... args)
|
|
: d_(std::allocate_shared<data>(alloc_type{h},
|
|
std::forward<DeducedHandler>(h), s,
|
|
std::forward<Args>(args)...))
|
|
{
|
|
(*this)(error_code{}, false);
|
|
}
|
|
|
|
void operator()(error_code const& ec, bool again = true);
|
|
|
|
friend
|
|
auto asio_handler_allocate(
|
|
std::size_t size, read_op* op)
|
|
{
|
|
return boost_asio_handler_alloc_helpers::
|
|
allocate(size, op->d_->h);
|
|
}
|
|
|
|
friend
|
|
auto asio_handler_deallocate(
|
|
void* p, std::size_t size, read_op* op)
|
|
{
|
|
return boost_asio_handler_alloc_helpers::
|
|
deallocate(p, size, op->d_->h);
|
|
}
|
|
|
|
friend
|
|
auto asio_handler_is_continuation(read_op* op)
|
|
{
|
|
return op->d_->cont;
|
|
}
|
|
|
|
template <class Function>
|
|
friend
|
|
auto asio_handler_invoke(Function&& f, read_op* op)
|
|
{
|
|
return boost_asio_handler_invoke_helpers::
|
|
invoke(f, op->d_->h);
|
|
}
|
|
};
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers, class Handler>
|
|
void
|
|
stream<NextLayer, Allocator>::
|
|
read_op<isRequest, Body, Headers, Handler>::
|
|
operator()(error_code const& ec, bool again)
|
|
{
|
|
auto& d = *d_;
|
|
d.cont = d.cont || again;
|
|
while(! ec && d.state != 99)
|
|
{
|
|
switch(d.state)
|
|
{
|
|
case 0:
|
|
d.state = 99;
|
|
beast::http::async_read(d.s.next_layer_,
|
|
d.s.rd_buf_, d.m, std::move(*this));
|
|
return;
|
|
}
|
|
}
|
|
d.h(ec);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers,
|
|
class Handler>
|
|
class stream<NextLayer, Allocator>::write_op : public op
|
|
{
|
|
using alloc_type =
|
|
handler_alloc<char, Handler>;
|
|
|
|
struct data
|
|
{
|
|
stream<NextLayer>& s;
|
|
message<isRequest, Body, Headers> m;
|
|
Handler h;
|
|
bool cont;
|
|
int state = 0;
|
|
|
|
template<class DeducedHandler>
|
|
data(DeducedHandler&& h_, stream<NextLayer>& s_,
|
|
message<isRequest, Body, Headers> const& m_,
|
|
bool cont_)
|
|
: s(s_)
|
|
, m(m_)
|
|
, h(std::forward<DeducedHandler>(h_))
|
|
, cont(cont_)
|
|
{
|
|
}
|
|
|
|
template<class DeducedHandler>
|
|
data(DeducedHandler&& h_, stream<NextLayer>& s_,
|
|
message<isRequest, Body, Headers>&& m_,
|
|
bool cont_)
|
|
: s(s_)
|
|
, m(std::move(m_))
|
|
, h(std::forward<DeducedHandler>(h_))
|
|
, cont(cont_)
|
|
{
|
|
}
|
|
};
|
|
|
|
std::shared_ptr<data> d_;
|
|
|
|
public:
|
|
write_op(write_op&&) = default;
|
|
write_op(write_op const&) = default;
|
|
|
|
template<class DeducedHandler, class... Args>
|
|
write_op(DeducedHandler&& h,
|
|
stream<NextLayer>& s, Args&&... args)
|
|
: d_(std::allocate_shared<data>(alloc_type{h},
|
|
std::forward<DeducedHandler>(h), s,
|
|
std::forward<Args>(args)...))
|
|
{
|
|
}
|
|
|
|
void
|
|
operator()() override
|
|
{
|
|
(*this)(error_code{}, false);
|
|
}
|
|
|
|
void cancel() override;
|
|
|
|
void operator()(error_code const& ec, bool again = true);
|
|
|
|
friend
|
|
auto asio_handler_allocate(
|
|
std::size_t size, write_op* op)
|
|
{
|
|
return boost_asio_handler_alloc_helpers::
|
|
allocate(size, op->d_->h);
|
|
}
|
|
|
|
friend
|
|
auto asio_handler_deallocate(
|
|
void* p, std::size_t size, write_op* op)
|
|
{
|
|
return boost_asio_handler_alloc_helpers::
|
|
deallocate(p, size, op->d_->h);
|
|
}
|
|
|
|
friend
|
|
auto asio_handler_is_continuation(write_op* op)
|
|
{
|
|
return op->d_->cont;
|
|
}
|
|
|
|
template <class Function>
|
|
friend
|
|
auto asio_handler_invoke(Function&& f, write_op* op)
|
|
{
|
|
return boost_asio_handler_invoke_helpers::
|
|
invoke(f, op->d_->h);
|
|
}
|
|
};
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers, class Handler>
|
|
void
|
|
stream<NextLayer, Allocator>::
|
|
write_op<isRequest, Body, Headers, Handler>::
|
|
cancel()
|
|
{
|
|
auto& d = *d_;
|
|
d.s.get_io_service().post(
|
|
bind_handler(std::move(*this),
|
|
boost::asio::error::operation_aborted));
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers, class Handler>
|
|
void
|
|
stream<NextLayer, Allocator>::
|
|
write_op<isRequest, Body, Headers, Handler>::
|
|
operator()(error_code const& ec, bool again)
|
|
{
|
|
auto& d = *d_;
|
|
d.cont = d.cont || again;
|
|
while(! ec && d.state != 99)
|
|
{
|
|
switch(d.state)
|
|
{
|
|
case 0:
|
|
d.state = 99;
|
|
beast::http::async_write(d.s.next_layer_,
|
|
d.m, std::move(*this));
|
|
return;
|
|
}
|
|
}
|
|
d.h(ec);
|
|
if(! d.s.wr_q_.empty())
|
|
{
|
|
auto& op = d.s.wr_q_.front();
|
|
op();
|
|
// VFALCO Use allocator
|
|
delete &op;
|
|
d.s.wr_q_.pop_front();
|
|
}
|
|
else
|
|
{
|
|
d.s.wr_active_ = false;
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
|
|
template<class NextLayer, class Allocator>
|
|
stream<NextLayer, Allocator>::
|
|
~stream()
|
|
{
|
|
// Can't destroy with pending operations!
|
|
assert(wr_q_.empty());
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<class... Args>
|
|
stream<NextLayer, Allocator>::
|
|
stream(Args&&... args)
|
|
: next_layer_(std::forward<Args>(args)...)
|
|
{
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
void
|
|
stream<NextLayer, Allocator>::
|
|
cancel(error_code& ec)
|
|
{
|
|
cancel_all();
|
|
lowest_layer().cancel(ec);
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers>
|
|
void
|
|
stream<NextLayer, Allocator>::
|
|
read(message<isRequest, Body, Headers>& msg,
|
|
error_code& ec)
|
|
{
|
|
beast::http::read(next_layer_, rd_buf_, msg, ec);
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers,
|
|
class ReadHandler>
|
|
auto
|
|
stream<NextLayer, Allocator>::
|
|
async_read(message<isRequest, Body, Headers>& msg,
|
|
ReadHandler&& handler)
|
|
{
|
|
async_completion<
|
|
ReadHandler, void(error_code)
|
|
> completion(handler);
|
|
read_op<isRequest, Body, Headers,
|
|
decltype(completion.handler)>{
|
|
completion.handler, *this, msg};
|
|
return completion.result.get();
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers>
|
|
void
|
|
stream<NextLayer, Allocator>::
|
|
write(message<isRequest, Body, Headers> const& msg,
|
|
error_code& ec)
|
|
{
|
|
beast::http::write(next_layer_, msg, ec);
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers,
|
|
class WriteHandler>
|
|
auto
|
|
stream<NextLayer, Allocator>::
|
|
async_write(message<isRequest, Body, Headers> const& msg,
|
|
WriteHandler&& handler)
|
|
{
|
|
async_completion<
|
|
WriteHandler, void(error_code)> completion(handler);
|
|
auto const cont = wr_active_ ||
|
|
boost_asio_handler_cont_helpers::is_continuation(handler);
|
|
if(! wr_active_)
|
|
{
|
|
wr_active_ = true;
|
|
write_op<isRequest, Body, Headers,
|
|
decltype(completion.handler)>{
|
|
completion.handler, *this, msg, cont }();
|
|
}
|
|
else
|
|
{
|
|
// VFALCO Use allocator
|
|
wr_q_.push_back(*new write_op<isRequest, Body, Headers,
|
|
decltype(completion.handler)>(
|
|
completion.handler, *this, msg, cont));
|
|
}
|
|
return completion.result.get();
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
template<bool isRequest, class Body, class Headers,
|
|
class WriteHandler>
|
|
auto
|
|
stream<NextLayer, Allocator>::
|
|
async_write(message<isRequest, Body, Headers>&& msg,
|
|
WriteHandler&& handler)
|
|
{
|
|
async_completion<
|
|
WriteHandler, void(error_code)> completion(handler);
|
|
auto const cont = wr_active_ ||
|
|
boost_asio_handler_cont_helpers::is_continuation(handler);
|
|
if(! wr_active_)
|
|
{
|
|
wr_active_ = true;
|
|
write_op<isRequest, Body, Headers,
|
|
decltype(completion.handler)>{completion.handler,
|
|
*this, std::move(msg), cont}();
|
|
}
|
|
else
|
|
{
|
|
// VFALCO Use allocator
|
|
wr_q_.push_back(*new write_op<isRequest, Body, Headers,
|
|
decltype(completion.handler)>(completion.handler,
|
|
*this, std::move(msg), cont));
|
|
}
|
|
return completion.result.get();
|
|
}
|
|
|
|
template<class NextLayer, class Allocator>
|
|
void
|
|
stream<NextLayer, Allocator>::
|
|
cancel_all()
|
|
{
|
|
for(auto it = wr_q_.begin(); it != wr_q_.end();)
|
|
{
|
|
auto& op = *it++;
|
|
op.cancel();
|
|
// VFALCO Use allocator
|
|
delete &op;
|
|
}
|
|
wr_q_.clear();
|
|
}
|
|
|
|
} // http
|
|
} // beast
|
|
|
|
#endif
|