How to use gen_tcp:recv correctly - erlang

Question

I writing simple http client, and faced following problem, i copypasted that do_recv from offficial doc, but it works strange way:
do_recv(Sock, Bs) ->
case gen_tcp:recv(Sock, 0, ?TIMEOUT) of
{ok, B} ->
gen_tcp:shutdown(Sock, write), % <-- this appears to fix the problem!
do_recv(Sock, [Bs, B]);
{error, closed} ->
{ok, list_to_binary(Bs)}
end.
The chat sequence is following:
{ok, S} = gen_tcp:connect(Ip, Port, [inet, binary,
{packet, 0},
{active, false},
{nodelay, true},
{reuseaddr, true}], 2000),
Req = io_lib:format("GET ~s HTTP/1.1\r\nHost: ~s\r\n\r\n", [Url, UrlHost]),
ok = gen_tcp:send(S, list_to_binary(Req)) of
do_recv(S, []);
And final call to do_recv sometimes works as expected and returns server
respose, but sometimes it hangs and timeouts, i guess because server not closing socket
on its own.
So the second case with timeout is something i want to avoid, any ideas
how to cope with that behaviour ?
UPD:
I am added gen_tcp:shutdown call to do_recv function (see comment in code sample),
and this seem to resolve the issue. Question is pretty noobish i know, and solution
is pretty like guess, maybe someone still can explain what happens here and
how they typically solve this kind of problem.

Answer 1

Your code has some problems.
If you receive 0, you can get half of the GET string, or you can get more than the whole GET string, depending on how the kernel handles the stream. TCP is stream oriented, so you need to eat data from the socket until you have enough. Also, you can easily end up with a {error, timeout} triggering, so you have to handle that problem as well. Otherwise it won't work as expected. Basically you need a loop which gathers up data until you have enough data to parse the GET. Timeouts will happen in that loop before you have all data.
Something along the lines of:
do_recv(Sock, Gathered) ->
case gen_tcp:recv(Sock, 0, ?TIMEOUT) of
{ok, Bin} ->
Remaining = try_decode(Sock, <<Gathered/binary, Bin/binary>>),
do_recv(Sock, Remaining);
{error, timeout} ->
do_recv(Sock, Remaining);
{error, Reason} ->
exit(Reason)
end.
try_decode(Sock, Gathered) ->
case decode(Gathered) of
{ok, Data, Rest} ->
processor ! Data,
try_decode(Sock, Rest);
need_more_data ->
do_recv(Sock, Gathered)
end.
Here assuming a couple of things
decode/1 is a function that tries to decode data and it might fail to do so and request more data.
processor is a process to which we can send the message once we have something decoded. This could also be a function call that does something with the Data we just decoded.