Remove cowboy_req:fragment/1

Clients do not send it. We skip the value if we receive it now,
as it shouldn't happen, and won't for all the mainstream clients.

guide/req.md

@@ -41,8 +41,7 @@ The following access functions are defined in `cowboy_req`:
  *  `qs/1`: the entire query string unmodified
  *  `qs_val/{2,3}`: the value for the requested query string key
  *  `qs_vals/1`: all key/values found in the query string
- *  `fragment/1`: the fragment part of the URL (e.g. `#nav-links`)
- *  `host_url/1`: the requested URL without the path, qs and fragment
+ *  `host_url/1`: the requested URL without the path and query string
  *  `url/1`: the requested URL
  *  `binding/{2,3}`: the value for the requested binding found during routing
  *  `bindings/1`: all key/values found during routing

src/cowboy_protocol.erl

@@ -202,7 +202,7 @@ parse_method(<< C, Rest/bits >>, State, SoFar) ->
 parse_uri(<< $\r, _/bits >>, State, _) ->
 	error_terminate(400, State);
 parse_uri(<< "* ", Rest/bits >>, State, Method) ->
-	parse_version(Rest, State, Method, <<"*">>, <<>>, <<>>);
+	parse_version(Rest, State, Method, <<"*">>, <<>>);
 parse_uri(<< "http://", Rest/bits >>, State, Method) ->
 	parse_uri_skip_host(Rest, State, Method);
 parse_uri(<< "https://", Rest/bits >>, State, Method) ->
@@ -220,61 +220,61 @@ parse_uri_skip_host(<< C, Rest/bits >>, State, Method) ->
 parse_uri_path(<< C, Rest/bits >>, State, Method, SoFar) ->
 	case C of
 		$\r -> error_terminate(400, State);
-		$\s -> parse_version(Rest, State, Method, SoFar, <<>>, <<>>);
+		$\s -> parse_version(Rest, State, Method, SoFar, <<>>);
 		$? -> parse_uri_query(Rest, State, Method, SoFar, <<>>);
-		$# -> parse_uri_fragment(Rest, State, Method, SoFar, <<>>, <<>>);
+		$# -> skip_uri_fragment(Rest, State, Method, SoFar, <<>>);
 		_ -> parse_uri_path(Rest, State, Method, << SoFar/binary, C >>)
 	end.
 
 parse_uri_query(<< C, Rest/bits >>, S, M, P, SoFar) ->
 	case C of
 		$\r -> error_terminate(400, S);
-		$\s -> parse_version(Rest, S, M, P, SoFar, <<>>);
-		$# -> parse_uri_fragment(Rest, S, M, P, SoFar, <<>>);
+		$\s -> parse_version(Rest, S, M, P, SoFar);
+		$# -> skip_uri_fragment(Rest, S, M, P, SoFar);
 		_ -> parse_uri_query(Rest, S, M, P, << SoFar/binary, C >>)
 	end.
 
-parse_uri_fragment(<< C, Rest/bits >>, S, M, P, Q, SoFar) ->
+skip_uri_fragment(<< C, Rest/bits >>, S, M, P, Q) ->
 	case C of
 		$\r -> error_terminate(400, S);
-		$\s -> parse_version(Rest, S, M, P, Q, SoFar);
-		_ -> parse_uri_fragment(Rest, S, M, P, Q, << SoFar/binary, C >>)
+		$\s -> parse_version(Rest, S, M, P, Q);
+		_ -> skip_uri_fragment(Rest, S, M, P, Q)
 	end.
 
