Reset error codes

fix #478

include/beast/core/impl/buffered_read_stream.ipp

@@ -225,6 +225,10 @@ read_some(MutableBufferSequence const& buffers,
         if(ec)
             return 0;
     }
+    else
+    {
+        ec = {};
+    }
     auto bytes_transferred =
         buffer_copy(buffers, sb_.data());
     sb_.consume(bytes_transferred);

include/beast/http/basic_parser.hpp

@@ -52,8 +52,11 @@ namespace http {
     Every callback must be provided by the derived class, or else
     a compilation error will be generated. This exemplar shows
     the signature and description of the callbacks required in
-    the derived class. If a callback sets the error code, the error
-    will be propagated to the caller of the parser.
+    the derived class.
+    For each callback, the function will ensure that `!ec` is `true`
+    if there was no error or set to the appropriate error code if
+    there was one.  If an error is set, the value is propagated to
+    the caller of the parser.
 
     @tparam isRequest A `bool` indicating whether the parser will be
     presented with request or response message.

include/beast/http/buffer_body.hpp

@@ -110,8 +110,9 @@ struct buffer_body
         }
 
         void
-        init(error_code&)
+        init(error_code& ec)
         {
+            ec = {};
         }
 
         boost::optional<
@@ -125,22 +126,30 @@ struct buffer_body
                     toggle_ = false;
                     ec = error::need_buffer;
                 }
+                else
+                {
+                    ec = {};
+                }
                 return boost::none;
             }
             if(body_.data)
             {
+                ec = {};
                 toggle_ = true;
                 return {{const_buffers_type{
                     body_.data, body_.size}, body_.more}};
             }
             if(body_.more)
                 ec = error::need_buffer;
+            else
+                ec = {};
             return boost::none;
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif
@@ -162,8 +171,9 @@ struct buffer_body
         }
 
         void
-        init(boost::optional<std::uint64_t>, error_code&)
+        init(boost::optional<std::uint64_t>, error_code& ec)
         {
+            ec = {};
         }
 
         template<class ConstBufferSequence>
@@ -179,6 +189,7 @@ struct buffer_body
                 ec = error::need_buffer;
                 return;
             }
+            ec = {};
             auto const bytes_transferred =
                 buffer_copy(boost::asio::buffer(
                     body_.data, body_.size), buffers);
@@ -188,8 +199,9 @@ struct buffer_body
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif

include/beast/http/detail/basic_parser.hpp

@@ -389,16 +389,23 @@ protected:
         for(;;)
         {
             if(it == last)
+            {
+                ec = {};
                 return nullptr;
+            }
             if(*it == '\r')
             {
                 if(++it == last)
+                {
+                    ec = {};
                     return nullptr;
+                }
                 if(*it != '\n')
                 {
                     ec = error::bad_line_ending;
                     return nullptr;
                 }
+                ec = {};
                 return ++it;
             }
             // VFALCO Should we handle the legacy case
@@ -418,30 +425,43 @@ protected:
         for(;;)
         {
             if(it == last)
+            {
+                ec = {};
                 return nullptr;
+            }
             if(*it == '\r')
             {
                 if(++it == last)
+                {
+                    ec = {};
                     return nullptr;
+                }
                 if(*it != '\n')
                 {
                     ec = error::bad_line_ending;
                     return nullptr;
                 }
                 if(++it == last)
+                {
+                    ec = {};
                     return nullptr;
+                }
                 if(*it != '\r')
                 {
                     ++it;
                     continue;
                 }
                 if(++it == last)
+                {
+                    ec = {};
                     return nullptr;
+                }
                 if(*it != '\n')
                 {
                     ec = error::bad_line_ending;
                     return nullptr;
                 }
+                ec = {};
                 return ++it;
             }
             // VFALCO Should we handle the legacy case

include/beast/http/dynamic_body.hpp

@@ -61,19 +61,22 @@ struct basic_dynamic_body
         }
 
         void
-        init(error_code&)
+        init(error_code& ec)
         {
+            ec = {};
         }
 
         boost::optional<std::pair<const_buffers_type, bool>>
         get(error_code& ec)
         {
+            ec = {};
             return {{body_.data(), false}};
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif
@@ -97,8 +100,9 @@ struct basic_dynamic_body
 
         void
         init(boost::optional<
-            std::uint64_t> const&, error_code&)
+            std::uint64_t> const&, error_code& ec)
         {
+            ec = {};
         }
 
         template<class ConstBufferSequence>
@@ -120,12 +124,14 @@ struct basic_dynamic_body
                 ec = error::buffer_overflow;
                 return;
             }
