anchor.diff:  -define(READ_SIZE, 8192).
   
   -export([get_header_value/1, get_primary_header_value/1, get/1, dump/0]).
  --export([send/1, recv/1, recv/2, recv_body/0, recv_body/1]).
  +-export([send/1, recv/1, recv/2, recv_body/0, recv_body/1, stream_body/3]).
   -export([start_response/1, start_response_length/1, start_raw_response/1]).
   -export([respond/1, ok/1]).
   -export([not_found/0, not_found/1]).
  
positive.code: %% @doc Receive the body of the HTTP request (defined by Content-Length).
  %%      Will receive up to MaxBody bytes.
  recv_body(MaxBody) ->
      case get_header_value("expect") of
          "100-continue" ->
              start_raw_response({100, gb_trees:empty()});
          _Else ->
              ok
      end,
      Body = case body_length() of
                 undefined ->
                     undefined;
                 {unknown_transfer_encoding, Unknown} ->
                     exit({unknown_transfer_encoding, Unknown});
                 chunked ->
                     read_chunked_body(MaxBody, []);
                 0 ->
                     <<>>;
                 Length when is_integer(Length), Length =< MaxBody ->
                     recv(Length);
                 Length ->
                     exit({body_too_large, Length})
             end,
      put(?SAVE_BODY, Body),
      Body.
  
  
  %% @spec start_response({integer(), ioheaders()}) -> response()
  
negative.code:             Cached
      end.
  
  %% @spec stream_chunked_body(integer(), fun(), term()) -> term()
  %% @doc The function is called for each chunk.
  %%      Used internally by read_chunked_body.
  stream_chunked_body(MaxChunkSize, Fun, FunState) ->
      case read_chunk_length() of
          0 ->
              Fun({0, read_chunk(0)}, FunState);
          Length when Length > MaxChunkSize ->
              NewState = read_sub_chunks(Length, MaxChunkSize, Fun, FunState),
              stream_chunked_body(MaxChunkSize, Fun, NewState);
          Length ->
              NewState = Fun({Length, read_chunk(Length)}, FunState),
              stream_chunked_body(MaxChunkSize, Fun, NewState)
      end.
  
  stream_unchunked_body(0, _MaxChunkSize, Fun, FunState) ->
      Fun({0, <<>>}, FunState);
  stream_unchunked_body(Length, MaxChunkSize, Fun, FunState) when Length > MaxChunkSize ->
      Bin = recv(MaxChunkSize),
      NewState = Fun({MaxChunkSize, Bin}, FunState),
      stream_unchunked_body(Length - MaxChunkSize, MaxChunkSize, Fun, NewState);
  stream_unchunked_body(Length, MaxChunkSize, Fun, FunState) ->
      Bin = recv(Length),
      NewState = Fun({Length, Bin}, FunState),
      stream_unchunked_body(0, MaxChunkSize, Fun, NewState).
  
  
  %% @spec read_chunk_length() -> integer()
  %% @doc Read the length of the next HTTP chunk.
  