diff --git a/CHANGELOG.md b/CHANGELOG.md index ecde73a9..f84ebee9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,12 @@ +1.0.0-b20 + +API Changes: + +* Rename HTTP identifiers + +-------------------------------------------------------------------------------- + +>>>>>>> b152207... . 1.0.0-b19 * Boost library min/max guidance diff --git a/doc/design.qbk b/doc/design.qbk index c3947d6b..698c6c80 100644 --- a/doc/design.qbk +++ b/doc/design.qbk @@ -447,17 +447,16 @@ start. Other design goals: or frame data, which is of any type meeting the requirements of __DynamicBuffer__ (modeled after `boost::asio::streambuf`). - Beast comes with the class `beast::basic_streambuf`, an efficient - implementation of the [*DynamicBuffer] concept which makes use of multiple + Beast comes with the class __basic_streambuf__, an efficient + implementation of the __DynamicBuffer__ concept which makes use of multiple allocated octet arrays. If an incoming message is broken up into multiple pieces, no reallocation occurs. Instead, new allocations are appended to the sequence when existing allocations are filled. Beast does not impose any particular memory management model on callers. The - `basic_streambuf` provided by beast supports standard allocators through - a template argument. Use the [*DynamicBuffer] that comes with beast, + __basic_streambuf__ provided by beast supports standard allocators through + a template argument. Use the __DynamicBuffer__ that comes with beast, customize the allocator if you desire, or provide your own type that - meets the - [@https://github.com/vinniefalco/Beast/blob/6c8b4b2f8dde72b01507e4ac7fde4ffea57ebc99/include/beast/basic_streambuf.hpp#L21 concept requirements]. + meets the requirements. [table [ diff --git a/doc/http.qbk b/doc/http.qbk index 3553f3ee..8ef784ff 100644 --- a/doc/http.qbk +++ b/doc/http.qbk @@ -5,30 +5,62 @@ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) ] +[/ +ideas: + - complete send request walkthrough (client) + - complete receive response walkthrough (client) + - complete receive request walkthrough (server) + - complete send response walkthrough (server) + + - Introduce concepts from simple to complex + - Smooth progression of new ideas building on the previous ideas + + - do we show a simplified message with collapsed fields? + - do we introduce `header` or `message` first? + + +contents: + Message (and header, fields) + Create request + Create response + Algorithms + Write + Read + Parse + Examples + Send Request + Receive Response + Receive Request + Send Response + Advanced + Responding to HEAD + Expect: 100-continue + Body (user defined) + + +section beast.http.examples Examples + +note + In the example code which follows, `socket` refers to an object of type + `boost::asio::ip::tcp::socket` which is currently connected to a remote peer. +] + [section:http Using HTTP] [block ''' - Messages - Headers + Message + Fields Body Algorithms - Sockets '''] -Beast.HTTP offers programmers simple and performant models of HTTP messages and +Beast offers programmers simple and performant models of HTTP messages and their associated operations including synchronous and asynchronous reading and -writing of messages in the HTTP/1 wire format using Boost.Asio. - -A HTTP message (referred to hereafter as "message") contains request or -response specific attributes, a series of zero or more name/value pairs -(collectively termed "headers"), and a series of octets called the message -body which may be zero in length. The HTTP protocol defines the client and -server roles: clients send messages called requests and servers send back -messages called responses. +writing of messages and headers in the HTTP/1 wire format using Boost.Asio. [note The following documentation assumes familiarity with both Boost.Asio @@ -36,6 +68,7 @@ messages called responses. and identifiers mentioned in this section are written as if the following declarations are in effect: ``` + #include #include using namespace beast; using namespace beast::http; @@ -44,101 +77,124 @@ messages called responses. -[section:message Messages] -The __message__ class template models HTTP/1 and HTTP/2 requests and responses. -These class templates are complete: they contain all the information needed -by the algorithms. Objects of this type are first class: They may be returned -from functions, moved, copied, passed as arguments, and stored in containers. -Request and response messages are distinct types; functions may be overloaded -on just one or the other if desired. Because this class template supports -HTTP/1 and HTTP/2, it is sometimes referred to as the universal message model. -There are three important template parameters in the message class: +[section:message Message] + +The HTTP protocol defines the client and server roles: clients send messages +called requests and servers send back messages called responses. A HTTP message +(referred to hereafter as "message") contains request or response specific +attributes (contained in the "Start Line"), a series of zero or more name/value +pairs (collectively termed "Fields"), and an optional series of octets called +the message body which may be zero in length. The start line for a HTTP request +includes a string called the method, a string called the URL, and a version +number indicating HTTP/1.0 or HTTP/1.1. For a response, the start line contains +an integer status code and a string called the reason phrase. Alternatively, a +HTTP message can be viewed as two parts: a header, followed by a body. + +[note + The Reason-Phrase is obsolete as of rfc7230. +] + +The __header__ class template models the header for HTTP/1 and HTTP/2 messages. +This class template is a family of specializations, one for requests and one +for responses, depending on the [*`isRequest`] template value. +The [*`Fields`] template type determines the type of associative container +used to store the field values. The provided __basic_fields__ class template +and __fields__ type alias are typical choices for the [*`Fields`] type, but +advanced applications may supply user defined types which meet the requirements. +The __message__ class template models the header and optional body for HTTP/1 +and HTTP/2 requests and responses. It is derived from the __header__ class +template with the same shared template parameters, and adds the `body` data +member. The message class template requires an additional template argument +type [*`Body`]. This type controls the container used to represent the body, +if any, as well as the algorithms needed to serialize and parse bodies of +that type. + +This illustration shows the declarations and members of the __header__ and +__message__ class templates, as well as the inheritance relationship: + +[$images/message.png [width 650px] [height 390px]] + +For notational convenience, these template type aliases are provided which +supply typical choices for the [*`Fields`] type: ``` - template< - bool isRequest, - class Body, - class Headers - > - class message; +using request_header = header; +using response_header = header; +template +using request = message; + +template +using response = message; ``` -* [*`isRequest`]: Controls whether or not the message is a request or response. - Depending on the value, different data members will be present in the resulting - type. +The code examples below show how to create and fill in a request and response +object: -* [*`Body`]: determines both the kind of container used to represent the - message body and the algorithms used to parse and serialize it. - -* [*`Headers`]: determines the container used to represent the HTTP headers. - -For notational convenience, the following template type aliases are provided: -``` - template< - class Body, - class Headers = basic_headers>> - using request = message; - - template< - class Body, - class Headers = basic_headers>> - using response = message; -``` - -The message class template has different data members depending on whether -it represents a request or response. These simplified declarations -notionally illustrate the members of HTTP/1 messages: - -``` - template - struct request - { - int version; // 10 for HTTP/1.0, 11 for HTTP/1.1 - std::string method; - std::string url; - Headers headers; - typename Body::value_type body; - }; - - template - struct response - { - int version; // 10 for HTTP/1.0, 11 for HTTP/1.1 - int status; - std::string reason; - Headers headers; - typename Body::value_type body; - }; -``` - -These statements set fields in request and response message objects: -``` - request req; - req.version = 11; // HTTP/1.1 +[table Create Message +[[HTTP Request] [HTTP Response]] +[[ + ``` + request req; + req.version = 11; // HTTP/1.1 req.method = "GET"; - req.url = "/index.html"; - req.headers.insert("User-Agent", "Beast.HTTP"); - req.body = ""; - + req.url = "/index.htm" + req.fields.insert("Accept", "text/html"); + req.fields.insert("Connection", "keep-alive"); + req.fields.insert("User-Agent", "Beast"); + ``` +][ + ``` response res; - res.version = 10; // HTTP/1.0 - res.status = 404; - res.reason = "Not Found"; - res.headers.insert("Server", "Beast.HTTP"); - res.body = "The requested resource was not found."; -``` + res.version = 11; // HTTP/1.1 + res.status = 200; + res.reason = "OK"; + res.fields.insert("Sever", "Beast"); + res.fields.insert("Content-Length", 4); + res.body = "****"; + ``` +]]] + +In the serialized format of a HTTP message, the header is represented as a +series of text lines ending in CRLF (`"\r\n"`). The end of the header is +indicated by a line containing only CRLF. Here are examples of serialized HTTP +request and response objects. The objects created above will produce these +results when serialized. Note that only the response has a body: + +[table Serialized HTTP Request and Response +[[HTTP Request] [HTTP Response]] +[[ + ``` + GET /index.htm HTTP/1.1\r\n + Accept: text/html\r\n + Connection: keep-alive\r\n + User-Agent: Beast\r\n + \r\n + ``` +][ + ``` + 200 OK HTTP/1.1\r\n + Server: Beast\r\n + Content-Length: 4\r\n + \r\n + **** + ``` +]]] + + + [endsect] -[section:headers Headers] -The [*`Headers`] type represents a container that can set or retrieve the -headers in a message. Beast provides the -[link beast.ref.http__basic_headers `basic_headers`] class which serves +[section:fields Fields] + +The [*`Fields`] type represents a container that can set or retrieve the +fields in a message. Beast provides the +[link beast.ref.http__basic_fields `basic_fields`] class which serves the needs for most users. It supports modification and inspection of values. The field names are not case-sensitive. @@ -157,15 +213,7 @@ These statements change the values of the headers in the message passed: } ``` -[heading Advanced] - -This illustration shows more detail about the -[link beast.ref.http__message [*`message`]] class template (boilerplate -present in the actual declaration has been removed for clarity): - -[$images/message.png [width 580px] [height 225px]] - -User defined [*`Headers`] types are possible. To support serialization, the +User defined [*`Fields`] types are possible. To support serialization, the type must meet the requirements of __FieldSequence__. To support parsing using the provided parser, the type must provide the `insert` member function. @@ -233,30 +281,24 @@ serializing message bodies that come from a file. [section:algorithms Algorithms] -In addition to the universal message model, Beast provides synchronous -algorithms which operate on HTTP/1 messages: +Algorithms are provided to serialize and deserialize HTTP/1 messages on +streams. -* [link beast.ref.http__read [*read]]: Parse a message from a stream - -* [link beast.ref.http__write [*write]]: Serialize a message into its wire format on a stream +* [link beast.ref.http__read [*read]]: Deserialize a HTTP/1 __header__ or __message__ from a stream. +* [link beast.ref.http__write [*write]]: Serialize a HTTP/1 __header__ or __message__ to a stream. Asynchronous versions of these algorithms are also available: -* [link beast.ref.http__async_read [*async_read]]: Parse a message from a stream +* [link beast.ref.http__async_read [*async_read]]: Deserialize a HTTP/1 __header__ or __message__ asynchronously from a stream. +* [link beast.ref.http__async_write [*async_write]]: Serialize a HTTP/1 __header__ or __message__ asynchronously to a stream. -* [link beast.ref.http__async_write [*async_write]]: Serialize a message into its wire format on a stream +[heading Using Sockets] -[endsect] - - - -[section:sockets Using Sockets] - -The library provides simple free functions modeled after Boost.Asio to -send and receive messages on TCP/IP sockets, SSL streams, or any object -which meets the Boost.Asio type requirements (SyncReadStream, SyncWriteStream, -AsyncReadStream, and AsyncWriteStream depending on the types of operations -performed). To send messages synchronously, use one of the +The free function algorithms are modeled after Boost.Asio to send and receive +messages on TCP/IP sockets, SSL streams, or any object which meets the +Boost.Asio type requirements (__SyncReadStream__, __SyncWriteStream__, +__AsyncReadStream__, and __AsyncWriteStream__ depending on the types of +operations performed). To send messages synchronously, use one of the [link beast.ref.http__write `write`] functions: ``` void send_request(boost::asio::ip::tcp::socket& sock) diff --git a/doc/images/message.png b/doc/images/message.png index cb07efc8..9b88298a 100644 Binary files a/doc/images/message.png and b/doc/images/message.png differ diff --git a/doc/master.qbk b/doc/master.qbk index 4075e301..d8155f2d 100644 --- a/doc/master.qbk +++ b/doc/master.qbk @@ -23,25 +23,33 @@ [template indexterm1[term1] ''''''[term1]''''''] [template indexterm2[term1 term2] ''''''[term1]''''''[term2]''''''] -[def __asio_handler_invoke__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/asio_handler_invoke.html `asio_handler_invoke`]] -[def __asio_handler_allocate__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/asio_handler_allocate.html `asio_handler_allocate`]] -[def __AsyncReadStream__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/AsyncReadStream.html [*AsyncReadStream]]] -[def __AsyncWriteStream__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/AsyncWriteStream.html [*AsyncWriteStream]]] -[def __Body__ [link beast.ref.Body [*`Body`]]] -[def __CompletionHandler__ [@http://www.boost.org/doc/libs/1_60_0/doc/html/boost_asio/reference/CompletionHandler.html [*CompletionHandler]]] -[def __ConstBufferSequence__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/ConstBufferSequence.html [*ConstBufferSequence]]] -[def __DynamicBuffer__ [link beast.ref.DynamicBuffer [*DynamicBuffer]]] -[def __FieldSequence__ [link beast.ref.FieldSequence [*FieldSequence]]] -[def __message__ [link beast.ref.http__message `message`]] -[def __message_v1__ [link beast.ref.http__message_v1 `message_v1`]] -[def __MutableBufferSequence__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/MutableBufferSequence.html [*MutableBufferSequence]]] [def __N4588__ [@http://cplusplus.github.io/networking-ts/draft.pdf [*N4588]]] [def __rfc6455__ [@https://tools.ietf.org/html/rfc6455 rfc6455]] [def __rfc7230__ [@https://tools.ietf.org/html/rfc7230 rfc7230]] -[def __streambuf__ [link beast.ref.streambuf `streambuf`]] + +[def __asio_handler_invoke__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/asio_handler_invoke.html `asio_handler_invoke`]] +[def __asio_handler_allocate__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/asio_handler_allocate.html `asio_handler_allocate`]] +[def __void_or_deduced__ [@http://www.boost.org/doc/libs/1_60_0/doc/html/boost_asio/reference/asynchronous_operations.html#boost_asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]] + +[def __AsyncReadStream__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/AsyncReadStream.html [*AsyncReadStream]]] +[def __AsyncWriteStream__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/AsyncWriteStream.html [*AsyncWriteStream]]] +[def __CompletionHandler__ [@http://www.boost.org/doc/libs/1_60_0/doc/html/boost_asio/reference/CompletionHandler.html [*CompletionHandler]]] +[def __ConstBufferSequence__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/ConstBufferSequence.html [*ConstBufferSequence]]] +[def __MutableBufferSequence__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/MutableBufferSequence.html [*MutableBufferSequence]]] [def __SyncReadStream__ [@http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/reference/SyncReadStream.html [*SyncReadStream]]] [def __SyncWriteStream__ [@http://www.boost.org/doc/libs/1_60_0/doc/html/boost_asio/reference/SyncWriteStream.html [*SyncWriteStream]]] -[def __void_or_deduced__ [@http://www.boost.org/doc/libs/1_60_0/doc/html/boost_asio/reference/asynchronous_operations.html#boost_asio.reference.asynchronous_operations.return_type_of_an_initiating_function ['void-or-deduced]]] + +[def __Body__ [link beast.ref.Body [*`Body`]]] +[def __DynamicBuffer__ [link beast.ref.DynamicBuffer [*DynamicBuffer]]] +[def __FieldSequence__ [link beast.ref.FieldSequence [*FieldSequence]]] +[def __Parser__ [link beast.ref.Parser [*`Parser`]]] + +[def __basic_fields__ [link beast.ref.http__basic_fields `basic_fields`]] +[def __fields__ [link beast.ref.http__fields `fields`]] +[def __header__ [link beast.ref.http__header `header`]] +[def __message__ [link beast.ref.http__message `message`]] +[def __streambuf__ [link beast.ref.streambuf `streambuf`]] +[def __basic_streambuf__ [link beast.ref.basic_streambuf `basic_streambuf`]] Beast is a cross-platform, header-only C++ library built on Boost.Asio that provides implementations of the HTTP and WebSocket protocols. diff --git a/doc/quickref.xml b/doc/quickref.xml index 2f75e68a..a51832ba 100644 --- a/doc/quickref.xml +++ b/doc/quickref.xml @@ -30,24 +30,25 @@ Classes basic_dynabuf_body - basic_headers + basic_fields basic_parser_v1 empty_body - headers - headers_parser_v1 + fields + header + header_parser_v1 message - message_headers parser_v1 request - request_headers + request_header response - response_headers + response_header resume_context streambuf_body string_body rfc7230 + ext_list param_list token_list @@ -56,20 +57,21 @@ Functions - async_parse async_read + async_parse async_write chunk_encode chunk_encode_final + swap is_keep_alive is_upgrade + operator<< parse prepare read - swap + reason_string with_body write - operator<< Type Traits @@ -84,14 +86,17 @@ Options + header_max_size body_max_size - headers_max_size skip_body Constants body_what connection + no_content_length + parse_error + parse_flag Concepts diff --git a/examples/file_body.hpp b/examples/file_body.hpp index 8e7bb55b..c92d4fe7 100644 --- a/examples/file_body.hpp +++ b/examples/file_body.hpp @@ -8,9 +8,12 @@ #ifndef BEAST_EXAMPLE_FILE_BODY_H_INCLUDED #define BEAST_EXAMPLE_FILE_BODY_H_INCLUDED -#include +#include +#include +#include #include #include +#include #include #include @@ -34,8 +37,8 @@ struct file_body writer(writer const&) = delete; writer& operator=(writer const&) = delete; - template - writer(message const& m) noexcept + template + writer(message const& m) noexcept : path_(m.body) { } diff --git a/examples/http_async_server.hpp b/examples/http_async_server.hpp index fdc94ef9..350f4a38 100644 --- a/examples/http_async_server.hpp +++ b/examples/http_async_server.hpp @@ -85,7 +85,7 @@ public: private: template + bool isRequest, class Body, class Fields> class write_op { using alloc_type = @@ -94,13 +94,13 @@ private: struct data { Stream& s; - message m; + message m; Handler h; bool cont; template data(DeducedHandler&& h_, Stream& s_, - message&& m_) + message&& m_) : s(s_) , m(std::move(m_)) , h(std::forward(h_)) @@ -170,16 +170,16 @@ private: }; template static void async_write(Stream& stream, message< - isRequest, Body, Headers>&& msg, + isRequest, Body, Fields>&& msg, DeducedHandler&& handler) { write_op::type, - isRequest, Body, Headers>{std::forward( + isRequest, Body, Fields>{std::forward( handler), stream, std::move(msg)}; } @@ -240,8 +240,8 @@ private: res.status = 404; res.reason = "Not Found"; res.version = req_.version; - res.headers.insert("Server", "http_async_server"); - res.headers.insert("Content-Type", "text/html"); + res.fields.insert("Server", "http_async_server"); + res.fields.insert("Content-Type", "text/html"); res.body = "The file '" + path + "' was not found"; prepare(res); async_write(sock_, std::move(res), @@ -255,8 +255,8 @@ private: res.status = 200; res.reason = "OK"; res.version = req_.version; - res.headers.insert("Server", "http_async_server"); - res.headers.insert("Content-Type", mime_type(path)); + res.fields.insert("Server", "http_async_server"); + res.fields.insert("Content-Type", mime_type(path)); res.body = path; prepare(res); async_write(sock_, std::move(res), @@ -269,8 +269,8 @@ private: res.status = 500; res.reason = "Internal Error"; res.version = req_.version; - res.headers.insert("Server", "http_async_server"); - res.headers.insert("Content-Type", "text/html"); + res.fields.insert("Server", "http_async_server"); + res.fields.insert("Content-Type", "text/html"); res.body = std::string{"An internal error occurred"} + e.what(); prepare(res); diff --git a/examples/http_crawl.cpp b/examples/http_crawl.cpp index b968abbb..3e67a14e 100644 --- a/examples/http_crawl.cpp +++ b/examples/http_crawl.cpp @@ -40,9 +40,9 @@ int main(int, char const*[]) req.method = "GET"; req.url = "/"; req.version = 11; - req.headers.insert("Host", host + std::string(":") + + req.fields.insert("Host", host + std::string(":") + boost::lexical_cast(ep.port())); - req.headers.insert("User-Agent", "beast/http"); + req.fields.insert("User-Agent", "beast/http"); prepare(req); write(sock, req); response res; diff --git a/examples/http_example.cpp b/examples/http_example.cpp index 2ccbc3be..55910fee 100644 --- a/examples/http_example.cpp +++ b/examples/http_example.cpp @@ -26,9 +26,9 @@ int main() req.method = "GET"; req.url = "/"; req.version = 11; - req.headers.replace("Host", host + ":" + + req.fields.replace("Host", host + ":" + boost::lexical_cast(sock.remote_endpoint().port())); - req.headers.replace("User-Agent", "Beast"); + req.fields.replace("User-Agent", "Beast"); beast::http::prepare(req); beast::http::write(sock, req); diff --git a/examples/http_sync_server.hpp b/examples/http_sync_server.hpp index 8dfe45d4..bd6df50d 100644 --- a/examples/http_sync_server.hpp +++ b/examples/http_sync_server.hpp @@ -168,8 +168,8 @@ private: res.status = 404; res.reason = "Not Found"; res.version = req.version; - res.headers.insert("Server", "http_sync_server"); - res.headers.insert("Content-Type", "text/html"); + res.fields.insert("Server", "http_sync_server"); + res.fields.insert("Content-Type", "text/html"); res.body = "The file '" + path + "' was not found"; prepare(res); write(sock, res, ec); @@ -183,8 +183,8 @@ private: res.status = 200; res.reason = "OK"; res.version = req.version; - res.headers.insert("Server", "http_sync_server"); - res.headers.insert("Content-Type", mime_type(path)); + res.fields.insert("Server", "http_sync_server"); + res.fields.insert("Content-Type", mime_type(path)); res.body = path; prepare(res); write(sock, res, ec); @@ -197,8 +197,8 @@ private: res.status = 500; res.reason = "Internal Error"; res.version = req.version; - res.headers.insert("Server", "http_sync_server"); - res.headers.insert("Content-Type", "text/html"); + res.fields.insert("Server", "http_sync_server"); + res.fields.insert("Content-Type", "text/html"); res.body = std::string{"An internal error occurred: "} + e.what(); prepare(res); diff --git a/examples/ssl/http_ssl_example.cpp b/examples/ssl/http_ssl_example.cpp index 09e921cf..ff6224c2 100644 --- a/examples/ssl/http_ssl_example.cpp +++ b/examples/ssl/http_ssl_example.cpp @@ -38,9 +38,9 @@ int main() req.method = "GET"; req.url = "/"; req.version = 11; - req.headers.insert("Host", host + ":" + + req.fields.insert("Host", host + ":" + boost::lexical_cast(sock.remote_endpoint().port())); - req.headers.insert("User-Agent", "Beast"); + req.fields.insert("User-Agent", "Beast"); beast::http::prepare(req); beast::http::write(stream, req); diff --git a/include/beast/core/dynabuf_readstream.hpp b/include/beast/core/dynabuf_readstream.hpp index 458bcc2c..32c545cc 100644 --- a/include/beast/core/dynabuf_readstream.hpp +++ b/include/beast/core/dynabuf_readstream.hpp @@ -46,7 +46,7 @@ namespace beast { Example: @code - // Process the next HTTP headers on the stream, + // Process the next HTTP header on the stream, // leaving excess bytes behind for the next call. // template @@ -54,7 +54,7 @@ namespace beast { dynabuf_readstream& stream) { // Read up to and including the end of the HTTP - // headers, leaving the sequence in the stream's + // header, leaving the sequence in the stream's // buffer. read_until may read past the end of the // headers; the return value will include only the // part up to the end of the delimiter. diff --git a/include/beast/http.hpp b/include/beast/http.hpp index 02cb4b0d..ee475791 100644 --- a/include/beast/http.hpp +++ b/include/beast/http.hpp @@ -8,12 +8,11 @@ #ifndef BEAST_HTTP_HPP #define BEAST_HTTP_HPP -#include +#include #include -#include #include #include -#include +#include #include #include #include diff --git a/include/beast/http/basic_dynabuf_body.hpp b/include/beast/http/basic_dynabuf_body.hpp index 4d331380..de2f43cd 100644 --- a/include/beast/http/basic_dynabuf_body.hpp +++ b/include/beast/http/basic_dynabuf_body.hpp @@ -8,9 +8,12 @@ #ifndef BEAST_HTTP_BASIC_DYNABUF_BODY_HPP #define BEAST_HTTP_BASIC_DYNABUF_BODY_HPP -#include +#include +#include +#include #include #include +#include namespace beast { namespace http { @@ -34,10 +37,10 @@ private: value_type& sb_; public: - template + template explicit reader(message& m) noexcept + basic_dynabuf_body, Fields>& m) noexcept : sb_(m.body) { } @@ -63,10 +66,10 @@ private: DynamicBuffer const& body_; public: - template + template explicit writer(message< - isRequest, basic_dynabuf_body, Headers> const& m) noexcept + isRequest, basic_dynabuf_body, Fields> const& m) noexcept : body_(m.body) { } diff --git a/include/beast/http/basic_headers.hpp b/include/beast/http/basic_fields.hpp similarity index 81% rename from include/beast/http/basic_headers.hpp rename to include/beast/http/basic_fields.hpp index b4010196..3bc95774 100644 --- a/include/beast/http/basic_headers.hpp +++ b/include/beast/http/basic_fields.hpp @@ -5,11 +5,11 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // -#ifndef BEAST_HTTP_BASIC_HEADERS_HPP -#define BEAST_HTTP_BASIC_HEADERS_HPP +#ifndef BEAST_HTTP_BASIC_FIELDS_HPP +#define BEAST_HTTP_BASIC_FIELDS_HPP #include -#include +#include #include #include #include @@ -21,35 +21,35 @@ namespace beast { namespace http { -/** A container for storing HTTP headers. +/** A container for storing HTTP header fields. This container is designed to store the field value pairs that make - up the headers and trailers in a HTTP message. Objects of this type - are iterable, which each element holding the field name and field + up the fields and trailers in a HTTP message. Objects of this type + are iterable, with each element holding the field name and field value. - Field names are stored as-is, but comparison are case-insensitive. + Field names are stored as-is, but comparisons are case-insensitive. When the container is iterated, the fields are presented in the order of insertion. For fields with the same name, the container behaves - as a std::multiset; there will be a separate value for each occurrence + as a `std::multiset`; there will be a separate value for each occurrence of the field name. - @note Meets the requirements of @b `FieldSequence`. + @note Meets the requirements of @b FieldSequence. */ template -class basic_headers : +class basic_fields : #if ! GENERATING_DOCS private beast::detail::empty_base_optimization< typename std::allocator_traits:: template rebind_alloc< - detail::basic_headers_base::element>>, + detail::basic_fields_base::element>>, #endif - public detail::basic_headers_base + public detail::basic_fields_base { using alloc_type = typename std::allocator_traits:: template rebind_alloc< - detail::basic_headers_base::element>; + detail::basic_fields_base::element>; using alloc_traits = std::allocator_traits; @@ -61,16 +61,16 @@ class basic_headers : delete_all(); void - move_assign(basic_headers&, std::false_type); + move_assign(basic_fields&, std::false_type); void - move_assign(basic_headers&, std::true_type); + move_assign(basic_fields&, std::true_type); void - copy_assign(basic_headers const&, std::false_type); + copy_assign(basic_fields const&, std::false_type); void - copy_assign(basic_headers const&, std::true_type); + copy_assign(basic_fields const&, std::true_type); template void @@ -103,17 +103,17 @@ public: #endif /// Default constructor. - basic_headers() = default; + basic_fields() = default; /// Destructor - ~basic_headers(); + ~basic_fields(); - /** Construct the headers. + /** Construct the fields. @param alloc The allocator to use. */ explicit - basic_headers(Allocator const& alloc); + basic_fields(Allocator const& alloc); /** Move constructor. @@ -121,7 +121,7 @@ public: @param other The object to move from. */ - basic_headers(basic_headers&& other); + basic_fields(basic_fields&& other); /** Move assignment. @@ -129,25 +129,25 @@ public: @param other The object to move from. */ - basic_headers& operator=(basic_headers&& other); + basic_fields& operator=(basic_fields&& other); /// Copy constructor. - basic_headers(basic_headers const&); + basic_fields(basic_fields const&); /// Copy assignment. - basic_headers& operator=(basic_headers const&); + basic_fields& operator=(basic_fields const&); /// Copy constructor. template - basic_headers(basic_headers const&); + basic_fields(basic_fields const&); /// Copy assignment. template - basic_headers& operator=(basic_headers const&); + basic_fields& operator=(basic_fields const&); /// Construct from a field sequence. template - basic_headers(FwdIt first, FwdIt last); + basic_fields(FwdIt first, FwdIt last); /// Returns `true` if the field sequence contains no elements. bool @@ -218,7 +218,7 @@ public: boost::string_ref operator[](boost::string_ref const& name) const; - /// Clear the contents of the basic_headers. + /// Clear the contents of the basic_fields. void clear() noexcept; @@ -301,6 +301,6 @@ public: } // http } // beast -#include +#include #endif diff --git a/include/beast/http/basic_parser_v1.hpp b/include/beast/http/basic_parser_v1.hpp index 9db48bf3..70e9e06c 100644 --- a/include/beast/http/basic_parser_v1.hpp +++ b/include/beast/http/basic_parser_v1.hpp @@ -22,8 +22,11 @@ namespace beast { namespace http { -namespace parse_flag { -enum values +/** Parse flags + + The set of parser bit flags are returned by @ref basic_parser_v1::flags. +*/ +enum parse_flag { chunked = 1, connection_keep_alive = 2, @@ -34,28 +37,6 @@ enum values skipbody = 64, contentlength = 128 }; -} // parse_flag - -/** Headers maximum size option. - - Sets the maximum number of cumulative bytes allowed - including all header octets. A value of zero indicates - no limit on the number of header octets - - The default headers maximum size is 16KB (16,384 bytes). - - @note Objects of this type are used with basic_parser_v1::set_option. -*/ -struct headers_max_size -{ - std::size_t value; - - explicit - headers_max_size(std::size_t v) - : value(v) - { - } -}; /** Body maximum size option. @@ -67,7 +48,7 @@ struct headers_max_size The default body maximum size for requests is 4MB (four megabytes or 4,194,304 bytes) and unlimited for responses. - @note Objects of this type are used with basic_parser_v1::set_option. + @note Objects of this type are used with @ref basic_parser_v1::set_option. */ struct body_max_size { @@ -80,9 +61,30 @@ struct body_max_size } }; +/** Header maximum size option. + + Sets the maximum number of cumulative bytes allowed + including all header octets. A value of zero indicates + no limit on the number of header octets. + + The default header maximum size is 16KB (16,384 bytes). + + @note Objects of this type are used with @ref basic_parser_v1::set_option. +*/ +struct header_max_size +{ + std::size_t value; + + explicit + header_max_size(std::size_t v) + : value(v) + { + } +}; + /** A value indicating how the parser should treat the body. - This value is returned from the `on_headers` callback in + This value is returned from the `on_header` callback in the derived class. It controls what the parser does next in terms of the message body. */ @@ -94,7 +96,7 @@ enum class body_what /** Skip parsing of the body. - When returned by `on_headers` this causes parsing to + When returned by `on_header` this causes parsing to complete and control to return to the caller. This could be used when sending a response to a HEAD request, for example. @@ -116,8 +118,8 @@ enum class body_what to the parser will begin reading the message body. This could be used by callers to inspect the HTTP - headers before committing to read the body. For example, - to choose the body type based on the headers. Or to + header before committing to read the body. For example, + to choose the body type based on the fields. Or to respond to an Expect: 100-continue request. */ pause @@ -181,19 +183,19 @@ static std::uint64_t constexpr no_content_length = // void on_value(boost::string_ref const&, error_code&) - // Called when all the headers have been parsed successfully. + // Called when the entire header has been parsed successfully. // void - on_headers(std::uint64_t content_length, error_code&); + on_header(std::uint64_t content_length, error_code&); - // Called after on_headers, before the body is parsed + // Called after on_header, before the body is parsed // body_what on_body_what(std::uint64_t content_length, error_code&); // Called for each piece of the body. // - // If the headers indicate chunk encoding, the chunk + // If the header indicates chunk encoding, the chunk // encoding is removed from the buffer before being // passed to the callback. // @@ -319,9 +321,9 @@ public: std::forward(an)...); } - /// Set the headers maximum size option + /// Set the header maximum size option void - set_option(headers_max_size const& o) + set_option(header_max_size const& o) { h_max_ = o.value; h_left_ = h_max_; @@ -508,7 +510,7 @@ private: void init(std::true_type) { - // 16KB max headers, 4MB max body + // Request: 16KB max header, 4MB max body h_max_ = 16 * 1024; b_max_ = 4 * 1024 * 1024; } @@ -516,7 +518,7 @@ private: void init(std::false_type) { - // 16KB max headers, unlimited body + // Response: 16KB max header, unlimited body h_max_ = 16 * 1024; b_max_ = 0; } @@ -616,7 +618,7 @@ private: template struct check_on_headers().on_headers( + std::declval().on_header( std::declval(), std::declval()) )>> : std::true_type {}; @@ -674,7 +676,7 @@ private: "on_method requirements not met"); if(h_max_ && s.size() > h_left_) { - ec = parse_error::headers_too_big; + ec = parse_error::header_too_big; return; } h_left_ -= s.size(); @@ -700,7 +702,7 @@ private: "on_uri requirements not met"); if(h_max_ && s.size() > h_left_) { - ec = parse_error::headers_too_big; + ec = parse_error::header_too_big; return; } h_left_ -= s.size(); @@ -726,7 +728,7 @@ private: "on_reason requirements not met"); if(h_max_ && s.size() > h_left_) { - ec = parse_error::headers_too_big; + ec = parse_error::header_too_big; return; } h_left_ -= s.size(); @@ -785,7 +787,7 @@ private: "on_field requirements not met"); if(h_max_ && s.size() > h_left_) { - ec = parse_error::headers_too_big; + ec = parse_error::header_too_big; return; } h_left_ -= s.size(); @@ -799,7 +801,7 @@ private: "on_value requirements not met"); if(h_max_ && s.size() > h_left_) { - ec = parse_error::headers_too_big; + ec = parse_error::header_too_big; return; } h_left_ -= s.size(); @@ -810,8 +812,8 @@ private: call_on_headers(error_code& ec) { static_assert(check_on_headers::value, - "on_headers requirements not met"); - impl().on_headers(content_length_, ec); + "on_header requirements not met"); + impl().on_header(content_length_, ec); } body_what diff --git a/include/beast/http/body_type.hpp b/include/beast/http/body_type.hpp deleted file mode 100644 index 5b3f9601..00000000 --- a/include/beast/http/body_type.hpp +++ /dev/null @@ -1,19 +0,0 @@ -// -// Copyright (c) 2013-2016 Vinnie Falco (vinnie dot falco at gmail dot com) -// -// Distributed under the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// - -#ifndef BEAST_HTTP_BODY_TYPE_HPP -#define BEAST_HTTP_BODY_TYPE_HPP - -// Convenience header to include everything -// needed when declarating a user defined Body type. - -#include -#include -#include -#include - -#endif diff --git a/include/beast/http/chunk_encode.hpp b/include/beast/http/chunk_encode.hpp index 6d9836f2..cb2881b4 100644 --- a/include/beast/http/chunk_encode.hpp +++ b/include/beast/http/chunk_encode.hpp @@ -5,10 +5,11 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // -#ifndef BEAST_HTTP_DETAIL_CHUNK_ENCODE_HPP -#define BEAST_HTTP_DETAIL_CHUNK_ENCODE_HPP +#ifndef BEAST_HTTP_CHUNK_ENCODE_HPP +#define BEAST_HTTP_CHUNK_ENCODE_HPP #include +#include #include #include #include @@ -20,92 +21,6 @@ namespace beast { namespace http { -class chunk_encode_text -{ - boost::asio::const_buffer cb_; - - // Storage for the longest hex string we might need, plus delimiters. - std::array buf_; - - template - void - copy(chunk_encode_text const& other); - - template - void - setup(std::size_t n); - - template - static - OutIter - to_hex(OutIter last, std::size_t n) - { - if(n == 0) - { - *--last = '0'; - return last; - } - while(n) - { - *--last = "0123456789abcdef"[n&0xf]; - n>>=4; - } - return last; - } - -public: - using value_type = boost::asio::const_buffer; - - using const_iterator = value_type const*; - - chunk_encode_text(chunk_encode_text const& other) - { - copy(other); - } - - explicit - chunk_encode_text(std::size_t n) - { - setup(n); - } - - const_iterator - begin() const - { - return &cb_; - } - - const_iterator - end() const - { - return begin() + 1; - } -}; -template -void -chunk_encode_text:: -copy(chunk_encode_text const& other) -{ - auto const n = - boost::asio::buffer_size(other.cb_); - buf_ = other.buf_; - cb_ = boost::asio::const_buffer( - &buf_[buf_.size() - n], n); -} - -template -void -chunk_encode_text:: -setup(std::size_t n) -{ - buf_[buf_.size() - 2] = '\r'; - buf_[buf_.size() - 1] = '\n'; - auto it = to_hex(buf_.end() - 2, n); - cb_ = boost::asio::const_buffer{&*it, - static_cast( - std::distance(it, buf_.end()))}; -} - /** Returns a chunk-encoded ConstBufferSequence. This returns a buffer sequence representing the @@ -124,7 +39,7 @@ template implementation_defined #else beast::detail::buffer_cat_helper< - chunk_encode_text, + detail::chunk_encode_delim, ConstBufferSequence, boost::asio::const_buffers_1> #endif @@ -132,7 +47,7 @@ chunk_encode(bool fin, ConstBufferSequence const& buffers) { using boost::asio::buffer_size; return buffer_cat( - chunk_encode_text{buffer_size(buffers)}, + detail::chunk_encode_delim{buffer_size(buffers)}, buffers, fin ? boost::asio::const_buffers_1{"\r\n0\r\n\r\n", 7} : boost::asio::const_buffers_1{"\r\n", 2}); diff --git a/include/beast/http/detail/basic_headers.hpp b/include/beast/http/detail/basic_fields.hpp similarity index 90% rename from include/beast/http/detail/basic_headers.hpp rename to include/beast/http/detail/basic_fields.hpp index 49bc678d..a60b30f2 100644 --- a/include/beast/http/detail/basic_headers.hpp +++ b/include/beast/http/detail/basic_fields.hpp @@ -5,8 +5,8 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // -#ifndef BEAST_HTTP_DETAIL_BASIC_HEADERS_HPP -#define BEAST_HTTP_DETAIL_BASIC_HEADERS_HPP +#ifndef BEAST_HTTP_DETAIL_BASIC_FIELDS_HPP +#define BEAST_HTTP_DETAIL_BASIC_FIELDS_HPP #include #include @@ -17,11 +17,11 @@ namespace beast { namespace http { template -class basic_headers; +class basic_fields; namespace detail { -class basic_headers_base +class basic_fields_base { public: struct value_type @@ -51,7 +51,7 @@ public: protected: template - friend class beast::http::basic_headers; + friend class beast::http::basic_fields; struct element : boost::intrusive::set_base_hook < @@ -105,7 +105,7 @@ protected: set_t set_; list_t list_; - basic_headers_base(set_t&& set, list_t&& list) + basic_fields_base(set_t&& set, list_t&& list) : set_(std::move(set)) , list_(std::move(list)) { @@ -116,21 +116,21 @@ public: using iterator = const_iterator; - basic_headers_base() = default; + basic_fields_base() = default; }; //------------------------------------------------------------------------------ -class basic_headers_base::const_iterator +class basic_fields_base::const_iterator { using iter_type = list_t::const_iterator; iter_type it_; template - friend class beast::http::basic_headers; + friend class beast::http::basic_fields; - friend class basic_headers_base; + friend class basic_fields_base; const_iterator(iter_type it) : it_(it) @@ -139,7 +139,7 @@ class basic_headers_base::const_iterator public: using value_type = - typename basic_headers_base::value_type; + typename basic_fields_base::value_type; using pointer = value_type const*; using reference = value_type const&; using difference_type = std::ptrdiff_t; diff --git a/include/beast/http/detail/chunk_encode.hpp b/include/beast/http/detail/chunk_encode.hpp new file mode 100644 index 00000000..e2ebb812 --- /dev/null +++ b/include/beast/http/detail/chunk_encode.hpp @@ -0,0 +1,111 @@ +// +// Copyright (c) 2013-2016 Vinnie Falco (vinnie dot falco at gmail dot com) +// +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) +// + +#ifndef BEAST_HTTP_DETAIL_CHUNK_ENCODE_HPP +#define BEAST_HTTP_DETAIL_CHUNK_ENCODE_HPP + +#include +#include +#include +#include + +namespace beast { +namespace http { +namespace detail { + +class chunk_encode_delim +{ + boost::asio::const_buffer cb_; + + // Storage for the longest hex string we might need, plus delimiters. + std::array buf_; + + template + void + copy(chunk_encode_delim const& other); + + template + void + setup(std::size_t n); + + template + static + OutIter + to_hex(OutIter last, std::size_t n) + { + if(n == 0) + { + *--last = '0'; + return last; + } + while(n) + { + *--last = "0123456789abcdef"[n&0xf]; + n>>=4; + } + return last; + } + +public: + using value_type = boost::asio::const_buffer; + + using const_iterator = value_type const*; + + chunk_encode_delim(chunk_encode_delim const& other) + { + copy(other); + } + + explicit + chunk_encode_delim(std::size_t n) + { + setup(n); + } + + const_iterator + begin() const + { + return &cb_; + } + + const_iterator + end() const + { + return begin() + 1; + } +}; + +template +void +chunk_encode_delim:: +copy(chunk_encode_delim const& other) +{ + auto const n = + boost::asio::buffer_size(other.cb_); + buf_ = other.buf_; + cb_ = boost::asio::const_buffer( + &buf_[buf_.size() - n], n); +} + +template +void +chunk_encode_delim:: +setup(std::size_t n) +{ + buf_[buf_.size() - 2] = '\r'; + buf_[buf_.size() - 1] = '\n'; + auto it = to_hex(buf_.end() - 2, n); + cb_ = boost::asio::const_buffer{&*it, + static_cast( + std::distance(it, buf_.end()))}; +} + +} // detail +} // http +} // beast + +#endif diff --git a/include/beast/http/empty_body.hpp b/include/beast/http/empty_body.hpp index b76e02d7..e497b87f 100644 --- a/include/beast/http/empty_body.hpp +++ b/include/beast/http/empty_body.hpp @@ -8,9 +8,12 @@ #ifndef BEAST_HTTP_EMPTY_BODY_HPP #define BEAST_HTTP_EMPTY_BODY_HPP -#include +#include +#include +#include #include #include +#include #include #include @@ -36,9 +39,9 @@ private: struct writer { - template + template explicit - writer(message const& m) noexcept + writer(message const& m) noexcept { beast::detail::ignore_unused(m); } diff --git a/include/beast/http/headers.hpp b/include/beast/http/fields.hpp similarity index 62% rename from include/beast/http/headers.hpp rename to include/beast/http/fields.hpp index 3268fa50..fb80ad7f 100644 --- a/include/beast/http/headers.hpp +++ b/include/beast/http/fields.hpp @@ -5,17 +5,18 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // -#ifndef BEAST_HTTP_HEADERS_HPP -#define BEAST_HTTP_HEADERS_HPP +#ifndef BEAST_HTTP_FIELDS_HPP +#define BEAST_HTTP_FIELDS_HPP -#include +#include #include namespace beast { namespace http { -using headers = - basic_headers>; +/// A typical HTTP header fields container +using fields = + basic_fields>; } // http } // beast diff --git a/include/beast/http/headers_parser_v1.hpp b/include/beast/http/header_parser_v1.hpp similarity index 74% rename from include/beast/http/headers_parser_v1.hpp rename to include/beast/http/header_parser_v1.hpp index 21236fd5..9caafa44 100644 --- a/include/beast/http/headers_parser_v1.hpp +++ b/include/beast/http/header_parser_v1.hpp @@ -13,7 +13,6 @@ #include #include #include -#include #include #include #include @@ -36,100 +35,99 @@ struct response_parser_base } // detail -/** A parser for HTTP/1 request and response headers. +/** A parser for a HTTP/1 request or response header. This class uses the HTTP/1 wire format parser to - convert a series of octets into a @ref request_headers - or @ref response_headers. + convert a series of octets into a request or + response @ref header. @note A new instance of the parser is required for each message. */ -template -class headers_parser_v1 +template +class header_parser_v1 : public basic_parser_v1> + header_parser_v1> , private std::conditional::type { public: - /// The type of message this parser produces. - using headers_type = - message_headers; + /// The type of the header this parser produces. + using header_type = header; private: - // VFALCO Check Headers requirements? + // VFALCO Check Fields requirements? std::string field_; std::string value_; - headers_type h_; + header_type h_; bool flush_ = false; public: /// Default constructor - headers_parser_v1() = default; + header_parser_v1() = default; /// Move constructor - headers_parser_v1(headers_parser_v1&&) = default; + header_parser_v1(header_parser_v1&&) = default; /// Copy constructor (disallowed) - headers_parser_v1(headers_parser_v1 const&) = delete; + header_parser_v1(header_parser_v1 const&) = delete; /// Move assignment (disallowed) - headers_parser_v1& operator=(headers_parser_v1&&) = delete; + header_parser_v1& operator=(header_parser_v1&&) = delete; /// Copy assignment (disallowed) - headers_parser_v1& operator=(headers_parser_v1 const&) = delete; + header_parser_v1& operator=(header_parser_v1 const&) = delete; /** Construct the parser. - @param args Forwarded to the message headers constructor. + @param args Forwarded to the header constructor. */ #if GENERATING_DOCS template explicit - headers_parser_v1(Args&&... args); + header_parser_v1(Args&&... args); #else template::type, headers_parser_v1>::value>> + typename std::decay::type, header_parser_v1>::value>> explicit - headers_parser_v1(Arg1&& arg1, ArgN&&... argn) + header_parser_v1(Arg1&& arg1, ArgN&&... argn) : h_(std::forward(arg1), std::forward(argn)...) { } #endif - /** Returns the parsed headers. + /** Returns the parsed header Only valid if @ref complete would return `true`. */ - headers_type const& + header_type const& get() const { return h_; } - /** Returns the parsed headers. + /** Returns the parsed header. Only valid if @ref complete would return `true`. */ - headers_type& + header_type& get() { return h_; } - /** Returns ownership of the parsed headers. + /** Returns ownership of the parsed header. Ownership is transferred to the caller. Only valid if @ref complete would return `true`. Requires: - `message_headers` is @b MoveConstructible + @ref header_type is @b MoveConstructible */ - headers_type + header_type release() { static_assert(std::is_move_constructible::value, @@ -138,7 +136,7 @@ public: } private: - friend class basic_parser_v1; + friend class basic_parser_v1; void flush() { @@ -146,7 +144,7 @@ private: return; flush_ = false; BOOST_ASSERT(! field_.empty()); - h_.headers.insert(field_, value_); + h_.fields.insert(field_, value_); field_.clear(); value_.clear(); } @@ -207,7 +205,7 @@ private: } void - on_headers(std::uint64_t, error_code&) + on_header(std::uint64_t, error_code&) { flush(); h_.version = 10 * this->http_major() + this->http_minor(); diff --git a/include/beast/http/impl/basic_headers.ipp b/include/beast/http/impl/basic_fields.ipp similarity index 76% rename from include/beast/http/impl/basic_headers.ipp rename to include/beast/http/impl/basic_fields.ipp index 1186731b..8c421e9e 100644 --- a/include/beast/http/impl/basic_headers.ipp +++ b/include/beast/http/impl/basic_fields.ipp @@ -5,8 +5,8 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // -#ifndef BEAST_HTTP_IMPL_BASIC_HEADERS_IPP -#define BEAST_HTTP_IMPL_BASIC_HEADERS_IPP +#ifndef BEAST_HTTP_IMPL_BASIC_FIELDS_IPP +#define BEAST_HTTP_IMPL_BASIC_FIELDS_IPP #include #include @@ -16,7 +16,7 @@ namespace http { template void -basic_headers:: +basic_fields:: delete_all() { for(auto it = list_.begin(); it != list_.end();) @@ -31,8 +31,8 @@ delete_all() template inline void -basic_headers:: -move_assign(basic_headers& other, std::false_type) +basic_fields:: +move_assign(basic_fields& other, std::false_type) { if(this->member() != other.member()) { @@ -49,8 +49,8 @@ move_assign(basic_headers& other, std::false_type) template inline void -basic_headers:: -move_assign(basic_headers& other, std::true_type) +basic_fields:: +move_assign(basic_fields& other, std::true_type) { this->member() = std::move(other.member()); set_ = std::move(other.set_); @@ -60,8 +60,8 @@ move_assign(basic_headers& other, std::true_type) template inline void -basic_headers:: -copy_assign(basic_headers const& other, std::false_type) +basic_fields:: +copy_assign(basic_fields const& other, std::false_type) { copy_from(other); } @@ -69,8 +69,8 @@ copy_assign(basic_headers const& other, std::false_type) template inline void -basic_headers:: -copy_assign(basic_headers const& other, std::true_type) +basic_fields:: +copy_assign(basic_fields const& other, std::true_type) { this->member() = other.member(); copy_from(other); @@ -79,35 +79,35 @@ copy_assign(basic_headers const& other, std::true_type) //------------------------------------------------------------------------------ template -basic_headers:: -~basic_headers() +basic_fields:: +~basic_fields() { delete_all(); } template -basic_headers:: -basic_headers(Allocator const& alloc) +basic_fields:: +basic_fields(Allocator const& alloc) : beast::detail::empty_base_optimization< alloc_type>(alloc) { } template -basic_headers:: -basic_headers(basic_headers&& other) +basic_fields:: +basic_fields(basic_fields&& other) : beast::detail::empty_base_optimization( std::move(other.member())) - , detail::basic_headers_base( + , detail::basic_fields_base( std::move(other.set_), std::move(other.list_)) { } template auto -basic_headers:: -operator=(basic_headers&& other) -> - basic_headers& +basic_fields:: +operator=(basic_fields&& other) -> + basic_fields& { if(this == &other) return *this; @@ -118,9 +118,9 @@ operator=(basic_headers&& other) -> } template -basic_headers:: -basic_headers(basic_headers const& other) - : basic_headers(alloc_traits:: +basic_fields:: +basic_fields(basic_fields const& other) + : basic_fields(alloc_traits:: select_on_container_copy_construction(other.member())) { copy_from(other); @@ -128,9 +128,9 @@ basic_headers(basic_headers const& other) template auto -basic_headers:: -operator=(basic_headers const& other) -> - basic_headers& +basic_fields:: +operator=(basic_fields const& other) -> + basic_fields& { clear(); copy_assign(other, std::integral_constant template template -basic_headers:: -basic_headers(basic_headers const& other) +basic_fields:: +basic_fields(basic_fields const& other) { copy_from(other); } @@ -149,9 +149,9 @@ basic_headers(basic_headers const& other) template template auto -basic_headers:: -operator=(basic_headers const& other) -> - basic_headers& +basic_fields:: +operator=(basic_fields const& other) -> + basic_fields& { clear(); copy_from(other); @@ -160,8 +160,8 @@ operator=(basic_headers const& other) -> template template -basic_headers:: -basic_headers(FwdIt first, FwdIt last) +basic_fields:: +basic_fields(FwdIt first, FwdIt last) { for(;first != last; ++first) insert(first->name(), first->value()); @@ -169,7 +169,7 @@ basic_headers(FwdIt first, FwdIt last) template std::size_t -basic_headers:: +basic_fields:: count(boost::string_ref const& name) const { auto const it = set_.find(name, less{}); @@ -181,7 +181,7 @@ count(boost::string_ref const& name) const template auto -basic_headers:: +basic_fields:: find(boost::string_ref const& name) const -> iterator { @@ -193,7 +193,7 @@ find(boost::string_ref const& name) const -> template boost::string_ref -basic_headers:: +basic_fields:: operator[](boost::string_ref const& name) const { auto const it = find(name); @@ -204,7 +204,7 @@ operator[](boost::string_ref const& name) const template void -basic_headers:: +basic_fields:: clear() noexcept { delete_all(); @@ -214,7 +214,7 @@ clear() noexcept template std::size_t -basic_headers:: +basic_fields:: erase(boost::string_ref const& name) { auto it = set_.find(name, less{}); @@ -238,7 +238,7 @@ erase(boost::string_ref const& name) template void -basic_headers:: +basic_fields:: insert(boost::string_ref const& name, boost::string_ref value) { @@ -251,7 +251,7 @@ insert(boost::string_ref const& name, template void -basic_headers:: +basic_fields:: replace(boost::string_ref const& name, boost::string_ref value) { diff --git a/include/beast/http/impl/basic_parser_v1.ipp b/include/beast/http/impl/basic_parser_v1.ipp index 069656b7..9757b92a 100644 --- a/include/beast/http/impl/basic_parser_v1.ipp +++ b/include/beast/http/impl/basic_parser_v1.ipp @@ -5,6 +5,16 @@ // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // +#ifndef BEAST_HTTP_IMPL_BASIC_PARSER_V1_IPP +#define BEAST_HTTP_IMPL_BASIC_PARSER_V1_IPP + +#include +#include +#include + +namespace beast { +namespace http { + /* Based on src/http/ngx_http_parse.c from NGINX copyright Igor Sysoev * * Additional changes are licensed under the same terms as NGINX and @@ -28,21 +38,10 @@ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. */ -/* - This code is a modified version of nodejs/http-parser, copyright above: - https://github.com/nodejs/http-parser +/* This code is a modified version of nodejs/http-parser, copyright above: + https://github.com/nodejs/http-parser */ -#ifndef BEAST_HTTP_IMPL_BASIC_PARSER_V1_IPP -#define BEAST_HTTP_IMPL_BASIC_PARSER_V1_IPP - -#include -#include -#include - -namespace beast { -namespace http { - template basic_parser_v1:: basic_parser_v1() diff --git a/include/beast/http/impl/message.ipp b/include/beast/http/impl/message.ipp index ea6c26f5..9a818cd8 100644 --- a/include/beast/http/impl/message.ipp +++ b/include/beast/http/impl/message.ipp @@ -20,67 +20,67 @@ namespace beast { namespace http { -template +template void swap( - message_headers& m1, - message_headers& m2) + header& m1, + header& m2) { using std::swap; swap(m1.version, m2.version); swap(m1.method, m2.method); swap(m1.url, m2.url); - swap(m1.headers, m2.headers); + swap(m1.fields, m2.fields); } -template +template void swap( - message_headers& a, - message_headers& b) + header& a, + header& b) { using std::swap; swap(a.version, b.version); swap(a.status, b.status); swap(a.reason, b.reason); - swap(a.headers, b.headers); + swap(a.fields, b.fields); } -template +template void swap( - message& m1, - message& m2) + message& m1, + message& m2) { using std::swap; swap(m1.base(), m2.base()); swap(m1.body, m2.body); } -template +template bool -is_keep_alive(message const& msg) +is_keep_alive(header const& msg) { BOOST_ASSERT(msg.version == 10 || msg.version == 11); if(msg.version == 11) { - if(token_list{msg.headers["Connection"]}.exists("close")) + if(token_list{msg.fields["Connection"]}.exists("close")) return false; return true; } - if(token_list{msg.headers["Connection"]}.exists("keep-alive")) + if(token_list{msg.fields["Connection"]}.exists("keep-alive")) return true; return false; } -template +template bool -is_upgrade(message const& msg) +is_upgrade(header const& msg) { BOOST_ASSERT(msg.version == 10 || msg.version == 11); if(msg.version == 10) return false; - if(token_list{msg.headers["Connection"]}.exists("upgrade")) + if(token_list{msg.fields["Connection"]}.exists("upgrade")) return true; return false; } @@ -93,19 +93,19 @@ struct prepare_info boost::optional content_length; }; -template +template inline void prepare_options(prepare_info& pi, - message& msg) + message& msg) { beast::detail::ignore_unused(pi, msg); } -template +template void prepare_option(prepare_info& pi, - message& msg, + message& msg, connection value) { beast::detail::ignore_unused(msg); @@ -113,11 +113,11 @@ prepare_option(prepare_info& pi, } template< - bool isRequest, class Body, class Headers, + bool isRequest, class Body, class Fields, class Opt, class... Opts> void prepare_options(prepare_info& pi, - message& msg, + message& msg, Opt&& opt, Opts&&... opts) { prepare_option(pi, msg, opt); @@ -125,10 +125,10 @@ prepare_options(prepare_info& pi, std::forward(opts)...); } -template +template void prepare_content_length(prepare_info& pi, - message const& msg, + message const& msg, std::true_type) { typename Body::writer w(msg); @@ -140,10 +140,10 @@ prepare_content_length(prepare_info& pi, pi.content_length = w.content_length(); } -template +template void prepare_content_length(prepare_info& pi, - message const& msg, + message const& msg, std::false_type) { beast::detail::ignore_unused(msg); @@ -153,10 +153,10 @@ prepare_content_length(prepare_info& pi, } // detail template< - bool isRequest, class Body, class Headers, + bool isRequest, class Body, class Fields, class... Options> void -prepare(message& msg, +prepare(message& msg, Options&&... options) { // VFALCO TODO @@ -165,7 +165,7 @@ prepare(message& msg, static_assert(has_writer::value, "Body has no writer"); static_assert(is_Writer>::value, + message>::value, "Writer requirements not met"); detail::prepare_info pi; detail::prepare_content_length(pi, msg, @@ -173,15 +173,15 @@ prepare(message& msg, detail::prepare_options(pi, msg, std::forward(options)...); - if(msg.headers.exists("Connection")) + if(msg.fields.exists("Connection")) throw std::invalid_argument( "prepare called with Connection field set"); - if(msg.headers.exists("Content-Length")) + if(msg.fields.exists("Content-Length")) throw std::invalid_argument( "prepare called with Content-Length field set"); - if(token_list{msg.headers["Transfer-Encoding"]}.exists("chunked")) + if(token_list{msg.fields["Transfer-Encoding"]}.exists("chunked")) throw std::invalid_argument( "prepare called with Transfer-Encoding: chunked set"); @@ -192,27 +192,27 @@ prepare(message& msg, struct set_field { void - operator()(message& msg, + operator()(message& msg, detail::prepare_info const& pi) const { using beast::detail::ci_equal; if(*pi.content_length > 0 || ci_equal(msg.method, "POST")) { - msg.headers.insert( + msg.fields.insert( "Content-Length", *pi.content_length); } } void - operator()(message& msg, + operator()(message& msg, detail::prepare_info const& pi) const { if((msg.status / 100 ) != 1 && msg.status != 204 && msg.status != 304) { - msg.headers.insert( + msg.fields.insert( "Content-Length", *pi.content_length); } } @@ -221,39 +221,39 @@ prepare(message& msg, } else if(msg.version >= 11) { - msg.headers.insert("Transfer-Encoding", "chunked"); + msg.fields.insert("Transfer-Encoding", "chunked"); } } auto const content_length = - msg.headers.exists("Content-Length"); + msg.fields.exists("Content-Length"); if(pi.connection_value) { switch(*pi.connection_value) { case connection::upgrade: - msg.headers.insert("Connection", "upgrade"); + msg.fields.insert("Connection", "upgrade"); break; case connection::keep_alive: if(msg.version < 11) { if(content_length) - msg.headers.insert("Connection", "keep-alive"); + msg.fields.insert("Connection", "keep-alive"); } break; case connection::close: if(msg.version >= 11) - msg.headers.insert("Connection", "close"); + msg.fields.insert("Connection", "close"); break; } } // rfc7230 6.7. if(msg.version < 11 && token_list{ - msg.headers["Connection"]}.exists("upgrade")) + msg.fields["Connection"]}.exists("upgrade")) throw std::invalid_argument( "invalid version for Connection: upgrade"); } diff --git a/include/beast/http/impl/parse_error.ipp b/include/beast/http/impl/parse_error.ipp index 25b5374e..83578ceb 100644 --- a/include/beast/http/impl/parse_error.ipp +++ b/include/beast/http/impl/parse_error.ipp @@ -50,7 +50,7 @@ public: case parse_error::invalid_chunk_size: return "invalid chunk size"; case parse_error::invalid_ext_name: return "invalid ext name"; case parse_error::invalid_ext_val: return "invalid ext val"; - case parse_error::headers_too_big: return "headers size limit exceeded"; + case parse_error::header_too_big: return "header size limit exceeded"; case parse_error::body_too_big: return "body size limit exceeded"; default: case parse_error::short_read: return "unexpected end of data"; diff --git a/include/beast/http/impl/read.ipp b/include/beast/http/impl/read.ipp index 50b19867..6a96355a 100644 --- a/include/beast/http/impl/read.ipp +++ b/include/beast/http/impl/read.ipp @@ -9,7 +9,7 @@ #define BEAST_HTTP_IMPL_READ_IPP_HPP #include -#include +#include #include #include #include @@ -23,18 +23,18 @@ namespace http { namespace detail { template -class read_headers_op +class read_header_op { using alloc_type = handler_alloc; using parser_type = - headers_parser_v1; + header_parser_v1; using message_type = - message_headers; + header; struct data { @@ -63,11 +63,11 @@ class read_headers_op std::shared_ptr d_; public: - read_headers_op(read_headers_op&&) = default; - read_headers_op(read_headers_op const&) = default; + read_header_op(read_header_op&&) = default; + read_header_op(read_header_op const&) = default; template - read_headers_op( + read_header_op( DeducedHandler&& h, Stream& s, Args&&... args) : d_(std::allocate_shared(alloc_type{h}, std::forward(h), s, @@ -81,7 +81,7 @@ public: friend void* asio_handler_allocate( - std::size_t size, read_headers_op* op) + std::size_t size, read_header_op* op) { return boost_asio_handler_alloc_helpers:: allocate(size, op->d_->h); @@ -89,21 +89,21 @@ public: friend void asio_handler_deallocate( - void* p, std::size_t size, read_headers_op* op) + void* p, std::size_t size, read_header_op* op) { return boost_asio_handler_alloc_helpers:: deallocate(p, size, op->d_->h); } friend - bool asio_handler_is_continuation(read_headers_op* op) + bool asio_handler_is_continuation(read_header_op* op) { return op->d_->cont; } template friend - void asio_handler_invoke(Function&& f, read_headers_op* op) + void asio_handler_invoke(Function&& f, read_header_op* op) { return boost_asio_handler_invoke_helpers:: invoke(f, op->d_->h); @@ -111,10 +111,10 @@ public: }; template void -read_headers_op:: +read_header_op:: operator()(error_code ec, bool again) { auto& d = *d_; @@ -141,10 +141,10 @@ operator()(error_code ec, bool again) } // detail template + bool isRequest, class Fields> void read(SyncReadStream& stream, DynamicBuffer& dynabuf, - message_headers& msg) + header& msg) { static_assert(is_SyncReadStream::value, "SyncReadStream requirements not met"); @@ -157,17 +157,17 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, } template + bool isRequest, class Fields> void read(SyncReadStream& stream, DynamicBuffer& dynabuf, - message_headers& m, + header& m, error_code& ec) { static_assert(is_SyncReadStream::value, "SyncReadStream requirements not met"); static_assert(is_DynamicBuffer::value, "DynamicBuffer requirements not met"); - headers_parser_v1 p; + header_parser_v1 p; beast::http::parse(stream, dynabuf, p, ec); if(ec) return; @@ -176,12 +176,12 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, } template typename async_completion< ReadHandler, void(error_code)>::result_type async_read(AsyncReadStream& stream, DynamicBuffer& dynabuf, - message_headers& m, + header& m, ReadHandler&& handler) { static_assert(is_AsyncReadStream::value, @@ -190,8 +190,8 @@ async_read(AsyncReadStream& stream, DynamicBuffer& dynabuf, "DynamicBuffer requirements not met"); beast::async_completion completion(handler); - detail::read_headers_op{completion.handler, stream, dynabuf, m}; return completion.result.get(); @@ -202,7 +202,7 @@ async_read(AsyncReadStream& stream, DynamicBuffer& dynabuf, namespace detail { template class read_op { @@ -210,10 +210,10 @@ class read_op handler_alloc; using parser_type = - parser_v1; + parser_v1; using message_type = - message; + message; struct data { @@ -289,10 +289,10 @@ public: }; template void -read_op:: +read_op:: operator()(error_code ec, bool again) { auto& d = *d_; @@ -319,10 +319,10 @@ operator()(error_code ec, bool again) } // detail template + bool isRequest, class Body, class Fields> void read(SyncReadStream& stream, DynamicBuffer& dynabuf, - message& msg) + message& msg) { static_assert(is_SyncReadStream::value, "SyncReadStream requirements not met"); @@ -333,7 +333,7 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, static_assert(has_reader::value, "Body has no reader"); static_assert(is_Reader>::value, + message>::value, "Reader requirements not met"); error_code ec; beast::http::read(stream, dynabuf, msg, ec); @@ -342,10 +342,10 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, } template + bool isRequest, class Body, class Fields> void read(SyncReadStream& stream, DynamicBuffer& dynabuf, - message& m, + message& m, error_code& ec) { static_assert(is_SyncReadStream::value, @@ -357,9 +357,9 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, static_assert(has_reader::value, "Body has no reader"); static_assert(is_Reader>::value, + message>::value, "Reader requirements not met"); - parser_v1 p; + parser_v1 p; beast::http::parse(stream, dynabuf, p, ec); if(ec) return; @@ -368,12 +368,12 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, } template typename async_completion< ReadHandler, void(error_code)>::result_type async_read(AsyncReadStream& stream, DynamicBuffer& dynabuf, - message& m, + message& m, ReadHandler&& handler) { static_assert(is_AsyncReadStream::value, @@ -385,12 +385,12 @@ async_read(AsyncReadStream& stream, DynamicBuffer& dynabuf, static_assert(has_reader::value, "Body has no reader"); static_assert(is_Reader>::value, + message>::value, "Reader requirements not met"); beast::async_completion completion(handler); detail::read_op{completion.handler, stream, dynabuf, m}; return completion.result.get(); diff --git a/include/beast/http/impl/write.ipp b/include/beast/http/impl/write.ipp index 44f37c53..e5b83ab2 100644 --- a/include/beast/http/impl/write.ipp +++ b/include/beast/http/impl/write.ipp @@ -32,10 +32,10 @@ namespace http { namespace detail { -template +template void write_start_line(DynamicBuffer& dynabuf, - message_headers const& msg) + header const& msg) { BOOST_ASSERT(msg.version == 10 || msg.version == 11); write(dynabuf, msg.method); @@ -52,10 +52,10 @@ write_start_line(DynamicBuffer& dynabuf, } } -template +template void write_start_line(DynamicBuffer& dynabuf, - message_headers const& msg) + header const& msg) { BOOST_ASSERT(msg.version == 10 || msg.version == 11); switch(msg.version) @@ -205,10 +205,10 @@ operator()(error_code ec, std::size_t, bool again) } // detail template + bool isRequest, class Fields> void write(SyncWriteStream& stream, - message_headers const& msg) + header const& msg) { static_assert(is_SyncWriteStream::value, "SyncWriteStream requirements not met"); @@ -219,28 +219,28 @@ write(SyncWriteStream& stream, } template + bool isRequest, class Fields> void write(SyncWriteStream& stream, - message_headers const& msg, + header const& msg, error_code& ec) { static_assert(is_SyncWriteStream::value, "SyncWriteStream requirements not met"); streambuf sb; detail::write_start_line(sb, msg); - detail::write_fields(sb, msg.headers); + detail::write_fields(sb, msg.fields); beast::write(sb, "\r\n"); boost::asio::write(stream, sb.data(), ec); } template typename async_completion< WriteHandler, void(error_code)>::result_type async_write(AsyncWriteStream& stream, - message_headers const& msg, + header const& msg, WriteHandler&& handler) { static_assert(is_AsyncWriteStream::value, @@ -249,7 +249,7 @@ async_write(AsyncWriteStream& stream, void(error_code)> completion(handler); streambuf sb; detail::write_start_line(sb, msg); - detail::write_fields(sb, msg.headers); + detail::write_fields(sb, msg.fields); beast::write(sb, "\r\n"); detail::write_streambuf_op{ @@ -261,10 +261,10 @@ async_write(AsyncWriteStream& stream, namespace detail { -template +template struct write_preparation { - message const& msg; + message const& msg; typename Body::writer w; streambuf sb; bool chunked; @@ -272,14 +272,14 @@ struct write_preparation explicit write_preparation( - message const& msg_) + message const& msg_) : msg(msg_) , w(msg) , chunked(token_list{ - msg.headers["Transfer-Encoding"]}.exists("chunked")) + msg.fields["Transfer-Encoding"]}.exists("chunked")) , close(token_list{ - msg.headers["Connection"]}.exists("close") || - (msg.version < 11 && ! msg.headers.exists( + msg.fields["Connection"]}.exists("close") || + (msg.version < 11 && ! msg.fields.exists( "Content-Length"))) { } @@ -292,13 +292,13 @@ struct write_preparation return; write_start_line(sb, msg); - write_fields(sb, msg.headers); + write_fields(sb, msg.fields); beast::write(sb, "\r\n"); } }; template + bool isRequest, class Body, class Fields> class write_op { using alloc_type = @@ -309,7 +309,7 @@ class write_op Stream& s; // VFALCO How do we use handler_alloc in write_preparation? write_preparation< - isRequest, Body, Headers> wp; + isRequest, Body, Fields> wp; Handler h; resume_context resume; resume_context copy; @@ -318,7 +318,7 @@ class write_op template data(DeducedHandler&& h_, Stream& s_, - message const& m_) + message const& m_) : s(s_) , wp(m_) , h(std::forward(h_)) @@ -343,7 +343,7 @@ class write_op void operator()(ConstBufferSequence const& buffers) const { auto& d = *self_.d_; - // write headers and body + // write header and body if(d.wp.chunked) boost::asio::async_write(d.s, buffer_cat(d.wp.sb.data(), @@ -451,9 +451,9 @@ public: }; template + bool isRequest, class Body, class Fields> void -write_op:: +write_op:: operator()(error_code ec, std::size_t, bool again) { auto& d = *d_; @@ -502,7 +502,7 @@ operator()(error_code ec, std::size_t, bool again) return; } - // sent headers and body + // sent header and body case 2: d.wp.sb.consume(d.wp.sb.size()); d.state = 3; @@ -578,7 +578,7 @@ public: template void operator()(ConstBufferSequence const& buffers) const { - // write headers and body + // write header and body if(chunked_) boost::asio::write(stream_, buffer_cat( sb_.data(), chunk_encode(false, buffers)), ec_); @@ -619,10 +619,10 @@ public: } // detail template + bool isRequest, class Body, class Fields> void write(SyncWriteStream& stream, - message const& msg) + message const& msg) { static_assert(is_SyncWriteStream::value, "SyncWriteStream requirements not met"); @@ -631,7 +631,7 @@ write(SyncWriteStream& stream, static_assert(has_writer::value, "Body has no writer"); static_assert(is_Writer>::value, + message>::value, "Writer requirements not met"); error_code ec; write(stream, msg, ec); @@ -640,10 +640,10 @@ write(SyncWriteStream& stream, } template + bool isRequest, class Body, class Fields> void write(SyncWriteStream& stream, - message const& msg, + message const& msg, error_code& ec) { static_assert(is_SyncWriteStream::value, @@ -653,9 +653,9 @@ write(SyncWriteStream& stream, static_assert(has_writer::value, "Body has no writer"); static_assert(is_Writer>::value, + message>::value, "Writer requirements not met"); - detail::write_preparation wp(msg); + detail::write_preparation wp(msg); wp.init(ec); if(ec) return; @@ -729,12 +729,12 @@ write(SyncWriteStream& stream, } template typename async_completion< WriteHandler, void(error_code)>::result_type async_write(AsyncWriteStream& stream, - message const& msg, + message const& msg, WriteHandler&& handler) { static_assert(is_AsyncWriteStream::value, @@ -744,21 +744,21 @@ async_write(AsyncWriteStream& stream, static_assert(has_writer::value, "Body has no writer"); static_assert(is_Writer>::value, + message>::value, "Writer requirements not met"); beast::async_completion completion(handler); detail::write_op{completion.handler, stream, msg}; + isRequest, Body, Fields>{completion.handler, stream, msg}; return completion.result.get(); } //------------------------------------------------------------------------------ -template +template std::ostream& operator<<(std::ostream& os, - message_headers const& msg) + header const& msg) { beast::detail::sync_ostream oss{os}; error_code ec; @@ -768,17 +768,17 @@ operator<<(std::ostream& os, return os; } -template +template std::ostream& operator<<(std::ostream& os, - message const& msg) + message const& msg) { static_assert(is_Body::value, "Body requirements not met"); static_assert(has_writer::value, "Body has no writer"); static_assert(is_Writer>::value, + message>::value, "Writer requirements not met"); beast::detail::sync_ostream oss{os}; error_code ec; diff --git a/include/beast/http/message.hpp b/include/beast/http/message.hpp index 8a136abd..ebe17238 100644 --- a/include/beast/http/message.hpp +++ b/include/beast/http/message.hpp @@ -8,7 +8,7 @@ #ifndef BEAST_HTTP_MESSAGE_HPP #define BEAST_HTTP_MESSAGE_HPP -#include +#include #include #include #include @@ -19,27 +19,30 @@ namespace beast { namespace http { #if GENERATING_DOCS -/** A container for HTTP request or response headers. +/** A container for a HTTP request or response header. - The container includes the headers, as well as the - request method and URL. Objects of this type may be - used to represent incoming or outgoing requests for - which the body is not yet known or generated. For - example, when receiving a request with the header value - "Expect: 100-continue". + A header includes the Start Line and Fields. + + Some use-cases: + + @li When the message has no body, such as a response to a HEAD request. + + @li When the caller wishes to defer instantiation of the body. + + @li Invoke algorithms which operate on the header only. */ -template -struct message_headers +template +struct header #else -template -struct message_headers; +template +struct header; -template -struct message_headers +template +struct header #endif { - /// Indicates if the message headers are a request or response. + /// Indicates if the header is a request or response. #if GENERATING_DOCS static bool constexpr is_request = isRequest; @@ -47,8 +50,8 @@ struct message_headers static bool constexpr is_request = true; #endif - /// The type representing the headers. - using headers_type = Headers; + /// The type representing the fields. + using fields_type = Fields; /** The HTTP version. @@ -74,67 +77,71 @@ struct message_headers std::string url; /// The HTTP field values. - Headers headers; + fields_type fields; /// Default constructor - message_headers() = default; + header() = default; /// Move constructor - message_headers(message_headers&&) = default; + header(header&&) = default; /// Copy constructor - message_headers(message_headers const&) = default; + header(header const&) = default; /// Move assignment - message_headers& operator=(message_headers&&) = default; + header& operator=(header&&) = default; /// Copy assignment - message_headers& operator=(message_headers const&) = default; + header& operator=(header const&) = default; - /** Construct message headers. + /** Construct the header. All arguments are forwarded to the constructor - of the `headers` member. + of the `fields` member. @note This constructor participates in overload resolution if and only if the first parameter is not convertible to - `message_headers`. + `header`. */ #if GENERATING_DOCS template explicit - message_headers(Args&&... args); + header(Args&&... args); #else template 0) || ! std::is_convertible< typename std::decay::type, - message_headers>::value>::type> + header>::value>::type> explicit - message_headers(Arg1&& arg1, ArgN&&... argn) - : headers(std::forward(arg1), + header(Arg1&& arg1, ArgN&&... argn) + : fields(std::forward(arg1), std::forward(argn)...) { } }; -/** A container for HTTP request or response headers. +/** A container for a HTTP request or response header. - The container includes the headers, as well as the - response status and reasons. Objects of this type may - be used to represent incoming or outgoing responses for - which the body is not yet known or generated. For - example, when responding to a HEAD request. + A header includes the Start Line and Fields. + + Some use-cases: + + @li When the message has no body, such as a response to a HEAD request. + + @li When the caller wishes to defer instantiation of the body. + + @li Invoke algorithms which operate on the header only. */ -template -struct message_headers +template +struct header { - /// Indicates if the message headers are a request or response. + /// Indicates if the header is a request or response. static bool constexpr is_request = false; - /// The type representing the headers. - using headers_type = Headers; + /// The type representing the fields. + using fields_type = Fields; /** The HTTP version. @@ -148,40 +155,40 @@ struct message_headers int version; /// The HTTP field values. - Headers headers; + fields_type fields; /// Default constructor - message_headers() = default; + header() = default; /// Move constructor - message_headers(message_headers&&) = default; + header(header&&) = default; /// Copy constructor - message_headers(message_headers const&) = default; + header(header const&) = default; /// Move assignment - message_headers& operator=(message_headers&&) = default; + header& operator=(header&&) = default; /// Copy assignment - message_headers& operator=(message_headers const&) = default; + header& operator=(header const&) = default; - /** Construct message headers. + /** Construct the header. All arguments are forwarded to the constructor - of the `headers` member. + of the `fields` member. @note This constructor participates in overload resolution if and only if the first parameter is not convertible to - `message_headers`. + `header`. */ template 0) || ! std::is_convertible< typename std::decay::type, - message_headers>::value>::type> + header>::value>::type> explicit - message_headers(Arg1&& arg1, ArgN&&... argn) - : headers(std::forward(arg1), + header(Arg1&& arg1, ArgN&&... argn) + : fields(std::forward(arg1), std::forward(argn)...) { } @@ -204,9 +211,10 @@ struct message_headers /** A container for a complete HTTP message. - A message can be a request or response, depending on the `isRequest` - template argument value. Requests and responses have different types, - so functions may be overloaded on them if desired. + A message can be a request or response, depending on the + `isRequest` template argument value. Requests and responses + have different types; functions may be overloaded based on + the type if desired. The `Body` template argument type determines the model used to read or write the content body of the message. @@ -217,19 +225,18 @@ struct message_headers @tparam Body A type meeting the requirements of Body. - @tparam Headers The type of container used to hold the + @tparam Fields The type of container used to hold the field value pairs. */ -template -struct message : - message_headers +template +struct message : header { - /// The base class used to hold the request or response headers - using base_type = message_headers; + /// The base class used to hold the header portion of the message. + using base_type = header; /** The type providing the body traits. - The `body` member will be of type `body_type::value_type`. + The @ref message::body member will be of type `body_type::value_type`. */ using body_type = Body; @@ -239,7 +246,7 @@ struct message : /// Default constructor message() = default; - /** Construct a message from message headers. + /** Construct a message from a header. Additional arguments, if any, are forwarded to the constructor of the body member. @@ -252,7 +259,7 @@ struct message : { } - /** Construct a message from message headers. + /** Construct a message from a header. Additional arguments, if any, are forwarded to the constructor of the body member. @@ -288,7 +295,7 @@ struct message : @param u An argument forwarded to the body constructor. - @param v An argument forwarded to the headers constructor. + @param v An argument forwarded to the fields constructor. @note This constructor participates in overload resolution only if `u` is not convertible to `base_type`. @@ -320,7 +327,7 @@ struct message : @param un A tuple forwarded as a parameter pack to the body constructor. - @param vn A tuple forwarded as a parameter pack to the headers constructor. + @param vn A tuple forwarded as a parameter pack to the fields constructor. */ template message(std::piecewise_construct_t, @@ -331,14 +338,14 @@ struct message : { } - /// Returns the message headers portion of the message + /// Returns the header portion of the message base_type& base() { return *this; } - /// Returns the message headers portion of the message + /// Returns the header portion of the message base_type const& base() const { @@ -368,64 +375,60 @@ private: //------------------------------------------------------------------------------ #if GENERATING_DOCS -/** Swap two HTTP message headers. +/** Swap two header objects. @par Requirements - `Headers` is @b Swappable. + `Fields` is @b Swappable. */ -template +template void swap( - message_headers& m1, - message_headers& m2); + header& m1, + header& m2); #endif -/** Swap two HTTP messages. +/** Swap two message objects. @par Requirements: - `Body` and `Headers` are @b Swappable. + `Body::value_type` and `Fields` are @b Swappable. */ -template +template void swap( - message& m1, - message& m2); + message& m1, + message& m2); -/// Message headers for a typical HTTP request -using request_headers = message_headers>>; +/// A typical HTTP request header +using request_header = header; -/// Message headers for a typical HTTP response -using response_headers = message_headers>>; +/// Typical HTTP response header +using response_header = header; -/// A typical HTTP request message -template>> -using request = message; +/// A typical HTTP request +template +using request = message; -/// A typical HTTP response message -template>> -using response = message; +/// A typical HTTP response +template +using response = message; //------------------------------------------------------------------------------ -/** Returns `true` if a HTTP/1 message indicates a keep alive. +/** Returns `true` if the HTTP/1 message indicates a keep alive. Undefined behavior if version is greater than 11. */ -template +template bool -is_keep_alive(message const& msg); +is_keep_alive(header const& msg); -/** Returns `true` if a HTTP/1 message indicates an Upgrade request or response. +/** Returns `true` if the HTTP/1 message indicates an Upgrade request or response. Undefined behavior if version is greater than 11. */ -template +template bool -is_upgrade(message const& msg); +is_upgrade(header const& msg); /** HTTP/1 connection prepare options. @@ -446,18 +449,18 @@ enum class connection /** Prepare a HTTP message. This function will adjust the Content-Length, Transfer-Encoding, - and Connection headers of the message based on the properties of + and Connection fields of the message based on the properties of the body and the options passed in. - @param msg The message to prepare. The headers may be modified. + @param msg The message to prepare. The fields may be modified. @param options A list of prepare options. */ template< - bool isRequest, class Body, class Headers, + bool isRequest, class Body, class Fields, class... Options> void -prepare(message& msg, +prepare(message& msg, Options&&... options); } // http diff --git a/include/beast/http/parse_error.hpp b/include/beast/http/parse_error.hpp index 56f8dc2b..43a66468 100644 --- a/include/beast/http/parse_error.hpp +++ b/include/beast/http/parse_error.hpp @@ -34,7 +34,7 @@ enum class parse_error invalid_ext_name, invalid_ext_val, - headers_too_big, + header_too_big, body_too_big, short_read }; diff --git a/include/beast/http/parser_v1.hpp b/include/beast/http/parser_v1.hpp index 9d013843..fbcd3401 100644 --- a/include/beast/http/parser_v1.hpp +++ b/include/beast/http/parser_v1.hpp @@ -9,7 +9,7 @@ #define BEAST_HTTP_PARSER_V1_HPP #include -#include +#include #include #include #include @@ -33,11 +33,11 @@ namespace http { For example, a 200 response to a CONNECT request from a tunneling proxy. In these cases, callers use the @ref skip_body option to inform the parser that no body is expected. The parser will consider - the message complete after the all headers have been received. + the message complete after the header has been received. Example: @code - parser_v1 p; + parser_v1 p; p.set_option(skip_body{true}); @endcode @@ -61,10 +61,10 @@ struct skip_body @note A new instance of the parser is required for each message. */ -template +template class parser_v1 : public basic_parser_v1> + parser_v1> , private std::conditional::type @@ -72,7 +72,7 @@ class parser_v1 public: /// The type of message this parser produces. using message_type = - message; + message; private: using reader = @@ -113,7 +113,7 @@ public: @param args Forwarded to the message constructor. @note This function participates in overload resolution only - if the first argument is not a parser or headers parser. + if the first argument is not a parser or fields parser. */ #if GENERATING_DOCS template @@ -124,7 +124,7 @@ public: class = typename std::enable_if< ! std::is_same::type, - headers_parser_v1>::value && + header_parser_v1>::value && ! std::is_same::type, parser_v1>::value >::type> @@ -136,20 +136,20 @@ public: } #endif - /** Construct the parser from a headers parser. + /** Construct the parser from a fields parser. - @param parser The headers parser to construct from. + @param parser The fields parser to construct from. @param args Forwarded to the message body constructor. */ template explicit - parser_v1(headers_parser_v1& parser, + parser_v1(header_parser_v1& parser, Args&&... args) : m_(parser.release(), std::forward(args)...) { static_cast>&>(*this) = parser; + isRequest, Body, Fields>>&>(*this) = parser; } /// Set the skip body option. @@ -185,7 +185,7 @@ public: valid if @ref complete would return `true`. Requires: - `message` is @b MoveConstructible + `message` is @b MoveConstructible */ message_type release() @@ -204,7 +204,7 @@ private: return; flush_ = false; BOOST_ASSERT(! field_.empty()); - m_.headers.insert(field_, value_); + m_.fields.insert(field_, value_); field_.clear(); value_.clear(); } @@ -265,7 +265,7 @@ private: } void - on_headers(std::uint64_t, error_code&) + on_header(std::uint64_t, error_code&) { flush(); m_.version = 10 * this->http_major() + this->http_minor(); @@ -291,22 +291,22 @@ private: } }; -/** Create a new parser from a headers parser. +/** Create a new parser from a fields parser. - Associates a Body type with a headers parser, and returns + Associates a Body type with a fields parser, and returns a new parser which parses a complete message object - containing the original message headers and a new body + containing the original message fields and a new body of the specified body type. This function allows HTTP messages to be parsed in two stages. - First, the headers are parsed and control is returned. Then, + First, the fields are parsed and control is returned. Then, the caller can choose at run-time, the type of Body to associate with the message. And finally, complete the parse in a second call. - @param parser The headers parser to construct from. Ownership - of the message headers in the headers parser is transferred - as if by call to @ref headers_parser_v1::release. + @param parser The fields parser to construct from. Ownership + of the message fields in the fields parser is transferred + as if by call to @ref header_parser_v1::release. @param args Forwarded to the body constructor of the message in the new parser. @@ -315,19 +315,20 @@ private: @par Example @code - headers_parser ph; + headers_parser ph; ... auto p = with_body(ph); ... - message m = p.release(); + message m = p.release(); @endcode */ -template -parser_v1 -with_body(headers_parser_v1& parser, +template +parser_v1 +with_body(header_parser_v1& parser, Args&&... args) { - return parser_v1( + return parser_v1( parser, std::forward(args)...); } diff --git a/include/beast/http/read.hpp b/include/beast/http/read.hpp index e5f0bb70..67610e65 100644 --- a/include/beast/http/read.hpp +++ b/include/beast/http/read.hpp @@ -15,22 +15,27 @@ namespace beast { namespace http { -/** Read HTTP/1 message headers from a stream. +/** Read a HTTP/1 header from a stream. - This function is used to synchronously read message headers from - the stream. The call blocks until one of the following conditions - is true: + This function is used to synchronously read a header + from a stream. The call blocks until one of the following + conditions is true: - @li The complete message headers are read in. + @li An entire header is read in. @li An error occurs in the stream or parser. This function is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional octets that lie past the end of the message - headers being parsed. This additional data is stored in the + fields being parsed. This additional data is stored in the stream buffer, which may be used in subsequent calls. + If the message corresponding to the header being received + contains a message body, it is the callers responsibility + to cause the body to be read in before attempting to read + the next message. + @param stream The stream from which the data is to be read. The type must support the @b `SyncReadStream` concept. @@ -40,37 +45,38 @@ namespace http { stream buffer's input sequence will be given to the parser first. - @param msg An object used to store the message headers. - Any contents will be overwritten. The type must support - copy assignment or move assignment. + @param msg An object used to store the header. Any contents + will be overwritten. The type must support copy assignment + or move assignment. @throws system_error Thrown on failure. */ template + bool isRequest, class Fields> void read(SyncReadStream& stream, DynamicBuffer& dynabuf, - message_headers& msg); + header& msg); -/** Read HTTP/1 message headers from a stream. +/** Read a HTTP/1 header from a stream. - This function is used to synchronously read message headers from - the stream. The call blocks until one of the following conditions - is true: + This function is used to synchronously read a header + from a stream. The call blocks until one of the following + conditions is true: - @li The complete message headers are read in. + @li An entire header is read in. @li An error occurs in the stream or parser. This function is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional octets that lie past the end of the message - headers being parsed. This additional data is stored in the + fields being parsed. This additional data is stored in the stream buffer, which may be used in subsequent calls. - If the message being received contains a message body, it - is the callers responsibility to cause the body to be read - in before attempting to read the next message. + If the message corresponding to the header being received + contains a message body, it is the callers responsibility + to cause the body to be read in before attempting to read + the next message. @param stream The stream from which the data is to be read. The type must support the @b `SyncReadStream` concept. @@ -81,40 +87,42 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, stream buffer's input sequence will be given to the parser first. - @param msg An object used to store the message headers. - Any contents will be overwritten. The type must support - copy assignment or move assignment. + @param msg An object used to store the header. Any contents + will be overwritten. The type must support copy assignment + or move assignment. @param ec Set to the error, if any occurred. */ template + bool isRequest, class Fields> void read(SyncReadStream& stream, DynamicBuffer& dynabuf, - message_headers& msg, + header& msg, error_code& ec); -/** Start an asynchronous operation to read HTTP/1 message headers from a stream. +/** Read a HTTP/1 header asynchronously from a stream. - This function is used to asynchronously read a message from the - stream. The function call always returns immediately. The asynchronous - operation will continue until one of the following conditions is true: + This function is used to asynchronously read a header from + a stream. The function call always returns immediately. The + asynchronous operation will continue until one of the following + conditions is true: - @li A complete message is read in. + @li An entire header is read in. @li An error occurs in the stream or parser. This operation is implemented in terms of one or more calls to - the next layer's `async_read_some` function, and is known as a + the stream's `async_read_some` function, and is known as a composed operation. The program must ensure that the stream performs no other operations until this operation completes. The implementation may read additional octets that lie past the - end of the message headers being parsed. This additional data is + end of the message fields being parsed. This additional data is stored in the stream buffer, which may be used in subsequent calls. - If the message being received contains a message body, it - is the callers responsibility to cause the body to be read - in before attempting to read the next message. + If the message corresponding to the header being received + contains a message body, it is the callers responsibility + to cause the body to be read in before attempting to read + the next message. @param stream The stream to read the message from. The type must support the @b `AsyncReadStream` concept. @@ -125,13 +133,14 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, stream buffer's input sequence will be given to the parser first. - @param msg An object used to store the message. Any contents + @param msg An object used to store the header. Any contents will be overwritten. The type must support copy assignment or - move assignment. + move assignment. The object must remain valid at least until + the completion handler is called; ownership is not transferred. - @param handler The handler to be called when the request completes. - Copies will be made of the handler as required. The equivalent - function signature of the handler must be: + @param handler The handler to be called when the operation + completes. Copies will be made of the handler as required. + The equivalent function signature of the handler must be: @code void handler( error_code const& error // result of operation ); @endcode @@ -141,7 +150,7 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, manner equivalent to using `boost::asio::io_service::post`. */ template #if GENERATING_DOCS void_or_deduced @@ -150,13 +159,13 @@ typename async_completion< ReadHandler, void(error_code)>::result_type #endif async_read(AsyncReadStream& stream, DynamicBuffer& dynabuf, - message_headers& msg, + header& msg, ReadHandler&& handler); /** Read a HTTP/1 message from a stream. This function is used to synchronously read a message from - the stream. The call blocks until one of the following conditions + a stream. The call blocks until one of the following conditions is true: @li A complete message is read in. @@ -185,15 +194,15 @@ async_read(AsyncReadStream& stream, DynamicBuffer& dynabuf, @throws system_error Thrown on failure. */ template + bool isRequest, class Body, class Fields> void read(SyncReadStream& stream, DynamicBuffer& dynabuf, - message& msg); + message& msg); /** Read a HTTP/1 message from a stream. This function is used to synchronously read a message from - the stream. The call blocks until one of the following conditions + a stream. The call blocks until one of the following conditions is true: @li A complete message is read in. @@ -222,24 +231,25 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, @param ec Set to the error, if any occurred. */ template + bool isRequest, class Body, class Fields> void read(SyncReadStream& stream, DynamicBuffer& dynabuf, - message& msg, + message& msg, error_code& ec); -/** Start an asynchronous operation to read a HTTP/1 message from a stream. +/** Read a HTTP/1 message asynchronously from a stream. - This function is used to asynchronously read a message from the - stream. The function call always returns immediately. The asynchronous - operation will continue until one of the following conditions is true: + This function is used to asynchronously read a message from + a stream. The function call always returns immediately. The + asynchronous operation will continue until one of the following + conditions is true: @li A complete message is read in. @li An error occurs in the stream or parser. This operation is implemented in terms of one or more calls to - the next layer's `async_read_some` function, and is known as a + the stream's `async_read_some` function, and is known as a composed operation. The program must ensure that the stream performs no other operations until this operation completes. The implementation may read additional octets that lie past the @@ -255,13 +265,14 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, stream buffer's input sequence will be given to the parser first. - @param msg An object used to store the message. Any contents + @param msg An object used to store the header. Any contents will be overwritten. The type must support copy assignment or - move assignment. + move assignment. The object must remain valid at least until + the completion handler is called; ownership is not transferred. - @param handler The handler to be called when the request completes. - Copies will be made of the handler as required. The equivalent - function signature of the handler must be: + @param handler The handler to be called when the operation + completes. Copies will be made of the handler as required. + The equivalent function signature of the handler must be: @code void handler( error_code const& error // result of operation ); @endcode @@ -271,7 +282,7 @@ read(SyncReadStream& stream, DynamicBuffer& dynabuf, manner equivalent to using `boost::asio::io_service::post`. */ template #if GENERATING_DOCS void_or_deduced @@ -280,7 +291,7 @@ typename async_completion< ReadHandler, void(error_code)>::result_type #endif async_read(AsyncReadStream& stream, DynamicBuffer& dynabuf, - message& msg, + message& msg, ReadHandler&& handler); } // http diff --git a/include/beast/http/reason.hpp b/include/beast/http/reason.hpp index ab3b51b7..14b9bf7c 100644 --- a/include/beast/http/reason.hpp +++ b/include/beast/http/reason.hpp @@ -11,7 +11,8 @@ namespace beast { namespace http { -/** Returns the text for a known status code integer. */ +namespace detail { + template char const* reason_string(int status) @@ -66,6 +67,16 @@ reason_string(int status) return ""; } +} // detail + +/** Returns the text for a known status code integer. */ +inline +char const* +reason_string(int status) +{ + return detail::reason_string(status); +} + } // http } // beast diff --git a/include/beast/http/string_body.hpp b/include/beast/http/string_body.hpp index f5445e2f..5b8101c7 100644 --- a/include/beast/http/string_body.hpp +++ b/include/beast/http/string_body.hpp @@ -8,9 +8,12 @@ #ifndef BEAST_HTTP_STRING_BODY_HPP #define BEAST_HTTP_STRING_BODY_HPP -#include +#include +#include +#include #include #include +#include #include #include @@ -35,10 +38,10 @@ private: value_type& s_; public: - template + template explicit reader(message& m) noexcept + string_body, Fields>& m) noexcept : s_(m.body) { } @@ -63,10 +66,10 @@ private: value_type const& body_; public: - template + template explicit writer(message< - isRequest, string_body, Headers> const& msg) noexcept + isRequest, string_body, Fields> const& msg) noexcept : body_(msg.body) { } diff --git a/include/beast/http/write.hpp b/include/beast/http/write.hpp index 15a7bd12..f27937bd 100644 --- a/include/beast/http/write.hpp +++ b/include/beast/http/write.hpp @@ -17,94 +17,98 @@ namespace beast { namespace http { -/** Write HTTP/1 message headers on a stream. +/** Write a HTTP/1 header to a stream. - This function is used to write message headers to a stream. The - call will block until one of the following conditions is true: + This function is used to synchronously write a header to + a stream. The call will block until one of the following + conditions is true: - @li All the message headers are sent. + @li The entire header is written. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. - Regardless of the semantic meaning of the headers (for example, - specifying a zero-length message body and Connection: Close), + Regardless of the semantic meaning of the header (for example, + specifying "Content-Length: 0" and "Connection: close"), this function will not return `boost::asio::error::eof`. @param stream The stream to which the data is to be written. The type must support the @b `SyncWriteStream` concept. - @param msg The message headers to write. + @param msg The header to write. @throws system_error Thrown on failure. */ template + bool isRequest, class Fields> void write(SyncWriteStream& stream, - message_headers const& msg); + header const& msg); -/** Write HTTP/1 message headers on a stream. +/** Write a HTTP/1 header to a stream. - This function is used to write message headers to a stream. The - call will block until one of the following conditions is true: + This function is used to synchronously write a header to + a stream. The call will block until one of the following + conditions is true: - @li All the message headers are sent. + @li The entire header is written. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. - Regardless of the semantic meaning of the headers (for example, - specifying a zero-length message body and Connection: Close), + Regardless of the semantic meaning of the header (for example, + specifying "Content-Length: 0" and "Connection: close"), this function will not return `boost::asio::error::eof`. @param stream The stream to which the data is to be written. The type must support the @b `SyncWriteStream` concept. - @param msg The message headers to write. + @param msg The header to write. @param ec Set to the error, if any occurred. */ template + bool isRequest, class Fields> void write(SyncWriteStream& stream, - message_headers const& msg, + header const& msg, error_code& ec); -/** Start an asynchronous operation to write HTTP/1 message headers to a stream. +/** Write a HTTP/1 header asynchronously to a stream. - This function is used to asynchronously write message headers to a stream. - The function call always returns immediately. The asynchronous - operation will continue until one of the following conditions is true: + This function is used to asynchronously write a header to + a stream. The function call always returns immediately. The + asynchronous operation will continue until one of the following + conditions is true: - @li The entire message headers are sent. + @li The entire header is written. @li An error occurs. - This operation is implemented in terms of one or more calls to the - stream's `async_write_some` functions, and is known as a composed - operation. The program must ensure that the stream performs no - other write operations (such as @ref async_write, the stream's - `async_write_some` function, or any other composed operations that - perform writes) until this operation completes. + This operation is implemented in terms of one or more calls to + the stream's `async_write_some` functions, and is known as a + composed operation. The program must ensure that the + stream performs no other write operations until this operation + completes. - Regardless of the semantic meaning of the headers (for example, - specifying a zero-length message body and Connection: Close), - the handler will not be called with `boost::asio::error::eof`. + Regardless of the semantic meaning of the header (for example, + specifying "Content-Length: 0" and "Connection: close"), + this function will not return `boost::asio::error::eof`. @param stream The stream to which the data is to be written. The type must support the @b `AsyncWriteStream` concept. - @param msg The message headers to send. + @param msg The header to write. The object must remain valid + at least until the completion handler is called; ownership is + not transferred. - @param handler The handler to be called when the request completes. - Copies will be made of the handler as required. The equivalent - function signature of the handler must be: + @param handler The handler to be called when the operation + completes. Copies will be made of the handler as required. + The equivalent function signature of the handler must be: @code void handler( error_code const& error // result of operation ); @endcode @@ -112,12 +116,9 @@ write(SyncWriteStream& stream, immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `boost::asio::io_service::post`. - - @note The message object must remain valid at least until the - completion handler is called, no copies are made. */ template #if GENERATING_DOCS void_or_deduced @@ -126,17 +127,17 @@ typename async_completion< WriteHandler, void(error_code)>::result_type #endif async_write(AsyncWriteStream& stream, - message_headers const& msg, + header const& msg, WriteHandler&& handler); //------------------------------------------------------------------------------ -/** Write a HTTP/1 message on a stream. +/** Write a HTTP/1 message to a stream. This function is used to write a message to a stream. The call will block until one of the following conditions is true: - @li The entire message is sent. + @li The entire message is written. @li An error occurs. @@ -157,17 +158,17 @@ async_write(AsyncWriteStream& stream, @throws system_error Thrown on failure. */ template + bool isRequest, class Body, class Fields> void write(SyncWriteStream& stream, - message const& msg); + message const& msg); /** Write a HTTP/1 message on a stream. This function is used to write a message to a stream. The call will block until one of the following conditions is true: - @li The entire message is sent. + @li The entire message is written. @li An error occurs. @@ -188,28 +189,28 @@ write(SyncWriteStream& stream, @param ec Set to the error, if any occurred. */ template + bool isRequest, class Body, class Fields> void write(SyncWriteStream& stream, - message const& msg, + message const& msg, error_code& ec); -/** Start an asynchronous operation to write a HTTP/1 message to a stream. +/** Write a HTTP/1 message asynchronously to a stream. - This function is used to asynchronously write a message to a stream. - The function call always returns immediately. The asynchronous - operation will continue until one of the following conditions is true: + This function is used to asynchronously write a message to + a stream. The function call always returns immediately. The + asynchronous operation will continue until one of the following + conditions is true: - @li The entire message is sent. + @li The entire message is written. @li An error occurs. - This operation is implemented in terms of one or more calls to the - stream's `async_write_some` functions, and is known as a composed - operation. The program must ensure that the stream performs no - other write operations (such as @ref async_write, the stream's - `async_write_some` function, or any other composed operations that - perform writes) until this operation completes. + This operation is implemented in terms of one or more calls to + the stream's `async_write_some` functions, and is known as a + composed operation. The program must ensure that the + stream performs no other write operations until this operation + completes. The implementation will automatically perform chunk encoding if the contents of the message indicate that chunk encoding is required. @@ -220,11 +221,13 @@ write(SyncWriteStream& stream, @param stream The stream to which the data is to be written. The type must support the @b `AsyncWriteStream` concept. - @param msg The message to send. + @param msg The message to write. The object must remain valid + at least until the completion handler is called; ownership is + not transferred. - @param handler The handler to be called when the request completes. - Copies will be made of the handler as required. The equivalent - function signature of the handler must be: + @param handler The handler to be called when the operation + completes. Copies will be made of the handler as required. + The equivalent function signature of the handler must be: @code void handler( error_code const& error // result of operation ); @endcode @@ -232,12 +235,9 @@ write(SyncWriteStream& stream, immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `boost::asio::io_service::post`. - - @note The message object must remain valid at least until the - completion handler is called, no copies are made. */ template #if GENERATING_DOCS void_or_deduced @@ -246,25 +246,24 @@ typename async_completion< WriteHandler, void(error_code)>::result_type #endif async_write(AsyncWriteStream& stream, - message const& msg, + message const& msg, WriteHandler&& handler); //------------------------------------------------------------------------------ -/** Serialize HTTP/1 message headers to a `std::ostream`. +/** Serialize a HTTP/1 header to a `std::ostream`. - The function converts the message headers to its HTTP/1 - serialized representation and stores the result in the output - stream. + The function converts the header to its HTTP/1 serialized + representation and stores the result in the output stream. @param os The output stream to write to. - @param msg The message headers to write. + @param msg The message fields to write. */ -template +template std::ostream& operator<<(std::ostream& os, - message_headers const& msg); + header const& msg); /** Serialize a HTTP/1 message to a `std::ostream`. @@ -278,10 +277,10 @@ operator<<(std::ostream& os, @param msg The message to write. */ -template +template std::ostream& operator<<(std::ostream& os, - message const& msg); + message const& msg); } // http } // beast diff --git a/include/beast/websocket/detail/decorator.hpp b/include/beast/websocket/detail/decorator.hpp index 4bf1a54a..1250d35b 100644 --- a/include/beast/websocket/detail/decorator.hpp +++ b/include/beast/websocket/detail/decorator.hpp @@ -102,7 +102,7 @@ private: void operator()(request_type& req, std::false_type) { - req.headers.replace("User-Agent", + req.fields.replace("User-Agent", std::string{"Beast/"} + BEAST_VERSION_STRING); } @@ -115,7 +115,7 @@ private: void operator()(response_type& res, std::false_type) { - res.headers.replace("Server", + res.fields.replace("Server", std::string{"Beast/"} + BEAST_VERSION_STRING); } }; diff --git a/include/beast/websocket/impl/accept.ipp b/include/beast/websocket/impl/accept.ipp index 99b7d2f8..1ce54d32 100644 --- a/include/beast/websocket/impl/accept.ipp +++ b/include/beast/websocket/impl/accept.ipp @@ -43,9 +43,9 @@ class stream::response_op int state = 0; template + class Body, class Fields> data(DeducedHandler&& h_, stream& ws_, - http::request const& req, + http::request const& req, bool cont_) : ws(ws_) , resp(ws_.build_response(req)) @@ -305,11 +305,11 @@ async_accept(ConstBufferSequence const& bs, AcceptHandler&& handler) } template -template +template typename async_completion< AcceptHandler, void(error_code)>::result_type stream:: -async_accept(http::request const& req, +async_accept(http::request const& req, AcceptHandler&& handler) { static_assert(is_AsyncStream::value, @@ -390,10 +390,10 @@ accept(ConstBufferSequence const& buffers, error_code& ec) } template -template +template void stream:: -accept(http::request const& request) +accept(http::request const& request) { static_assert(is_SyncStream::value, "SyncStream requirements not met"); @@ -404,10 +404,10 @@ accept(http::request const& request) } template -template +template void stream:: -accept(http::request const& req, +accept(http::request const& req, error_code& ec) { static_assert(is_SyncStream::value, diff --git a/include/beast/websocket/impl/stream.ipp b/include/beast/websocket/impl/stream.ipp index 671dfd9c..bd04db45 100644 --- a/include/beast/websocket/impl/stream.ipp +++ b/include/beast/websocket/impl/stream.ipp @@ -66,21 +66,21 @@ build_request(boost::string_ref const& host, req.url = { resource.data(), resource.size() }; req.version = 11; req.method = "GET"; - req.headers.insert("Host", host); - req.headers.insert("Upgrade", "websocket"); + req.fields.insert("Host", host); + req.fields.insert("Upgrade", "websocket"); key = detail::make_sec_ws_key(maskgen_); - req.headers.insert("Sec-WebSocket-Key", key); - req.headers.insert("Sec-WebSocket-Version", "13"); + req.fields.insert("Sec-WebSocket-Key", key); + req.fields.insert("Sec-WebSocket-Version", "13"); (*d_)(req); http::prepare(req, http::connection::upgrade); return req; } template -template +template http::response stream:: -build_response(http::request const& req) +build_response(http::request const& req) { auto err = [&](std::string const& text) @@ -103,15 +103,15 @@ build_response(http::request const& req) return err("Wrong method"); if(! is_upgrade(req)) return err("Expected Upgrade request"); - if(! req.headers.exists("Host")) + if(! req.fields.exists("Host")) return err("Missing Host"); - if(! req.headers.exists("Sec-WebSocket-Key")) + if(! req.fields.exists("Sec-WebSocket-Key")) return err("Missing Sec-WebSocket-Key"); - if(! http::token_list{req.headers["Upgrade"]}.exists("websocket")) + if(! http::token_list{req.fields["Upgrade"]}.exists("websocket")) return err("Missing websocket Upgrade token"); { auto const version = - req.headers["Sec-WebSocket-Version"]; + req.fields["Sec-WebSocket-Version"]; if(version.empty()) return err("Missing Sec-WebSocket-Version"); if(version != "13") @@ -120,7 +120,7 @@ build_response(http::request const& req) res.status = 426; res.reason = http::reason_string(res.status); res.version = req.version; - res.headers.insert("Sec-WebSocket-Version", "13"); + res.fields.insert("Sec-WebSocket-Version", "13"); prepare(res, (is_keep_alive(req) && keep_alive_) ? http::connection::keep_alive : @@ -132,24 +132,24 @@ build_response(http::request const& req) res.status = 101; res.reason = http::reason_string(res.status); res.version = req.version; - res.headers.insert("Upgrade", "websocket"); + res.fields.insert("Upgrade", "websocket"); { auto const key = - req.headers["Sec-WebSocket-Key"]; - res.headers.insert("Sec-WebSocket-Accept", + req.fields["Sec-WebSocket-Key"]; + res.fields.insert("Sec-WebSocket-Accept", detail::make_sec_ws_accept(key)); } - res.headers.replace("Server", "Beast.WSProto"); + res.fields.replace("Server", "Beast.WSProto"); (*d_)(res); http::prepare(res, http::connection::upgrade); return res; } template -template +template void stream:: -do_response(http::response const& res, +do_response(http::response const& res, boost::string_ref const& key, error_code& ec) { // VFALCO Review these error codes @@ -160,11 +160,11 @@ do_response(http::response const& res, return fail(); if(! is_upgrade(res)) return fail(); - if(! http::token_list{res.headers["Upgrade"]}.exists("websocket")) + if(! http::token_list{res.fields["Upgrade"]}.exists("websocket")) return fail(); - if(! res.headers.exists("Sec-WebSocket-Accept")) + if(! res.fields.exists("Sec-WebSocket-Accept")) return fail(); - if(res.headers["Sec-WebSocket-Accept"] != + if(res.fields["Sec-WebSocket-Accept"] != detail::make_sec_ws_accept(key)) return fail(); open(detail::role_type::client); diff --git a/include/beast/websocket/option.hpp b/include/beast/websocket/option.hpp index 127aa158..d2864cdd 100644 --- a/include/beast/websocket/option.hpp +++ b/include/beast/websocket/option.hpp @@ -86,14 +86,14 @@ struct auto_fragment @code struct identity { - template + template void - operator()(http::message& m) + operator()(http::message& m) { if(isRequest) - m.headers.replace("User-Agent", "MyClient"); + m.fields.replace("User-Agent", "MyClient"); else - m.headers.replace("Server", "MyServer"); + m.fields.replace("Server", "MyServer"); } }; ... @@ -284,7 +284,7 @@ struct read_buffer_size /** Maximum incoming message size option. Sets the largest permissible incoming message size. Message - frame headers indicating a size that would bring the total + frame fields indicating a size that would bring the total message size over this limit will cause a protocol failure. The default setting is 16 megabytes. A value of zero indicates diff --git a/include/beast/websocket/stream.hpp b/include/beast/websocket/stream.hpp index a5bedaf3..23c9e344 100644 --- a/include/beast/websocket/stream.hpp +++ b/include/beast/websocket/stream.hpp @@ -583,9 +583,9 @@ public: @throws system_error Thrown on failure. */ // VFALCO TODO This should also take a DynamicBuffer with any leftover bytes. - template + template void - accept(http::request const& request); + accept(http::request const& request); /** Respond to a WebSocket HTTP Upgrade request @@ -615,9 +615,9 @@ public: @param ec Set to indicate what error occurred, if any. */ - template + template void - accept(http::request const& request, + accept(http::request const& request, error_code& ec); /** Start responding to a WebSocket HTTP Upgrade request. @@ -661,14 +661,14 @@ public: this function. Invocation of the handler will be performed in a manner equivalent to using `boost::asio::io_service::post`. */ - template + template #if GENERATING_DOCS void_or_deduced #else typename async_completion< AcceptHandler, void(error_code)>::result_type #endif - async_accept(http::request const& request, + async_accept(http::request const& request, AcceptHandler&& handler); /** Send a HTTP WebSocket Upgrade request and receive the response. @@ -1627,13 +1627,13 @@ private: boost::string_ref const& resource, std::string& key); - template + template http::response - build_response(http::request const& req); + build_response(http::request const& req); - template + template void - do_response(http::response const& resp, + do_response(http::response const& resp, boost::string_ref const& key, error_code& ec); void diff --git a/test/Jamfile b/test/Jamfile index 41ba85e2..331a8ade 100644 --- a/test/Jamfile +++ b/test/Jamfile @@ -43,13 +43,12 @@ unit-test core-tests : unit-test http-tests : ../extras/beast/unit_test/main.cpp http/basic_dynabuf_body.cpp - http/basic_headers.cpp + http/basic_fields.cpp http/basic_parser_v1.cpp - http/body_type.cpp http/concepts.cpp http/empty_body.cpp - http/headers.cpp - http/headers_parser_v1.cpp + http/fields.cpp + http/header_parser_v1.cpp http/message.cpp http/parse.cpp http/parse_error.cpp diff --git a/test/http/CMakeLists.txt b/test/http/CMakeLists.txt index 03647196..a01c92cb 100644 --- a/test/http/CMakeLists.txt +++ b/test/http/CMakeLists.txt @@ -11,13 +11,12 @@ add_executable (http-tests fail_parser.hpp ../../extras/beast/unit_test/main.cpp basic_dynabuf_body.cpp - basic_headers.cpp + basic_fields.cpp basic_parser_v1.cpp - body_type.cpp concepts.cpp empty_body.cpp - headers.cpp - headers_parser_v1.cpp + fields.cpp + header_parser_v1.cpp message.cpp parse.cpp parse_error.cpp diff --git a/test/http/basic_headers.cpp b/test/http/basic_fields.cpp similarity index 86% rename from test/http/basic_headers.cpp rename to test/http/basic_fields.cpp index 25b55a59..622d2f78 100644 --- a/test/http/basic_headers.cpp +++ b/test/http/basic_fields.cpp @@ -6,7 +6,7 @@ // // Test that header file is self-contained. -#include +#include #include #include @@ -14,18 +14,18 @@ namespace beast { namespace http { -class basic_headers_test : public beast::unit_test::suite +class basic_fields_test : public beast::unit_test::suite { public: template - using bha = basic_headers; + using bha = basic_fields; - using bh = basic_headers>; + using bh = basic_fields>; template static void - fill(std::size_t n, basic_headers& h) + fill(std::size_t n, basic_fields& h) { for(std::size_t i = 1; i<= n; ++i) h.insert(boost::lexical_cast(i), i); @@ -90,7 +90,7 @@ public: } }; -BEAST_DEFINE_TESTSUITE(basic_headers,http,beast); +BEAST_DEFINE_TESTSUITE(basic_fields,http,beast); } // http } // beast diff --git a/test/http/basic_parser_v1.cpp b/test/http/basic_parser_v1.cpp index 54214aba..5cbe1c19 100644 --- a/test/http/basic_parser_v1.cpp +++ b/test/http/basic_parser_v1.cpp @@ -51,7 +51,7 @@ public: bool start = false; bool field = false; bool value = false; - bool headers = false; + bool fields = false; bool _body_what = false; bool body = false; bool complete = false; @@ -92,9 +92,9 @@ public: value = true; } void - on_headers(std::uint64_t, error_code&) + on_header(std::uint64_t, error_code&) { - headers = true; + fields = true; } body_what on_body_what(std::uint64_t, error_code&) @@ -135,7 +135,7 @@ public: BEAST_EXPECT(p.request); BEAST_EXPECT(p.field); BEAST_EXPECT(p.value); - BEAST_EXPECT(p.headers); + BEAST_EXPECT(p.fields); BEAST_EXPECT(p._body_what); BEAST_EXPECT(p.body); BEAST_EXPECT(p.complete); @@ -158,7 +158,7 @@ public: BEAST_EXPECT(p.response); BEAST_EXPECT(p.field); BEAST_EXPECT(p.value); - BEAST_EXPECT(p.headers); + BEAST_EXPECT(p.fields); BEAST_EXPECT(p.body); BEAST_EXPECT(p.complete); } @@ -1104,7 +1104,7 @@ public: { test::fail_counter fc(1000); fail_parser p(fc); - p.set_option(headers_max_size{n}); + p.set_option(header_max_size{n}); error_code ec; p.write(buf( "GET / HTTP/1.1\r\n" @@ -1113,7 +1113,7 @@ public: ), ec); if(! ec) break; - BEAST_EXPECT(ec == parse_error::headers_too_big); + BEAST_EXPECT(ec == parse_error::header_too_big); } BEAST_EXPECT(n < Limit); } @@ -1122,7 +1122,7 @@ public: { test::fail_counter fc(1000); fail_parser p(fc); - p.set_option(headers_max_size{n}); + p.set_option(header_max_size{n}); error_code ec; p.write(buf( "HTTP/1.1 200 OK\r\n" @@ -1133,7 +1133,7 @@ public: ), ec); if(! ec) break; - BEAST_EXPECT(ec == parse_error::headers_too_big); + BEAST_EXPECT(ec == parse_error::header_too_big); } BEAST_EXPECT(n < Limit); } diff --git a/test/http/body_type.cpp b/test/http/body_type.cpp deleted file mode 100644 index cfddca65..00000000 --- a/test/http/body_type.cpp +++ /dev/null @@ -1,9 +0,0 @@ -// -// Copyright (c) 2013-2016 Vinnie Falco (vinnie dot falco at gmail dot com) -// -// Distributed under the Boost Software License, Version 1.0. (See accompanying -// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -// - -// Test that header file is self-contained. -#include diff --git a/test/http/fail_parser.hpp b/test/http/fail_parser.hpp index 46a228ce..3cb04960 100644 --- a/test/http/fail_parser.hpp +++ b/test/http/fail_parser.hpp @@ -86,7 +86,7 @@ public: } void - on_headers(std::uint64_t content_length, error_code& ec) + on_header(std::uint64_t content_length, error_code& ec) { if(fc_.fail(ec)) return; diff --git a/test/http/headers.cpp b/test/http/fields.cpp similarity index 89% rename from test/http/headers.cpp rename to test/http/fields.cpp index 79d68ffb..4a0f5fa8 100644 --- a/test/http/headers.cpp +++ b/test/http/fields.cpp @@ -6,4 +6,4 @@ // // Test that header file is self-contained. -#include +#include diff --git a/test/http/headers_parser_v1.cpp b/test/http/header_parser_v1.cpp similarity index 85% rename from test/http/headers_parser_v1.cpp rename to test/http/header_parser_v1.cpp index e15997dd..61a35c2b 100644 --- a/test/http/headers_parser_v1.cpp +++ b/test/http/header_parser_v1.cpp @@ -6,23 +6,23 @@ // // Test that header file is self-contained. -#include +#include -#include +#include #include #include namespace beast { namespace http { -class headers_parser_v1_test : public beast::unit_test::suite +class header_parser_v1_test : public beast::unit_test::suite { public: void testParser() { { error_code ec; - headers_parser_v1 p; + header_parser_v1 p; BEAST_EXPECT(! p.complete()); auto const n = p.write(boost::asio::buffer( "GET / HTTP/1.1\r\n" @@ -35,7 +35,7 @@ public: } { error_code ec; - headers_parser_v1 p; + header_parser_v1 p; BEAST_EXPECT(! p.complete()); auto const n = p.write(boost::asio::buffer( "GET / HTTP/1.1\r\n" @@ -50,7 +50,7 @@ public: } { error_code ec; - headers_parser_v1 p; + header_parser_v1 p; BEAST_EXPECT(! p.complete()); auto const n = p.write(boost::asio::buffer( "HTTP/1.1 200 OK\r\n" @@ -63,7 +63,7 @@ public: } { error_code ec; - headers_parser_v1 p; + header_parser_v1 p; BEAST_EXPECT(! p.complete()); auto const n = p.write(boost::asio::buffer( "HTTP/1.1 200 OK\r\n" @@ -84,7 +84,7 @@ public: } }; -BEAST_DEFINE_TESTSUITE(headers_parser_v1,http,beast); +BEAST_DEFINE_TESTSUITE(header_parser_v1,http,beast); } // http } // beast diff --git a/test/http/message.cpp b/test/http/message.cpp index e01ad2e5..d5db86e0 100644 --- a/test/http/message.cpp +++ b/test/http/message.cpp @@ -9,7 +9,7 @@ #include #include -#include +#include #include #include #include @@ -73,66 +73,66 @@ public: void testMessage() { static_assert(std::is_constructible< - message>::value, ""); + message>::value, ""); static_assert(std::is_constructible< - message, Arg1>::value, ""); + message, Arg1>::value, ""); static_assert(std::is_constructible< - message, Arg1 const>::value, ""); + message, Arg1 const>::value, ""); static_assert(std::is_constructible< - message, Arg1 const&>::value, ""); + message, Arg1 const&>::value, ""); static_assert(std::is_constructible< - message, Arg1&&>::value, ""); + message, Arg1&&>::value, ""); static_assert(! std::is_constructible< - message>::value, ""); + message>::value, ""); static_assert(std::is_constructible< - message, - Arg1, headers::allocator_type>::value, ""); + message, + Arg1, fields::allocator_type>::value, ""); static_assert(std::is_constructible< - message, std::piecewise_construct_t, + message, std::piecewise_construct_t, std::tuple>::value, ""); static_assert(std::is_constructible< - message, std::piecewise_construct_t, + message, std::piecewise_construct_t, std::tuple>::value, ""); static_assert(std::is_constructible< - message, std::piecewise_construct_t, - std::tuple, std::tuple>::value, ""); + message, std::piecewise_construct_t, + std::tuple, std::tuple>::value, ""); { Arg1 arg1; - message{std::move(arg1)}; + message{std::move(arg1)}; BEAST_EXPECT(arg1.moved); } { - headers h; + fields h; h.insert("User-Agent", "test"); - message m{Arg1{}, h}; + message m{Arg1{}, h}; BEAST_EXPECT(h["User-Agent"] == "test"); - BEAST_EXPECT(m.headers["User-Agent"] == "test"); + BEAST_EXPECT(m.fields["User-Agent"] == "test"); } { - headers h; + fields h; h.insert("User-Agent", "test"); - message m{Arg1{}, std::move(h)}; + message m{Arg1{}, std::move(h)}; BEAST_EXPECT(! h.exists("User-Agent")); - BEAST_EXPECT(m.headers["User-Agent"] == "test"); + BEAST_EXPECT(m.fields["User-Agent"] == "test"); } // swap - message m1; - message m2; + message m1; + message m2; m1.url = "u"; m1.body = "1"; - m1.headers.insert("h", "v"); + m1.fields.insert("h", "v"); m2.method = "G"; m2.body = "2"; swap(m1, m2); @@ -142,8 +142,8 @@ public: BEAST_EXPECT(m2.url == "u"); BEAST_EXPECT(m1.body == "2"); BEAST_EXPECT(m2.body == "1"); - BEAST_EXPECT(! m1.headers.exists("h")); - BEAST_EXPECT(m2.headers.exists("h")); + BEAST_EXPECT(! m1.fields.exists("h")); + BEAST_EXPECT(m2.fields.exists("h")); } struct MoveHeaders @@ -168,13 +168,13 @@ public: void testHeaders() { { - using req_type = request_headers; + using req_type = request_header; static_assert(std::is_copy_constructible::value, ""); static_assert(std::is_move_constructible::value, ""); static_assert(std::is_copy_assignable::value, ""); static_assert(std::is_move_assignable::value, ""); - using res_type = response_headers; + using res_type = response_header; static_assert(std::is_copy_constructible::value, ""); static_assert(std::is_move_constructible::value, ""); static_assert(std::is_copy_assignable::value, ""); @@ -183,12 +183,12 @@ public: { MoveHeaders h; - message_headers r{std::move(h)}; + header r{std::move(h)}; BEAST_EXPECT(h.moved_from); - BEAST_EXPECT(r.headers.moved_to); + BEAST_EXPECT(r.fields.moved_to); request m{std::move(r)}; - BEAST_EXPECT(r.headers.moved_from); - BEAST_EXPECT(m.headers.moved_to); + BEAST_EXPECT(r.fields.moved_from); + BEAST_EXPECT(m.fields.moved_to); } } @@ -199,12 +199,12 @@ public: m.method = "GET"; m.url = "/"; m.version = 11; - m.headers.insert("Upgrade", "test"); + m.fields.insert("Upgrade", "test"); BEAST_EXPECT(! is_upgrade(m)); prepare(m, connection::upgrade); BEAST_EXPECT(is_upgrade(m)); - BEAST_EXPECT(m.headers["Connection"] == "upgrade"); + BEAST_EXPECT(m.fields["Connection"] == "upgrade"); m.version = 10; BEAST_EXPECT(! is_upgrade(m)); @@ -216,7 +216,7 @@ public: request m; m.version = 10; BEAST_EXPECT(! is_upgrade(m)); - m.headers.insert("Transfer-Encoding", "chunked"); + m.fields.insert("Transfer-Encoding", "chunked"); try { prepare(m); @@ -225,8 +225,8 @@ public: catch(std::exception const&) { } - m.headers.erase("Transfer-Encoding"); - m.headers.insert("Content-Length", "0"); + m.fields.erase("Transfer-Encoding"); + m.fields.insert("Content-Length", "0"); try { prepare(m); @@ -236,8 +236,8 @@ public: { pass(); } - m.headers.erase("Content-Length"); - m.headers.insert("Connection", "keep-alive"); + m.fields.erase("Content-Length"); + m.fields.insert("Connection", "keep-alive"); try { prepare(m); @@ -248,19 +248,19 @@ public: pass(); } m.version = 11; - m.headers.erase("Connection"); - m.headers.insert("Connection", "close"); + m.fields.erase("Connection"); + m.fields.insert("Connection", "close"); BEAST_EXPECT(! is_keep_alive(m)); } void testSwap() { - message m1; - message m2; + message m1; + message m2; m1.status = 200; m1.version = 10; m1.body = "1"; - m1.headers.insert("h", "v"); + m1.fields.insert("h", "v"); m2.status = 404; m2.reason = "OK"; m2.body = "2"; @@ -274,8 +274,8 @@ public: BEAST_EXPECT(m2.version == 10); BEAST_EXPECT(m1.body == "2"); BEAST_EXPECT(m2.body == "1"); - BEAST_EXPECT(! m1.headers.exists("h")); - BEAST_EXPECT(m2.headers.exists("h")); + BEAST_EXPECT(! m1.fields.exists("h")); + BEAST_EXPECT(m2.fields.exists("h")); } void run() override diff --git a/test/http/message_fuzz.hpp b/test/http/message_fuzz.hpp index 2e0287fb..d76ebedc 100644 --- a/test/http/message_fuzz.hpp +++ b/test/http/message_fuzz.hpp @@ -475,7 +475,7 @@ public: template void - headers(DynamicBuffer& db) + fields(DynamicBuffer& db) { while(rand(6)) { @@ -536,7 +536,7 @@ public: request(DynamicBuffer& db) { write(db, method(), " ", uri(), " HTTP/1.1\r\n"); - headers(db); + fields(db); body(db); } @@ -549,7 +549,7 @@ public: write(db, " ", 100 + rand(401), " "); write(db, token()); write(db, "\r\n"); - headers(db); + fields(db); body(db); write(db, "\r\n"); } diff --git a/test/http/nodejs_parser.hpp b/test/http/nodejs_parser.hpp index 3dd98ad6..a9611e55 100644 --- a/test/http/nodejs_parser.hpp +++ b/test/http/nodejs_parser.hpp @@ -736,12 +736,12 @@ nodejs_basic_parser::cb_chunk_complete(http_parser*) The parser may only be used once. */ -template +template class nodejs_parser - : public nodejs_basic_parser> + : public nodejs_basic_parser> { using message_type = - message; + message; message_type m_; typename message_type::body_type::reader r_; @@ -781,7 +781,7 @@ private: void on_field(std::string const& field, std::string const& value) { - m_.headers.insert(field, value); + m_.fields.insert(field, value); } void diff --git a/test/http/parse_error.cpp b/test/http/parse_error.cpp index ac8c95ca..626c8e50 100644 --- a/test/http/parse_error.cpp +++ b/test/http/parse_error.cpp @@ -48,7 +48,7 @@ public: check("http", parse_error::invalid_chunk_size); check("http", parse_error::invalid_ext_name); check("http", parse_error::invalid_ext_val); - check("http", parse_error::headers_too_big); + check("http", parse_error::header_too_big); check("http", parse_error::body_too_big); check("http", parse_error::short_read); } diff --git a/test/http/parser_bench.cpp b/test/http/parser_bench.cpp index c1840069..a51d4822 100644 --- a/test/http/parser_bench.cpp +++ b/test/http/parser_bench.cpp @@ -122,20 +122,20 @@ public: [&] { testParser>( + true, streambuf_body, fields>>( Repeat, creq_); testParser>( + false, streambuf_body, fields>>( Repeat, cres_); }); timedTest(Trials, "http::basic_parser_v1", [&] { testParser>( + true, streambuf_body, fields>>( Repeat, creq_); testParser>( + false, streambuf_body, fields>>( Repeat, cres_); }); pass(); diff --git a/test/http/parser_v1.cpp b/test/http/parser_v1.cpp index 02075d86..d9e5259e 100644 --- a/test/http/parser_v1.cpp +++ b/test/http/parser_v1.cpp @@ -9,8 +9,8 @@ #include #include -#include -#include +#include +#include #include #include #include @@ -32,7 +32,7 @@ public: // consecutive empty header values { error_code ec; - parser_v1 p; + parser_v1 p; std::string const s = "GET / HTTP/1.1\r\n" "X1:\r\n" @@ -44,12 +44,12 @@ public: return; BEAST_EXPECT(p.complete()); auto const msg = p.release(); - BEAST_EXPECT(msg.headers.exists("X1")); - BEAST_EXPECT(msg.headers["X1"] == ""); - BEAST_EXPECT(msg.headers.exists("X2")); - BEAST_EXPECT(msg.headers["X2"] == ""); - BEAST_EXPECT(msg.headers.exists("X3")); - BEAST_EXPECT(msg.headers["X3"] == "x"); + BEAST_EXPECT(msg.fields.exists("X1")); + BEAST_EXPECT(msg.fields["X1"] == ""); + BEAST_EXPECT(msg.fields.exists("X2")); + BEAST_EXPECT(msg.fields["X2"] == ""); + BEAST_EXPECT(msg.fields.exists("X3")); + BEAST_EXPECT(msg.fields["X3"] == "x"); } } @@ -62,23 +62,23 @@ public: "\r\n" "*"}; streambuf rb; - headers_parser_v1 p0; + header_parser_v1 p0; parse(ss, rb, p0); - request_headers const& reqh = p0.get(); + request_header const& reqh = p0.get(); BEAST_EXPECT(reqh.method == "GET"); BEAST_EXPECT(reqh.url == "/"); BEAST_EXPECT(reqh.version == 11); - BEAST_EXPECT(reqh.headers["User-Agent"] == "test"); - BEAST_EXPECT(reqh.headers["Content-Length"] == "1"); - parser_v1 p = + BEAST_EXPECT(reqh.fields["User-Agent"] == "test"); + BEAST_EXPECT(reqh.fields["Content-Length"] == "1"); + parser_v1 p = with_body(p0); BEAST_EXPECT(p.get().method == "GET"); BEAST_EXPECT(p.get().url == "/"); BEAST_EXPECT(p.get().version == 11); - BEAST_EXPECT(p.get().headers["User-Agent"] == "test"); - BEAST_EXPECT(p.get().headers["Content-Length"] == "1"); + BEAST_EXPECT(p.get().fields["User-Agent"] == "test"); + BEAST_EXPECT(p.get().fields["Content-Length"] == "1"); parse(ss, rb, p); - request req = p.release(); + request req = p.release(); BEAST_EXPECT(req.body == "*"); } @@ -88,7 +88,7 @@ public: { error_code ec; parser_v1>> p; + basic_fields>> p; std::string const s = "GET / HTTP/1.1\r\n" "User-Agent: test\r\n" @@ -102,13 +102,13 @@ public: BEAST_EXPECT(m.method == "GET"); BEAST_EXPECT(m.url == "/"); BEAST_EXPECT(m.version == 11); - BEAST_EXPECT(m.headers["User-Agent"] == "test"); + BEAST_EXPECT(m.fields["User-Agent"] == "test"); BEAST_EXPECT(m.body == "*"); } { error_code ec; parser_v1>> p; + basic_fields>> p; std::string const s = "HTTP/1.1 200 OK\r\n" "Server: test\r\n" @@ -122,13 +122,13 @@ public: BEAST_EXPECT(m.status == 200); BEAST_EXPECT(m.reason == "OK"); BEAST_EXPECT(m.version == 11); - BEAST_EXPECT(m.headers["Server"] == "test"); + BEAST_EXPECT(m.fields["Server"] == "test"); BEAST_EXPECT(m.body == "*"); } // skip body { error_code ec; - parser_v1 p; + parser_v1 p; std::string const s = "HTTP/1.1 200 Connection Established\r\n" "Proxy-Agent: Zscaler/5.1\r\n" diff --git a/test/http/read.cpp b/test/http/read.cpp index 3d4f57b3..8775dc2f 100644 --- a/test/http/read.cpp +++ b/test/http/read.cpp @@ -10,7 +10,7 @@ #include "fail_parser.hpp" -#include +#include #include #include #include @@ -157,7 +157,7 @@ public: sb.prepare(len), buffer(s, len))); test::fail_counter fc{n}; test::string_stream ss{ios_, s}; - parser_v1 p{fc}; + parser_v1 p{fc}; error_code ec; parse(ss, sb, p, ec); if(! ec) @@ -172,7 +172,7 @@ public: { streambuf sb; test::string_stream ss(ios_, "GET / X"); - parser_v1 p; + parser_v1 p; parse(ss, sb, p); fail(); } @@ -258,7 +258,7 @@ public: "Content-Length: 5\r\n" "\r\n" }; - request_headers m; + request_header m; try { streambuf sb; @@ -280,7 +280,7 @@ public: "Content-Length: 0\r\n" "\r\n" ); - request_headers m; + request_header m; error_code ec; streambuf sb; async_read(fs, sb, m, do_yield[ec]); @@ -359,7 +359,7 @@ public: { streambuf sb; test::string_stream ss(ios_, ""); - parser_v1 p; + parser_v1 p; error_code ec; parse(ss, sb, p, ec); BEAST_EXPECT(ec == boost::asio::error::eof); @@ -367,7 +367,7 @@ public: { streambuf sb; test::string_stream ss(ios_, ""); - parser_v1 p; + parser_v1 p; error_code ec; async_parse(ss, sb, p, do_yield[ec]); BEAST_EXPECT(ec == boost::asio::error::eof); diff --git a/test/http/streambuf_body.cpp b/test/http/streambuf_body.cpp index eec84122..e2ed3811 100644 --- a/test/http/streambuf_body.cpp +++ b/test/http/streambuf_body.cpp @@ -9,7 +9,7 @@ #include #include -#include +#include #include #include #include @@ -34,7 +34,7 @@ public: "\r\n" "xyz"; test::string_stream ss(ios_, s); - parser_v1 p; + parser_v1 p; streambuf sb; parse(ss, sb, p); BEAST_EXPECT(to_string(p.get().body.data()) == "xyz"); diff --git a/test/http/write.cpp b/test/http/write.cpp index 0a70ef42..514086d3 100644 --- a/test/http/write.cpp +++ b/test/http/write.cpp @@ -8,7 +8,7 @@ // Test that header file is self-contained. #include -#include +#include #include #include #include @@ -221,9 +221,9 @@ public: }; }; - template + template std::string - str(message const& m) + str(message const& m) { string_write_stream ss(ios_); write(ss, m); @@ -234,11 +234,11 @@ public: testAsyncWriteHeaders(yield_context do_yield) { { - message_headers m; + header m; m.version = 11; m.method = "GET"; m.url = "/"; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); error_code ec; string_write_stream ss{ios_}; async_write(ss, m, do_yield[ec]); @@ -249,12 +249,12 @@ public: "\r\n"); } { - message_headers m; + header m; m.version = 10; m.status = 200; m.reason = "OK"; - m.headers.insert("Server", "test"); - m.headers.insert("Content-Length", "5"); + m.fields.insert("Server", "test"); + m.fields.insert("Content-Length", "5"); error_code ec; string_write_stream ss{ios_}; async_write(ss, m, do_yield[ec]); @@ -271,12 +271,12 @@ public: testAsyncWrite(yield_context do_yield) { { - message m; + message m; m.version = 10; m.status = 200; m.reason = "OK"; - m.headers.insert("Server", "test"); - m.headers.insert("Content-Length", "5"); + m.fields.insert("Server", "test"); + m.fields.insert("Content-Length", "5"); m.body = "*****"; error_code ec; string_write_stream ss{ios_}; @@ -290,12 +290,12 @@ public: "*****"); } { - message m; + message m; m.version = 11; m.status = 200; m.reason = "OK"; - m.headers.insert("Server", "test"); - m.headers.insert("Transfer-Encoding", "chunked"); + m.fields.insert("Server", "test"); + m.fields.insert("Transfer-Encoding", "chunked"); m.body = "*****"; error_code ec; string_write_stream ss(ios_); @@ -323,14 +323,14 @@ public: test::fail_counter fc(n); test::fail_stream< string_write_stream> fs(fc, ios_); - message m( + message m( std::piecewise_construct, std::forward_as_tuple(fc, ios_)); m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); - m.headers.insert("Content-Length", "5"); + m.fields.insert("User-Agent", "test"); + m.fields.insert("Content-Length", "5"); m.body = "*****"; try { @@ -356,14 +356,14 @@ public: test::fail_counter fc(n); test::fail_stream< string_write_stream> fs(fc, ios_); - message m( + message m( std::piecewise_construct, std::forward_as_tuple(fc, ios_)); m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); - m.headers.insert("Transfer-Encoding", "chunked"); + m.fields.insert("User-Agent", "test"); + m.fields.insert("Transfer-Encoding", "chunked"); m.body = "*****"; error_code ec; write(fs, m, ec); @@ -391,14 +391,14 @@ public: test::fail_counter fc(n); test::fail_stream< string_write_stream> fs(fc, ios_); - message m( + message m( std::piecewise_construct, std::forward_as_tuple(fc, ios_)); m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); - m.headers.insert("Transfer-Encoding", "chunked"); + m.fields.insert("User-Agent", "test"); + m.fields.insert("Transfer-Encoding", "chunked"); m.body = "*****"; error_code ec; async_write(fs, m, do_yield[ec]); @@ -426,14 +426,14 @@ public: test::fail_counter fc(n); test::fail_stream< string_write_stream> fs(fc, ios_); - message m( + message m( std::piecewise_construct, std::forward_as_tuple(fc, ios_)); m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); - m.headers.insert("Content-Length", "5"); + m.fields.insert("User-Agent", "test"); + m.fields.insert("Content-Length", "5"); m.body = "*****"; error_code ec; write(fs, m, ec); @@ -456,14 +456,14 @@ public: test::fail_counter fc(n); test::fail_stream< string_write_stream> fs(fc, ios_); - message m( + message m( std::piecewise_construct, std::forward_as_tuple(fc, ios_)); m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); - m.headers.insert("Content-Length", "5"); + m.fields.insert("User-Agent", "test"); + m.fields.insert("Content-Length", "5"); m.body = "*****"; error_code ec; async_write(fs, m, do_yield[ec]); @@ -487,11 +487,11 @@ public: { // auto content-length HTTP/1.0 { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; prepare(m); BEAST_EXPECT(str(m) == @@ -504,11 +504,11 @@ public: } // keep-alive HTTP/1.0 { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; prepare(m, connection::keep_alive); BEAST_EXPECT(str(m) == @@ -522,11 +522,11 @@ public: } // upgrade HTTP/1.0 { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; try { @@ -540,11 +540,11 @@ public: } // no content-length HTTP/1.0 { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 10; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; prepare(m); string_write_stream ss(ios_); @@ -560,11 +560,11 @@ public: } // auto content-length HTTP/1.1 { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 11; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; prepare(m); BEAST_EXPECT(str(m) == @@ -577,11 +577,11 @@ public: } // close HTTP/1.1 { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 11; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; prepare(m, connection::close); string_write_stream ss(ios_); @@ -599,11 +599,11 @@ public: } // upgrade HTTP/1.1 { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 11; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); prepare(m, connection::upgrade); BEAST_EXPECT(str(m) == "GET / HTTP/1.1\r\n" @@ -614,11 +614,11 @@ public: } // no content-length HTTP/1.1 { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 11; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; prepare(m); string_write_stream ss(ios_); @@ -639,11 +639,11 @@ public: void test_std_ostream() { // Conversion to std::string via operator<< - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 11; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; BEAST_EXPECT(boost::lexical_cast(m) == "GET / HTTP/1.1\r\nUser-Agent: test\r\n\r\n*"); @@ -656,7 +656,7 @@ public: std::stringstream::failbit); try { - // message_headers + // header ss << m.base(); fail("", __FILE__, __LINE__); } @@ -679,11 +679,11 @@ public: void testOstream() { - message m; + message m; m.method = "GET"; m.url = "/"; m.version = 11; - m.headers.insert("User-Agent", "test"); + m.fields.insert("User-Agent", "test"); m.body = "*"; prepare(m); std::stringstream ss; diff --git a/test/websocket/frame.cpp b/test/websocket/frame.cpp index b3aee27d..522c72f8 100644 --- a/test/websocket/frame.cpp +++ b/test/websocket/frame.cpp @@ -68,7 +68,7 @@ public: void testFrameHeader() { - // good frame headers + // good frame fields { role_type role = role_type::client; @@ -118,7 +118,7 @@ public: check(fh); } - // bad frame headers + // bad frame fields { role_type role = role_type::client; @@ -211,7 +211,7 @@ public: void testBadFrameHeaders() { - // bad frame headers + // bad frame fields // // can't be created by the library // so we produce them manually. diff --git a/test/websocket/stream.cpp b/test/websocket/stream.cpp index 8c396b2d..084019eb 100644 --- a/test/websocket/stream.cpp +++ b/test/websocket/stream.cpp @@ -133,15 +133,15 @@ public: struct identity { - template + template void - operator()(http::message&) + operator()(http::message&) { } - template + template void - operator()(http::message&) + operator()(http::message&) { } }; @@ -188,11 +188,11 @@ public: req.method = "GET"; req.url = "/"; req.version = 11; - req.headers.insert("Host", "localhost"); - req.headers.insert("Upgrade", "websocket"); - req.headers.insert("Connection", "upgrade"); - req.headers.insert("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ=="); - req.headers.insert("Sec-WebSocket-Version", "13"); + req.fields.insert("Host", "localhost"); + req.fields.insert("Upgrade", "websocket"); + req.fields.insert("Connection", "upgrade"); + req.fields.insert("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ=="); + req.fields.insert("Sec-WebSocket-Version", "13"); stream> ws(n, ios_, ""); try diff --git a/test/websocket/websocket_async_echo_server.hpp b/test/websocket/websocket_async_echo_server.hpp index 21b56e6b..ae496324 100644 --- a/test/websocket/websocket_async_echo_server.hpp +++ b/test/websocket/websocket_async_echo_server.hpp @@ -135,18 +135,18 @@ private: struct identity { - template + template void - operator()(http::message& req) + operator()(http::message& req) { - req.headers.replace("User-Agent", "async_echo_client"); + req.fields.replace("User-Agent", "async_echo_client"); } - template + template void - operator()(http::message& resp) + operator()(http::message& resp) { - resp.headers.replace("Server", "async_echo_server"); + resp.fields.replace("Server", "async_echo_server"); } }; diff --git a/test/websocket/websocket_sync_echo_server.hpp b/test/websocket/websocket_sync_echo_server.hpp index fd3dba2d..97276292 100644 --- a/test/websocket/websocket_sync_echo_server.hpp +++ b/test/websocket/websocket_sync_echo_server.hpp @@ -138,18 +138,18 @@ private: struct identity { - template + template void - operator()(http::message& req) + operator()(http::message& req) { - req.headers.replace("User-Agent", "sync_echo_client"); + req.fields.replace("User-Agent", "sync_echo_client"); } - template + template void - operator()(http::message& resp) + operator()(http::message& resp) { - resp.headers.replace("Server", "sync_echo_server"); + resp.fields.replace("Server", "sync_echo_server"); } };