-parse_version(<< "HTTP/1.1\r\n", Rest/bits >>, S, M, P, Q, F) ->
-	parse_header(Rest, S, M, P, Q, F, {1, 1}, []);
-parse_version(<< "HTTP/1.0\r\n", Rest/bits >>, S, M, P, Q, F) ->
-	parse_header(Rest, S, M, P, Q, F, {1, 0}, []);
-parse_version(_, State, _, _, _, _) ->
+parse_version(<< "HTTP/1.1\r\n", Rest/bits >>, S, M, P, Q) ->
+	parse_header(Rest, S, M, P, Q, {1, 1}, []);
+parse_version(<< "HTTP/1.0\r\n", Rest/bits >>, S, M, P, Q) ->
+	parse_header(Rest, S, M, P, Q, {1, 0}, []);
+parse_version(_, State, _, _, _) ->
 	error_terminate(505, State).
 
 %% Stop receiving data if we have more than allowed number of headers.
-wait_header(_, State=#state{max_headers=MaxHeaders}, _, _, _, _, _, Headers)
+wait_header(_, State=#state{max_headers=MaxHeaders}, _, _, _, _, Headers)
 		when length(Headers) >= MaxHeaders ->
 	error_terminate(400, State);
 wait_header(Buffer, State=#state{socket=Socket, transport=Transport,
-		until=Until}, M, P, Q, F, V, H) ->
+		until=Until}, M, P, Q, V, H) ->
 	case recv(Socket, Transport, Until) of
 		{ok, Data} ->
 			parse_header(<< Buffer/binary, Data/binary >>,
-				State, M, P, Q, F, V, H);
+				State, M, P, Q, V, H);
 		{error, timeout} ->
 			error_terminate(408, State);
 		{error, _} ->
 			terminate(State)
 	end.
 
-parse_header(<< $\r, $\n, Rest/bits >>, S, M, P, Q, F, V, Headers) ->
-	request(Rest, S, M, P, Q, F, V, lists:reverse(Headers));
+parse_header(<< $\r, $\n, Rest/bits >>, S, M, P, Q, V, Headers) ->
+	request(Rest, S, M, P, Q, V, lists:reverse(Headers));
 parse_header(Buffer, State=#state{max_header_name_length=MaxLength},
-		M, P, Q, F, V, H) ->
+		M, P, Q, V, H) ->
 	case match_colon(Buffer, 0) of
 		nomatch when byte_size(Buffer) > MaxLength ->
 			error_terminate(400, State);
 		nomatch ->
-			wait_header(Buffer, State, M, P, Q, F, V, H);
+			wait_header(Buffer, State, M, P, Q, V, H);
 		_ ->
-			parse_hd_name(Buffer, State, M, P, Q, F, V, H, <<>>)
+			parse_hd_name(Buffer, State, M, P, Q, V, H, <<>>)
 	end.
 
 match_colon(<< $:, _/bits >>, N) ->
@@ -290,73 +290,73 @@ match_colon(_, _) ->
 %% ... Sorry for your eyes.
 %%
 %% But let's be honest, that's still pretty readable.
-parse_hd_name(<< C, Rest/bits >>, S, M, P, Q, F, V, H, SoFar) ->
+parse_hd_name(<< C, Rest/bits >>, S, M, P, Q, V, H, SoFar) ->
 	case C of
