add client size close

Author: chenzhaoyu

boost/network/protocol/http/client/connection/async_normal.hpp

@@ -363,14 +363,25 @@ struct http_async_connection
             // Here we handle the body data ourself and append to an
             // ever-growing string buffer.
             auto self = this->shared_from_this();
-            this->parse_body(
+            typename protocol_base::buffer_type::const_iterator begin =
+                this->part_begin;
+            typename protocol_base::buffer_type::const_iterator end = begin;
+            std::advance(end, remainder);
+            string_type body_string(begin, end);
+            if (check_parse_body_complete(body_string)) {
+              this->append_body(remainder);
+              handle_received_data(body, get_body, callback,
+                                   boost::asio::error::eof, bytes_transferred);
+            } else {
+              this->parse_body(
                 delegate_,
                 request_strand_.wrap([=] (boost::system::error_code const &ec,
                                           std::size_t bytes_transferred) {
                                        self->handle_received_data(body, get_body, callback,
                                                                   ec, bytes_transferred);
                                      }),
                 remainder);
+            }
           }
           return;
         case body:
@@ -428,17 +439,25 @@ struct http_async_connection
                                                                     ec, bytes_transferred);
                                        }));
             } else {
-              // Here we don't have a body callback. Let's make sure that we
-              // deal with the remainder from the headers part in case we do
-              // have data that's still in the buffer.
-              this->parse_body(
+              string_type body_string(this->partial_parsed);
+              body_string.append(this->part.begin(), bytes_transferred);
+              if (check_parse_body_complete (body_string)) {
+                this->append_body(bytes_transferred);
+                handle_received_data(body, get_body, callback,
+                                     boost::asio::error::eof, bytes_transferred);
+              } else {
+                // Here we don't have a body callback. Let's make sure that we
+                // deal with the remainder from the headers part in case we do
+                // have data that's still in the buffer.
+                this->parse_body(
                   delegate_,
                   request_strand_.wrap([=] (boost::system::error_code const &ec,
                                             std::size_t bytes_transferred) {
                                          self->handle_received_data(body, get_body, callback,
                                                                     ec, bytes_transferred);
                                        }),
                   bytes_transferred);
+              }
             }
           }
           return;
@@ -476,6 +495,50 @@ struct http_async_connection
     }
   }
 
+  inline bool check_parse_body_complete(string_type& body_string)
+  {
+    if (this->is_chunk_encoding) {
+      return parse_chunk_encoding_complete(body_string);
+    }
+    if (this->is_content_length && this->content_length >= 0) {
+      return parse_content_length_complete(body_string, this->content_length);
+    }
+    return false;
+  }
+
+  inline bool parse_content_length_complete(string_type& body_string, size_t content_length){
+    return body_string.length() >= content_length;
+  }
+
+  bool parse_chunk_encoding_complete(string_type& body_string) {
+    string_type body;
+    string_type crlf = "\r\n";
+
+    typename string_type::iterator begin = body_string.begin();
+    for (typename string_type::iterator iter =
+             std::search(begin, body_string.end(), crlf.begin(), crlf.end());
+         iter != body_string.end();
+         iter =
+             std::search(begin, body_string.end(), crlf.begin(), crlf.end())) {
+      string_type line(begin, iter);
+      if (line.empty()) {
+          std::advance(iter, 2);
+          begin = iter;
+          continue;
+      }
+      std::stringstream stream(line);
+      int len;
+      stream >> std::hex >> len;
+      std::advance(iter, 2);
+      if (!len) return true;
+      if (len <= body_string.end() - iter) {
+        std::advance(iter, len + 2);
+      }
+      begin = iter;
+    }
+    return false;
+  }
+
   string_type parse_chunk_encoding(string_type& body_string) {
     string_type body;
     string_type crlf = "\r\n";

boost/network/protocol/http/client/connection/async_protocol_handler.hpp

@@ -246,6 +246,10 @@ struct http_async_protocol_handler {
         response_parser_type::http_header_line_done);
     typename headers_container<Tag>::type headers;
     std::pair<string_type, string_type> header_pair;
+    //init params
+    is_content_length = false;
+    content_length = -1;
+    is_chunk_end = false;
     while (!boost::empty(input_range)) {
       std::tie(parsed_ok, result_range) = headers_parser.parse_until(
           response_parser_type::http_header_colon, input_range);
@@ -266,6 +270,10 @@ struct http_async_protocol_handler {
       }
       trim(header_pair.second);
       headers.insert(header_pair);
+      if (boost::iequals(header_pair.first, "Content-Length")) {
+        is_content_length = true;
+        content_length = std::stoi(header_pair.second);
+      }
     }
     // determine if the body parser will need to handle chunked encoding
     typename headers_range<basic_response<Tag> >::type transfer_encoding_range =
@@ -325,6 +333,11 @@ struct http_async_protocol_handler {
         parsed_ok, std::distance(std::end(result_range), part_end));
   }
 
+  void append_body(size_t bytes) {
+    partial_parsed.append(part_begin, part_begin + bytes);
+    part_begin = part.begin();
+  }
+
   template <class Delegate, class Callback>
   void parse_body(Delegate& delegate_, Callback callback, size_t bytes) {
     // TODO(dberris): we should really not use a string for the partial body
@@ -351,6 +364,9 @@ struct http_async_protocol_handler {
   typename buffer_type::const_iterator part_begin;
   string_type partial_parsed;
   bool is_chunk_encoding;
+  bool is_chunk_end;
+  bool is_content_length;
+  std::size_t content_length;
 };
 
 }  // namespace impl