WHY WONT IT PARSE THE LAST FUCKING BYTE AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAH

src/qhl.erl

@@ -49,52 +49,62 @@ parse(Socket, Received) ->
 %% socket.
 
 parse(Socket, Received, M = #request{method = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_method(Socket, Received) of
         {ok, Method, Rest} -> parse(Socket, Rest, M#request{method = Method});
         Error              -> Error
     end;
 parse(Socket, Received, M = #request{path = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_path(Socket, Received) of
         {ok, Path, Rest} -> parse(Socket, Rest, M#request{path = Path});
         Error            -> Error
     end;
 parse(Socket, Received, M = #request{qargs = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_qargs(Socket, Received) of
         {ok, Qargs, Rest} -> parse(Socket, Rest, M#request{qargs = Qargs});
         Error             -> Error
     end;
 parse(Socket, Received, M = #request{fragment = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_fragment(Socket, Received) of
         {ok, Fragment, Rest} -> parse(Socket, Rest, M#request{fragment = Fragment});
         Error                -> Error
     end;
 parse(Socket, Received, M = #request{version = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_version(Socket, Received) of
         {ok, Version, Rest} -> parse(Socket, Rest, M#request{version = Version});
         Error               -> Error
     end;
 parse(Socket, Received, M = #request{headers = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_headers(Socket, Received) of
         {ok, Headers, Rest} -> parse(Socket, Rest, M#request{headers = Headers});
         Error               -> Error
     end;
 parse(Socket, Received, M = #request{enctype = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_enctype(M) of
         {ok, Enctype} -> parse(Socket, Received, M#request{enctype = Enctype});
         Error         -> Error
     end;
 parse(Socket, Received, M = #request{cookies = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_cookies(M) of
         {ok, Cookies} -> parse(Socket, Received, M#request{cookies = Cookies});
         Error         -> Error
     end;
 parse(Socket, Received, M = #request{size = undefined}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_size(M) of
         {ok, 0}    -> {ok, M#request{size = 0}, none};
         {ok, Size} -> parse(Socket, Received, M#request{size = Size});
         Error      -> Error
     end;
 parse(Socket, Received, M = #request{method = get, body = undefined, size = Size}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_body(Received, Size) of
         {ok, Body}         -> {ok, M#request{body = Body}, none};
         {ok, Body, Next}   -> {ok, M#request{body = Body}, Next};
@@ -107,6 +117,7 @@ parse(Socket,
                    method  = post,
                    enctype = urlencoded,
                    size    = Size}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_body(Received, Size) of
         {ok, Body} ->
             {ok, M#request{body = parts_to_map(posted(Body))}, none};
@@ -130,6 +141,7 @@ parse(Socket,
                    method  = post,
                    enctype = {multipart, Boundary},
                    size    = Size}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_multipart(Socket, Received, Boundary, Size) of
         {ok, Parts}       -> {ok, M#request{body = parts_to_map(Parts)}, none};
         {ok, Parts, Next} -> {ok, M#request{body = parts_to_map(Parts)}, Next};
@@ -141,10 +153,12 @@ parse(Socket,
                    method  = post,
                    enctype = json,
                    size    = Size}) ->
+    io:format("~p parse(~p, ~p, ~p)~n", [?LINE, Socket, Received, M]),
     case read_body(Received, Size) of
         {ok, Body}       -> read_json(M#request{body = Body}, none);
         {ok, Body, Next} -> read_json(M#request{body = Body}, Next);
         {incomplete, Body} ->
+            io:format("~p {incomplete, ~p}~n", [?LINE, Body]),
             case accumulate(Socket, M#request{body = Body}) of
                 {ok, NewM = #request{body = NewBody}} ->
                     read_json(NewM#request{body = NewBody}, none);
@@ -514,6 +528,7 @@ read_size(#request{method = options}) ->
 
 
 read_body(Received, Size) ->
+    io:format("~p read_body(~p, ~p)~n", [?LINE, Received, Size]),
     case Received of
         <<Bin:Size/binary>> ->
             {ok, Bin};
@@ -811,9 +826,11 @@ accumulate(Socket, M = #request{size = Size, body = Body}) ->
     end.
 
 accumulate(Socket, Remaining, Received) when Remaining > 0 ->
+    io:format("~p accumulate(~p, ~p, ~p)~n", [?LINE, Socket, Remaining, Received]),
     ok = inet:setopts(Socket, [{active, once}]),
     receive
         {tcp, Socket, Bin} ->
+            io:format("~p~n", [?LINE]),
             Size = byte_size(Bin),
             if
                 Size == Remaining ->
@@ -828,10 +845,15 @@ accumulate(Socket, Remaining, Received) when Remaining > 0 ->
                     {ok, NewReceived, Next}
              end;
         {tcp_closed, Socket} ->
+            io:format("~p~n", [?LINE]),
             {error, tcp_closed};
         {tcp_error, Socket, Reason} ->
-            {error, {tcp_error, Reason}}
-        after 3000 ->
+            io:format("~p~n", [?LINE]),
+            {error, {tcp_error, Reason}};
+        X ->
+            io:format("~p raseevd: ~p~n", [?LINE, X])
+        after 10_000 ->
+            io:format("~p~n", [?LINE]),
             {error, timeout}
     end;
 accumulate(_, 0, Received) ->