+            ec = {};
             body_.commit(buffer_copy(*b, buffers));
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif

include/beast/http/empty_body.hpp

@@ -63,19 +63,22 @@ struct empty_body
         }
 
         void
-        init(error_code&)
+        init(error_code& ec)
         {
+            ec = {};
         }
 
         boost::optional<std::pair<const_buffers_type, bool>>
         get(error_code& ec)
         {
+            ec = {};
             return boost::none;
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif
@@ -94,8 +97,9 @@ struct empty_body
 
         void
         init(boost::optional<std::uint64_t> const&,
-            error_code&)
+            error_code& ec)
         {
+            ec = {};
         }
 
         template<class ConstBufferSequence>
@@ -107,8 +111,9 @@ struct empty_body
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif

include/beast/http/impl/basic_parser.ipp

@@ -94,7 +94,10 @@ put(ConstBufferSequence const& buffers,
     auto const p = buffers.begin();
     auto const last = buffers.end();
     if(p == last)
+    {
+        ec = {};
         return 0;
+    }
     if(std::next(p) == last)
     {
         // single buffer
@@ -196,7 +199,8 @@ loop:
         break;
 
     case state::complete:
-        break;
+        ec = {};
+        goto done;
     }
     if(p < p1 && ! is_done() && eager())
     {
@@ -225,6 +229,7 @@ put_eof(error_code& ec)
             ec = error::partial_message;
             return;
         }
+        ec = {};
         return;
     }
     impl().on_complete(ec);
@@ -789,6 +794,7 @@ do_field(field f,
                 continue;
             }
         }
+        ec = {};
         return;
     }
 
@@ -827,6 +833,7 @@ do_field(field f,
             return;
         }
 
+        ec = {};
         len_ = v;
         f_ |= flagContentLength;
         return;
@@ -849,6 +856,7 @@ do_field(field f,
             return;
         }
 
+        ec = {};
         auto const v = token_list{value};
         auto const p = std::find_if(v.begin(), v.end(),
             [&](typename token_list::value_type const& s)
@@ -867,10 +875,12 @@ do_field(field f,
     // Upgrade
     if(f == field::upgrade)
     {
-        f_ |= flagUpgrade;
         ec = {};
+        f_ |= flagUpgrade;
         return;
     }
+
+    ec = {};
 }
 
 } // http

include/beast/http/impl/read.ipp