-		$: -> parse_hd_before_value(Rest, S, M, P, Q, F, V, H, SoFar);
-		$\s -> parse_hd_name_ws(Rest, S, M, P, Q, F, V, H, SoFar);
-		$\t -> parse_hd_name_ws(Rest, S, M, P, Q, F, V, H, SoFar);
-		$A -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $a >>);
-		$B -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $b >>);
-		$C -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $c >>);
-		$D -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $d >>);
-		$E -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $e >>);
-		$F -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $f >>);
-		$G -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $g >>);
-		$H -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $h >>);
-		$I -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $i >>);
-		$J -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $j >>);
-		$K -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $k >>);
-		$L -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $l >>);
-		$M -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $m >>);
-		$N -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $n >>);
-		$O -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $o >>);
-		$P -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $p >>);
-		$Q -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $q >>);
-		$R -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $r >>);
-		$S -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $s >>);
-		$T -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $t >>);
-		$U -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $u >>);
-		$V -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $v >>);
-		$W -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $w >>);
-		$X -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $x >>);
-		$Y -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $y >>);
-		$Z -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, $z >>);
-		C -> parse_hd_name(Rest, S, M, P, Q, F, V, H, << SoFar/binary, C >>)
+		$: -> parse_hd_before_value(Rest, S, M, P, Q, V, H, SoFar);
+		$\s -> parse_hd_name_ws(Rest, S, M, P, Q, V, H, SoFar);
+		$\t -> parse_hd_name_ws(Rest, S, M, P, Q, V, H, SoFar);
+		$A -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $a >>);
+		$B -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $b >>);
+		$C -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $c >>);
+		$D -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $d >>);
+		$E -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $e >>);
+		$F -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $f >>);
+		$G -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $g >>);
+		$H -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $h >>);
+		$I -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $i >>);
+		$J -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $j >>);
+		$K -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $k >>);
+		$L -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $l >>);
+		$M -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $m >>);
+		$N -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $n >>);
+		$O -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $o >>);
+		$P -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $p >>);
+		$Q -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $q >>);
+		$R -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $r >>);
+		$S -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $s >>);
+		$T -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $t >>);
+		$U -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $u >>);
+		$V -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $v >>);
+		$W -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $w >>);
+		$X -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $x >>);
+		$Y -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $y >>);
+		$Z -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, $z >>);
+		C -> parse_hd_name(Rest, S, M, P, Q, V, H, << SoFar/binary, C >>)
 	end.
 
-parse_hd_name_ws(<< C, Rest/bits >>, S, M, P, Q, F, V, H, Name) ->
+parse_hd_name_ws(<< C, Rest/bits >>, S, M, P, Q, V, H, Name) ->
 	case C of
-		$\s -> parse_hd_name_ws(Rest, S, M, P, Q, F, V, H, Name);
-		$\t -> parse_hd_name_ws(Rest, S, M, P, Q, F, V, H, Name);
-		$: -> parse_hd_before_value(Rest, S, M, P, Q, F, V, H, Name)
+		$\s -> parse_hd_name_ws(Rest, S, M, P, Q, V, H, Name);
+		$\t -> parse_hd_name_ws(Rest, S, M, P, Q, V, H, Name);
+		$: -> parse_hd_before_value(Rest, S, M, P, Q, V, H, Name)
 	end.
 
 wait_hd_before_value(Buffer, State=#state{
 		socket=Socket, transport=Transport, until=Until},
-		M, P, Q, F, V, H, N) ->
+		M, P, Q, V, H, N) ->
 	case recv(Socket, Transport, Until) of
 		{ok, Data} ->
 			parse_hd_before_value(<< Buffer/binary, Data/binary >>,
-				State, M, P, Q, F, V, H, N);
+				State, M, P, Q, V, H, N);
 		{error, timeout} ->
 			error_terminate(408, State);
 		{error, _} ->
 			terminate(State)
 	end.
 
-parse_hd_before_value(<< $\s, Rest/bits >>, S, M, P, Q, F, V, H, N) ->
-	parse_hd_before_value(Rest, S, M, P, Q, F, V, H, N);
-parse_hd_before_value(<< $\t, Rest/bits >>, S, M, P, Q, F, V, H, N) ->
-	parse_hd_before_value(Rest, S, M, P, Q, F, V, H, N);
+parse_hd_before_value(<< $\s, Rest/bits >>, S, M, P, Q, V, H, N) ->
+	parse_hd_before_value(Rest, S, M, P, Q, V, H, N);
+parse_hd_before_value(<< $\t, Rest/bits >>, S, M, P, Q, V, H, N) ->
+	parse_hd_before_value(Rest, S, M, P, Q, V, H, N);
 parse_hd_before_value(Buffer, State=#state{
-		max_header_value_length=MaxLength}, M, P, Q, F, V, H, N) ->
+		max_header_value_length=MaxLength}, M, P, Q, V, H, N) ->
 	case match_eol(Buffer, 0) of
 		nomatch when byte_size(Buffer) > MaxLength ->
 			error_terminate(400, State);
 		nomatch ->
