support "Expect: 100-continue" header

When the header is set the body is only sent if the server answer with a
100 continue status. In other case `hackney:stream_body/2` and
`hackney_multipart:stream/2` return {stop, Client}. When the body is not
streamed Hakney takes of this header and only send it if needed.

This changes allows you to received immediately the server errors and
allows you don't send the body for nothing.

More info about this header:
http://www.w3.org/Protocols/rfc2616/rfc2616-sec8.html#sec8.2.3

Author: benoitc

examples/test_continue.ebin

@@ -0,0 +1,50 @@
+#!/usr/bin/env escript
+%% -*- erlang -*-
+%%! -pa ./ebin -pa ./deps/mimetypes/ebin
+
+-module(test_continue).
+
+
+
+main(_) ->
+    hackney:start(),
+
+    {ok, _, _, Client} = hackney:request(<<"https://friendpaste.com">>),
+    {ok, Body, Client1} = hackney:body(Client),
+
+    io:format("body: ~p~n~n", [Body]),
+
+    {ok, _, _, Client2} = hackney:send_request(Client1, {get,
+                                                         <<"/_all_languages">>,
+                                                         [],
+                                                         <<>>}),
+
+    {ok, Body1, Client3} = hackney:body(Client2),
+
+    io:format("body: ~p~n~n", [Body1]),
+
+
+    ReqBody = << "{
+         \"id\": \"some_paste_id\",
+         \"rev\": \"some_revision_id\",
+         \"changeset\": \"changeset in unidiff format\"
+    }" >>,
+
+    ReqHeaders = [{<<"Content-Type">>, <<"application/json">>},
+                  {<<"Expect">>, <<"100-continue">>}],
+
+    {ok, _, _, Client4} = hackney:send_request(Client3, {post, <<"/">>,
+                                                         ReqHeaders,
+                                                         ReqBody}),
+    {ok, Body2, Client5} = hackney:body(Client4),
+    io:format("body: ~p~n~n", [Body2]),
+
+    ReqBody1 = {file, "./examples/test.json"},
+
+    {ok, _, _, Client6} = hackney:send_request(Client5, {post, <<"/">>,
+                                                         ReqHeaders,
+                                                         ReqBody1}),
+    {ok, Body3, Client7} = hackney:body(Client6),
+    io:format("body: ~p~n~n", [Body3]),
+
+    hackney:close(Client7).

include/hackney.hrl

@@ -15,6 +15,7 @@
         response_state = start,
         mp_boundary = nil,
         req_type = normal,
+        expect = false,
         send_fun=nil,
         body_state=waiting,
         req_chunk_size=4096,

src/hackney.erl

@@ -313,6 +313,8 @@ start_response(Client) ->
 
 
 %% @doc Stream the response body.
+-spec stream_body(#client{})
+    -> {ok, #client{}} | {stop, #client{}} | {error, term()}.
 stream_body(Client) ->
     hackney_response:stream_body(Client).
 

src/hackney_request.erl

@@ -48,6 +48,7 @@ perform(Client0, {Method0, Path, Headers0, Body0}) ->
                                          Headers0),
 
     ReqType0 = req_type(HeadersDict),
+    Expect = expectation(HeadersDict),
 
     %% build headers with the body.
     {HeaderDict1, ReqType, Body, Client1} = case Body0 of
@@ -98,11 +99,15 @@ perform(Client0, {Method0, Path, Headers0, Body0}) ->
     %% send headers data
     case hackney_request:send(Client, HeadersData) of
         ok when Body =:= stream ->
-            {ok, Client#client{response_state=stream, method=Method}};
+            {ok, Client#client{response_state=stream, method=Method,
+                               expect=Expect}};
         ok ->
-            case stream_body(Body, Client) of
+            case stream_body(Body, Client#client{expect=Expect}) of
                 {error, _Reason}=E ->
                     E;
+                {stop, Client2} ->
+                    FinalClient = Client2#client{method=Method},
+                    hackney_response:start_response(FinalClient);
                 {ok, Client2} ->
                     case end_stream_body(Client2) of
                         {ok, Client3} ->
@@ -116,6 +121,15 @@ perform(Client0, {Method0, Path, Headers0, Body0}) ->
             Error
     end.
 
+stream_body(Msg, #client{expect=true}=Client) ->
+    case hackney_response:expect_response(Client) of
+        {continue, Client2} ->
+            stream_body(Msg, Client2);
+        {stop, Client2} ->
+            {stop, Client2};
+        Error ->
+            Error
+    end;
 stream_body(eof, Client) ->
     {ok, Client#client{response_state=waiting}};
 stream_body(<<>>, Client) ->
@@ -331,6 +345,13 @@ req_type(Headers) ->
         _ -> normal
     end.
 
+expectation(Headers) ->
+    ExpectHdr = hackney_headers:get_value(<<"Expect">>, Headers, <<>>),
+    case hackney_util:to_lower(ExpectHdr) of
+        <<"100-continue">> -> true;
+        _ -> false
+    end.
+
 end_stream_body(#client{req_type=chunked}=Client) ->
     case send_chunk(Client, <<>>) of
         ok ->

src/hackney_response.erl

@@ -18,7 +18,8 @@
          stream_headers/1, stream_header/1,
          stream_body/1,
          body/1, body/2, skip_body/1,
-         close/1]).
+         close/1,
+         expect_response/1]).
 
 %% @doc Start the response It parse the request lines and headers.
 start_response(#client{response_state=stream, mp_boundary=nil} = Client) ->
@@ -50,6 +51,20 @@ start_response(#client{response_state=waiting} = Client) ->
 start_response(_) ->
     {error, invalide_state}.
 
+
+expect_response(Client) ->
+    case recv(Client#client{recv_timeout=1000}) of
+        {ok, <<"HTTP/1.1 100 Continue\r\n\r\n" >>} ->
+            {continue, Client#client{expect=false}};
+        {ok, Data} ->
+            {stop, Client#client{buffer=Data, expect=false,
+                                 response_state=waiting}};
+        {error, timeout} ->
+            continue;
+        Error ->
+            Error
+    end.
+
 %% @doc parse the status line
 stream_status(#client{buffer=Buf}=Client) ->
     case binary:split(Buf, <<"\r\n">>) of