@@ -467,7 +467,6 @@ read_some(
             break;
         if(ec != http::error::need_more)
             break;
-        ec = {};
     do_read:
         boost::optional<typename
             DynamicBuffer::mutable_buffers_type> b;
@@ -479,7 +478,7 @@ read_some(
         catch(std::length_error const&)
         {
             ec = error::buffer_overflow;
-            break;
+            return;
         }
         auto const bytes_transferred =
             stream.read_some(*b, ec);
@@ -489,7 +488,6 @@ read_some(
             if(parser.got_some())
             {
                 // caller sees EOF on next read
-                ec = {};
                 parser.put_eof(ec);
                 if(ec)
                     break;
@@ -570,12 +568,18 @@ read_header(
     static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     parser.eager(false);
-    while(! parser.is_header_done())
+    if(parser.is_header_done())
+    {
+        ec = {};
+        return;
+    }
+    do
     {
         read_some(stream, buffer, parser, ec);
         if(ec)
             return;
     }
+    while(! parser.is_header_done());
 }
 
 template<
@@ -643,12 +647,18 @@ read(
     static_assert(is_dynamic_buffer<DynamicBuffer>::value,
         "DynamicBuffer requirements not met");
     parser.eager(true);
-    while(! parser.is_done())
+    if(parser.is_done())
+    {
+        ec = {};
+        return;
+    }
+    do
     {
         read_some(stream, buffer, parser, ec);
         if(ec)
             return;
     }
+    while(! parser.is_done());
 }
 
 template<

include/beast/http/impl/serializer.ipp

@@ -60,7 +60,8 @@ get(error_code& ec, Visit&& visit)
         frdinit(std::integral_constant<bool,
             isRequest>{});
         close_ = m_.has_close() || (
-            m_.version < 11 && ! m_.has_content_length());
+            m_.version < 11 &&
+            ! m_.has_content_length());
         if(m_.has_chunked())
             goto go_init_c;
         s_ = do_init;

include/beast/http/impl/write.ipp

@@ -56,6 +56,7 @@ class write_some_op
         operator()(error_code& ec,
             ConstBufferSequence const& buffer)
         {
+            ec = {};
             invoked = true;
             return op_.s_.async_write_some(
                 buffer, std::move(op_));
@@ -212,6 +213,7 @@ class write_op
         operator()(error_code& ec,
             ConstBufferSequence const& buffer)
         {
+            ec = {};
             invoked = true;
             return op_.s_.async_write_some(
                 buffer, std::move(op_));
@@ -533,14 +535,16 @@ write_some(SyncWriteStream& stream, serializer<
     static_assert(is_body_reader<Body>::value,
         "BodyReader requirements not met");
     detail::write_some_lambda<SyncWriteStream> f{stream};
-    if(! sr.is_done())
+    if(sr.is_done())
     {
-        sr.get(ec, f);
-        if(ec)
-            return;
-        if(f.invoked)
-            sr.consume(f.bytes_transferred);
+        ec = {};
+        return;
     }
+    sr.get(ec, f);
+    if(ec)
+        return;
+    if(f.invoked)
+        sr.consume(f.bytes_transferred);
 }
 
 template<class AsyncWriteStream,
@@ -603,8 +607,13 @@ write_header(SyncWriteStream& stream, serializer<
     static_assert(is_body_reader<Body>::value,
         "BodyReader requirements not met");
     sr.split(true);
+    if(sr.is_header_done())
+    {
+        ec = {};
+        return;
+    }
     detail::write_lambda<SyncWriteStream> f{stream};
-    while(! sr.is_header_done())
+    do
     {
         sr.get(ec, f);
         if(ec)
@@ -612,6 +621,7 @@ write_header(SyncWriteStream& stream, serializer<
         BOOST_ASSERT(f.invoked);
         sr.consume(f.bytes_transferred);
     }
+    while(! sr.is_header_done());
 }
 
 template<class AsyncWriteStream,
@@ -668,8 +678,13 @@ write(SyncWriteStream& stream, serializer<
     static_assert(is_sync_write_stream<SyncWriteStream>::value,
         "SyncWriteStream requirements not met");
     sr.split(false);
+    if(sr.is_done())
+    {
+        ec = {};
+        return;
+    }
     detail::write_lambda<SyncWriteStream> f{stream};
-    while(! sr.is_done())
+    do
     {
         sr.get(ec, f);
         if(ec)
@@ -677,6 +692,7 @@ write(SyncWriteStream& stream, serializer<
         if(f.invoked)
             sr.consume(f.bytes_transferred);
     }
+    while(! sr.is_done());
     if(sr.need_close())
         ec = error::end_of_stream;
 }
@@ -792,9 +808,12 @@ public:
 
     template<class ConstBufferSequence>
     void
-    operator()(error_code&,
+    operator()(error_code& ec,
         ConstBufferSequence const& buffers) const
     {
+        ec = {};
+        if(os_.fail())
+            return;
         std::size_t bytes_transferred = 0;
         using boost::asio::buffer_cast;
         using boost::asio::buffer_size;

include/beast/http/parser.hpp

@@ -183,8 +183,9 @@ private:
 
     void
     on_request(verb method, string_view method_str,
-        string_view target, int version, error_code&)
+        string_view target, int version, error_code& ec)
     {
+        ec = {};
         m_.target(target);
         if(method != verb::unknown)
             m_.method(method);
@@ -196,8 +197,9 @@ private:
     void
     on_response(int code,
         string_view reason,
-            int version, error_code&)
+            int version, error_code& ec)
     {
+        ec = {};
         m_.result(code);
         m_.version = version;
         m_.reason(reason);
@@ -205,14 +207,16 @@ private:
 
     void
     on_field(field name, string_view name_string,
-        string_view value, error_code&)
+        string_view value, error_code& ec)
     {
+        ec = {};
         m_.insert(name, name_string, value);
     }
 
     void
     on_header(error_code& ec)
     {
+        ec = {};
     }
 
     void
@@ -233,8 +237,9 @@ private:
 
     void
     on_chunk(std::uint64_t,
-        string_view, error_code&)
+        string_view, error_code& ec)
     {
+        ec = {};
     }
 
     void
@@ -242,6 +247,8 @@ private:
     {
         if(wr_)
             wr_->finish(ec);
+        else
+            ec = {};
     }
 };
 

include/beast/http/string_body.hpp

@@ -63,20 +63,23 @@ struct string_body
         }
 
         void
-        init(error_code&)
+        init(error_code& ec)
         {
+            ec = {};
         }
 
         boost::optional<std::pair<const_buffers_type, bool>>
-        get(error_code&)
+        get(error_code& ec)
         {
+            ec = {};
             return {{const_buffers_type{
                 body_.data(), body_.size()}, false}};
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif
@@ -110,6 +113,7 @@ struct string_body
                         errc::not_enough_memory);
                     return;
                 }
+                ec = {};
                 body_.reserve(static_cast<
                     std::size_t>(*content_length));
             }
@@ -133,13 +137,15 @@ struct string_body
                 ec = error::buffer_overflow;
                 return;
             }
+            ec = {};
             buffer_copy(boost::asio::buffer(
                 &body_[0] + len, n), buffers);
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif

include/beast/http/string_view_body.hpp

@@ -64,19 +64,22 @@ struct string_view_body
         }
 
         void
-        init(error_code&)
+        init(error_code& ec)
         {
+            ec = {};
         }
 
         boost::optional<std::pair<const_buffers_type, bool>>
         get(error_code& ec)
         {
+            ec = {};
             return {{{body_.data(), body_.size()}, false}};
         }
 
         void
-        finish(error_code&)
+        finish(error_code& ec)
         {
+            ec = {};
         }
     };
 #endif

include/beast/websocket/detail/pmd_extension.hpp

@@ -461,6 +461,7 @@ deflate(
             }
         }
     }
+    ec = {};
     out = buffer(
         buffer_cast<void*>(out), zs.total_out);
     return true;

include/beast/websocket/impl/stream.ipp

@@ -148,7 +148,7 @@ do_handshake(response_type* res_p,
         return;
     do_response(res, key, ec);
     if(res_p)
-        swap(res, *res_p);
+        *res_p = std::move(res);
 }
 
 template<class NextLayer>
@@ -302,6 +302,7 @@ do_response(http::header<false> const& res,
         ec = error::handshake_failed;
         return;
     }
+    ec = {};
     detail::pmd_offer offer;
     pmd_read(offer, res);
     // VFALCO see if offer satisfies pmd_config_,