-			wait_hd_before_value(Buffer, State, M, P, Q, F, V, H, N);
+			wait_hd_before_value(Buffer, State, M, P, Q, V, H, N);
 		_ ->
-			parse_hd_value(Buffer, State, M, P, Q, F, V, H, N, <<>>)
+			parse_hd_value(Buffer, State, M, P, Q, V, H, N, <<>>)
 	end.
 
 %% We completely ignore the first argument which is always
@@ -365,10 +365,10 @@ parse_hd_before_value(Buffer, State=#state{
 %% operations for no reasons.
 wait_hd_value(_, State=#state{
 		socket=Socket, transport=Transport, until=Until},
-		M, P, Q, F, V, H, N, SoFar) ->
+		M, P, Q, V, H, N, SoFar) ->
 	case recv(Socket, Transport, Until) of
 		{ok, Data} ->
-			parse_hd_value(Data, State, M, P, Q, F, V, H, N, SoFar);
+			parse_hd_value(Data, State, M, P, Q, V, H, N, SoFar);
 		{error, timeout} ->
 			error_terminate(408, State);
 		{error, _} ->
@@ -380,51 +380,51 @@ wait_hd_value(_, State=#state{
 %% the critical path, but forces us to have a special function.
 wait_hd_value_nl(_, State=#state{
 		socket=Socket, transport=Transport, until=Until},
-		M, P, Q, F, V, Headers, Name, SoFar) ->
+		M, P, Q, V, Headers, Name, SoFar) ->
 	case recv(Socket, Transport, Until) of
 		{ok, << C, Data/bits >>} when C =:= $\s; C =:= $\t  ->
-			parse_hd_value(Data, State, M, P, Q, F, V, Headers, Name, SoFar);
+			parse_hd_value(Data, State, M, P, Q, V, Headers, Name, SoFar);
 		{ok, Data} ->
-			parse_header(Data, State, M, P, Q, F, V, [{Name, SoFar}|Headers]);
+			parse_header(Data, State, M, P, Q, V, [{Name, SoFar}|Headers]);
 		{error, timeout} ->
 			error_terminate(408, State);
 		{error, _} ->
 			terminate(State)
 	end.
 
-parse_hd_value(<< $\r, Rest/bits >>, S, M, P, Q, F, V, Headers, Name, SoFar) ->
+parse_hd_value(<< $\r, Rest/bits >>, S, M, P, Q, V, Headers, Name, SoFar) ->
 	case Rest of
 		<< $\n >> ->
-			wait_hd_value_nl(<<>>, S, M, P, Q, F, V, Headers, Name, SoFar);
+			wait_hd_value_nl(<<>>, S, M, P, Q, V, Headers, Name, SoFar);
 		<< $\n, C, Rest2/bits >> when C =:= $\s; C =:= $\t ->
-			parse_hd_value(Rest2, S, M, P, Q, F, V, Headers, Name, SoFar);
+			parse_hd_value(Rest2, S, M, P, Q, V, Headers, Name, SoFar);
 		<< $\n, Rest2/bits >> ->
-			parse_header(Rest2, S, M, P, Q, F, V, [{Name, SoFar}|Headers])
+			parse_header(Rest2, S, M, P, Q, V, [{Name, SoFar}|Headers])
 	end;
-parse_hd_value(<< C, Rest/bits >>, S, M, P, Q, F, V, H, N, SoFar) ->
-	parse_hd_value(Rest, S, M, P, Q, F, V, H, N, << SoFar/binary, C >>);
+parse_hd_value(<< C, Rest/bits >>, S, M, P, Q, V, H, N, SoFar) ->
+	parse_hd_value(Rest, S, M, P, Q, V, H, N, << SoFar/binary, C >>);
 parse_hd_value(<<>>, State=#state{max_header_value_length=MaxLength},
-		_, _, _, _, _, _, _, SoFar) when byte_size(SoFar) > MaxLength ->
+		_, _, _, _, _, _, SoFar) when byte_size(SoFar) > MaxLength ->
 	error_terminate(400, State);
