anchor.diff:  	end,
   	case parse_header(<<"transfer-encoding">>, Req1) of
   		{ok, [<<"chunked">>], Req2} ->
  -			stream_body(Req2#http_req{body_state=
  +			stream_body(MaxLength, Req2#http_req{body_state=
   				{stream, 0,
   					fun cowboy_http:te_chunked/2, {0, 0},
  -					fun cowboy_http:ce_identity/1}},
  -				MaxLength);
  +					fun cowboy_http:ce_identity/1}});
   		{ok, [<<"identity">>], Req2} ->
   			{Length, Req3} = body_length(Req2),
   			case Length of
   				0 ->
   					{done, Req3#http_req{body_state=done}};
   				Length ->
  -					stream_body(Req3#http_req{body_state=
  +					stream_body(MaxLength, Req3#http_req{body_state=
   						{stream, Length,
   							fun cowboy_http:te_identity/2, {0, Length},
  -							fun cowboy_http:ce_identity/1}},
  -						MaxLength)
  +							fun cowboy_http:ce_identity/1}})
   			end
   	end;
  -stream_body(Req=#http_req{body_state=done}, _) ->
  +stream_body(_, Req=#http_req{body_state=done}) ->
   	{done, Req};
  -stream_body(Req=#http_req{buffer=Buffer}, _)
  +stream_body(_, Req=#http_req{buffer=Buffer})
   		when Buffer =/= <<>> ->
   	transfer_decode(Buffer, Req#http_req{buffer= <<>>});
  -stream_body(Req, MaxLength) ->
  -	stream_body_recv(Req, MaxLength).
  -
  --spec stream_body_recv(Req, non_neg_integer())
  +stream_body(MaxLength, Req) ->
  +	stream_body_recv(MaxLength, Req).
  +
  +-spec stream_body_recv(non_neg_integer(), Req)
   	-> {ok, binary(), Req} | {error, atom()} when Req::req().
  -stream_body_recv(Req=#http_req{
  +stream_body_recv(MaxLength, Req=#http_req{
   		transport=Transport, socket=Socket, buffer=Buffer,
  -		body_state={stream, Length, _, _, _}}, MaxLength) ->
  +		body_state={stream, Length, _, _, _}}) ->
   	%% @todo Allow configuring the timeout.
   	case Transport:recv(Socket, min(Length, MaxLength), 5000) of
   		{ok, Data} -> transfer_decode(<< Buffer/binary, Data/binary >>,
  
positive.code: 				TransferDecode, TransferState2, ContentDecode}});
  		%% @todo {header(s) for chunked
  		more ->
  			stream_body_recv(Req#http_req{buffer=Data, body_state={stream,
  				0, TransferDecode, TransferState, ContentDecode}}, 0);
  		{more, Length, Data2, TransferState2} ->
  			content_decode(ContentDecode, Data2,
  				Req#http_req{body_state={stream, Length,
  
negative.code: 	{ok, Req#http_req{body_state=
  		{stream, 0, TransferDecode, TransferState, ContentDecode}}}.
  
  %% @equiv stream_body(1000000, Req)
  -spec stream_body(Req) -> {ok, binary(), Req}
  	| {done, Req} | {error, atom()} when Req::req().
  stream_body(Req) ->
  	stream_body(1000000, Req).
  
  %% @doc Stream the request's body.
  %%
  