-parse_hd_value(<<>>, S, M, P, Q, F, V, H, N, SoFar) ->
-	wait_hd_value(<<>>, S, M, P, Q, F, V, H, N, SoFar).
+parse_hd_value(<<>>, S, M, P, Q, V, H, N, SoFar) ->
+	wait_hd_value(<<>>, S, M, P, Q, V, H, N, SoFar).
 
-request(B, State=#state{transport=Transport}, M, P, Q, F, Version, Headers) ->
+request(B, State=#state{transport=Transport}, M, P, Q, Version, Headers) ->
 	case lists:keyfind(<<"host">>, 1, Headers) of
 		false when Version =:= {1, 1} ->
 			error_terminate(400, State);
 		false ->
-			request(B, State, M, P, Q, F, Version, Headers,
+			request(B, State, M, P, Q, Version, Headers,
 				<<>>, default_port(Transport:name()));
 		{_, RawHost} ->
 			case catch parse_host(RawHost, <<>>) of
 				{'EXIT', _} ->
 					error_terminate(400, State);
 				{Host, undefined} ->
-					request(B, State, M, P, Q, F, Version, Headers,
+					request(B, State, M, P, Q, Version, Headers,
 						Host, default_port(Transport:name()));
 				{Host, Port} ->
-					request(B, State, M, P, Q, F, Version, Headers,
+					request(B, State, M, P, Q, Version, Headers,
 						Host, Port)
 			end
 	end.
@@ -476,11 +476,11 @@ parse_host(<< C, Rest/bits >>, Acc) ->
 request(Buffer, State=#state{socket=Socket, transport=Transport,
 		req_keepalive=ReqKeepalive, max_keepalive=MaxKeepalive,
 		compress=Compress, onresponse=OnResponse},
-		Method, Path, Query, Fragment, Version, Headers, Host, Port) ->
+		Method, Path, Query, Version, Headers, Host, Port) ->
 	case Transport:peername(Socket) of
 		{ok, Peer} ->
 			Req = cowboy_req:new(Socket, Transport, Peer, Method, Path,
-				Query, Fragment, Version, Headers, Host, Port, Buffer,
+				Query, Version, Headers, Host, Port, Buffer,
 				ReqKeepalive < MaxKeepalive, Compress, OnResponse),
 			onrequest(Req, State);
 		{error, _} ->
@@ -583,7 +583,7 @@ error_terminate(Code, State=#state{socket=Socket, transport=Transport,
 		{cowboy_req, resp_sent} -> ok
 	after 0 ->
 		_ = cowboy_req:reply(Code, cowboy_req:new(Socket, Transport,
-			undefined, <<"GET">>, <<>>, <<>>, <<>>, {1, 1}, [], <<>>,
+			undefined, <<"GET">>, <<>>, <<>>, {1, 1}, [], <<>>,
 			undefined, <<>>, false, Compress, OnResponse)),
 		ok
 	end,

src/cowboy_req.erl

@@ -41,7 +41,7 @@
 -module(cowboy_req).
 
 %% Request API.
--export([new/15]).
+-export([new/14]).
 -export([method/1]).
 -export([version/1]).
 -export([peer/1]).
@@ -54,7 +54,6 @@
 -export([qs_val/2]).
 -export([qs_val/3]).
 -export([qs_vals/1]).
--export([fragment/1]).
 -export([host_url/1]).
 -export([url/1]).
 -export([binding/2]).
@@ -143,7 +142,6 @@
 	path_info = undefined :: undefined | cowboy_router:tokens(),
 	qs = undefined :: binary(),
 	qs_vals = undefined :: undefined | list({binary(), binary() | true}),
-	fragment = undefined :: binary(),
 	bindings = undefined :: undefined | cowboy_router:bindings(),
 	headers = [] :: cowboy_http:headers(),
 	p_headers = [] :: [any()], %% @todo Improve those specs.
@@ -183,16 +181,16 @@
 %% in an optimized way and add the parsed value to p_headers' cache.
 -spec new(inet:socket(), module(),
 	undefined | {inet:ip_address(), inet:port_number()},
-	binary(), binary(), binary(), binary(),
+	binary(), binary(), binary(),
 	cowboy_http:version(), cowboy_http:headers(), binary(),
 	inet:port_number() | undefined, binary(), boolean(), boolean(),
 	undefined | cowboy_protocol:onresponse_fun())
 	-> req().
-new(Socket, Transport, Peer, Method, Path, Query, Fragment,
+new(Socket, Transport, Peer, Method, Path, Query,
 		Version, Headers, Host, Port, Buffer, CanKeepalive,
 		Compress, OnResponse) ->
 	Req = #http_req{socket=Socket, transport=Transport, pid=self(), peer=Peer,
-		method=Method, path=Path, qs=Query, fragment=Fragment, version=Version,
+		method=Method, path=Path, qs=Query, version=Version,
 		headers=Headers, host=Host, port=Port, buffer=Buffer,
 		resp_compress=Compress, onresponse=OnResponse},
 	case CanKeepalive and (Version =:= {1, 1}) of
@@ -289,11 +287,6 @@ qs_vals(Req=#http_req{qs=RawQs, qs_vals=undefined}) ->
 qs_vals(Req=#http_req{qs_vals=QsVals}) ->
 	{QsVals, Req}.
 
-%% @doc Return the raw fragment directly taken from the request.
--spec fragment(Req) -> {binary(), Req} when Req::req().
-fragment(Req) ->
-	{Req#http_req.fragment, Req}.
-
 %% @doc Return the request URL as a binary without the path and query string.
 %%
 %% The URL includes the scheme, host and port only.
@@ -316,7 +309,7 @@ host_url(Req=#http_req{transport=Transport, host=Host, port=Port}) ->
 
 %% @doc Return the full request URL as a binary.
 %%
-%% The URL includes the scheme, host, port, path, query string and fragment.
+%% The URL includes the scheme, host, port, path and query string.
 -spec url(Req) -> {undefined | binary(), Req} when Req::req().
 url(Req=#http_req{}) ->
 	{HostURL, Req2} = host_url(Req),
@@ -324,16 +317,12 @@ url(Req=#http_req{}) ->
 
 url(undefined, Req=#http_req{}) ->
 	{undefined, Req};
-url(HostURL, Req=#http_req{path=Path, qs=QS, fragment=Fragment}) ->
+url(HostURL, Req=#http_req{path=Path, qs=QS}) ->
 	QS2 = case QS of
 		<<>> -> <<>>;
 		_ -> << "?", QS/binary >>
 	end,
-	Fragment2 = case Fragment of
-		<<>> -> <<>>;
-		_ -> << "#", Fragment/binary >>
-	end,
-	{<< HostURL/binary, Path/binary, QS2/binary, Fragment2/binary >>, Req}.
+	{<< HostURL/binary, Path/binary, QS2/binary >>, Req}.
 
 %% @equiv binding(Name, Req, undefined)
 -spec binding(atom(), Req) -> {binary() | undefined, Req} when Req::req().
@@ -1123,7 +1112,6 @@ g(body_state, #http_req{body_state=Ret}) -> Ret;
 g(buffer, #http_req{buffer=Ret}) -> Ret;
 g(connection, #http_req{connection=Ret}) -> Ret;
 g(cookies, #http_req{cookies=Ret}) -> Ret;
-g(fragment, #http_req{fragment=Ret}) -> Ret;
 g(headers, #http_req{headers=Ret}) -> Ret;
 g(host, #http_req{host=Ret}) -> Ret;
 g(host_info, #http_req{host_info=Ret}) -> Ret;
@@ -1154,7 +1142,6 @@ set([{body_state, Val}|Tail], Req) -> set(Tail, Req#http_req{body_state=Val});
 set([{buffer, Val}|Tail], Req) -> set(Tail, Req#http_req{buffer=Val});
 set([{connection, Val}|Tail], Req) -> set(Tail, Req#http_req{connection=Val});
 set([{cookies, Val}|Tail], Req) -> set(Tail, Req#http_req{cookies=Val});
-set([{fragment, Val}|Tail], Req) -> set(Tail, Req#http_req{fragment=Val});
 set([{headers, Val}|Tail], Req) -> set(Tail, Req#http_req{headers=Val});
 set([{host, Val}|Tail], Req) -> set(Tail, Req#http_req{host=Val});
 set([{host_info, Val}|Tail], Req) -> set(Tail, Req#http_req{host_info=Val});
@@ -1441,38 +1428,28 @@ status(B) when is_binary(B) -> B.
 url_test() ->
 	{undefined, _} =
 		url(#http_req{transport=ranch_tcp, host= <<>>, port= undefined,
-			path= <<>>, qs= <<>>, fragment= <<>>, pid=self()}),
+			path= <<>>, qs= <<>>, pid=self()}),
 	{<<"http://localhost/path">>, _ } =
 		url(#http_req{transport=ranch_tcp, host= <<"localhost">>, port=80,
-			path= <<"/path">>, qs= <<>>, fragment= <<>>, pid=self()}),
+			path= <<"/path">>, qs= <<>>, pid=self()}),
 	{<<"http://localhost:443/path">>, _} =
 		url(#http_req{transport=ranch_tcp, host= <<"localhost">>, port=443,
-			path= <<"/path">>, qs= <<>>, fragment= <<>>, pid=self()}),
+			path= <<"/path">>, qs= <<>>, pid=self()}),
 	{<<"http://localhost:8080/path">>, _} =
 		url(#http_req{transport=ranch_tcp, host= <<"localhost">>, port=8080,
-			path= <<"/path">>, qs= <<>>, fragment= <<>>, pid=self()}),
+			path= <<"/path">>, qs= <<>>, pid=self()}),
 	{<<"http://localhost:8080/path?dummy=2785">>, _} =
 		url(#http_req{transport=ranch_tcp, host= <<"localhost">>, port=8080,
-			path= <<"/path">>, qs= <<"dummy=2785">>, fragment= <<>>,
-			pid=self()}),
-	{<<"http://localhost:8080/path?dummy=2785#fragment">>, _} =
-		url(#http_req{transport=ranch_tcp, host= <<"localhost">>, port=8080,
-			path= <<"/path">>, qs= <<"dummy=2785">>, fragment= <<"fragment">>,
-			pid=self()}),
+			path= <<"/path">>, qs= <<"dummy=2785">>, pid=self()}),
 	{<<"https://localhost/path">>, _} =
 		url(#http_req{transport=ranch_ssl, host= <<"localhost">>, port=443,
-			path= <<"/path">>, qs= <<>>, fragment= <<>>, pid=self()}),
+			path= <<"/path">>, qs= <<>>, pid=self()}),
 	{<<"https://localhost:8443/path">>, _} =
 		url(#http_req{transport=ranch_ssl, host= <<"localhost">>, port=8443,
-			path= <<"/path">>, qs= <<>>, fragment= <<>>, pid=self()}),
+			path= <<"/path">>, qs= <<>>, pid=self()}),
 	{<<"https://localhost:8443/path?dummy=2785">>, _} =
 		url(#http_req{transport=ranch_ssl, host= <<"localhost">>, port=8443,
-			path= <<"/path">>, qs= <<"dummy=2785">>, fragment= <<>>,
-			pid=self()}),
-	{<<"https://localhost:8443/path?dummy=2785#fragment">>, _} =
-		url(#http_req{transport=ranch_ssl, host= <<"localhost">>, port=8443,
-			path= <<"/path">>, qs= <<"dummy=2785">>, fragment= <<"fragment">>,
-			pid=self()}),
+			path= <<"/path">>, qs= <<"dummy=2785">>, pid=self()}),
 	ok.
 
 parse_connection_test_() ->