src/mochiweb_http.erl - couchdb-mochiweb - Git at Google

 %% @author Bob Ippolito <bob@mochimedia.com>
 %% @copyright 2007 Mochi Media, Inc.
 %%
 %% Permission is hereby granted, free of charge, to any person obtaining a
 %% copy of this software and associated documentation files (the "Software"),
 %% to deal in the Software without restriction, including without limitation
 %% the rights to use, copy, modify, merge, publish, distribute, sublicense,
 %% and/or sell copies of the Software, and to permit persons to whom the
 %% Software is furnished to do so, subject to the following conditions:
 %%
 %% The above copyright notice and this permission notice shall be included in
 %% all copies or substantial portions of the Software.
 %%
 %% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 %% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 %% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 %% THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 %% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 %% FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 %% DEALINGS IN THE SOFTWARE.

 %% @doc HTTP server.

 -module(mochiweb_http).

 -author('bob@mochimedia.com').

 -export([start/1, start_link/1, stop/0, stop/1]).

 -export([loop/3]).

 -export([after_response/2, reentry/1]).

 -export([parse_range_request/1, range_skip_length/2]).

 -define(REQUEST_RECV_TIMEOUT,
 	300000).   %% timeout waiting for request line

 -define(HEADERS_RECV_TIMEOUT,
 	30000).    %% timeout waiting for headers

 -define(MAX_HEADERS, 1000).

 -define(DEFAULTS, [{name, ?MODULE}, {port, 8888}]).

 -ifdef(gen_tcp_r15b_workaround).

 r15b_workaround() -> false.

 -else.

 r15b_workaround() -> false.

 -endif.

 parse_options(Options) ->
     {loop, HttpLoop} = proplists:lookup(loop, Options),
     Loop = {?MODULE, loop, [HttpLoop]},
     Options1 = [{loop, Loop} | proplists:delete(loop,
 						Options)],
     mochilists:set_defaults(?DEFAULTS, Options1).

 stop() -> mochiweb_socket_server:stop(?MODULE).

 stop(Name) -> mochiweb_socket_server:stop(Name).

 %% @spec start(Options) -> ServerRet
 %%     Options = [option()]
 %%     Option = {name, atom()} | {ip, string() | tuple()} | {backlog, integer()}
 %%              | {nodelay, boolean()} | {acceptor_pool_size, integer()}
 %%              | {ssl, boolean()} | {profile_fun, undefined | (Props) -> ok}
 %%              | {link, false} | {recbuf, undefined | non_negative_integer()}
 %% @doc Start a mochiweb server.
 %%      profile_fun is used to profile accept timing.
 %%      After each accept, if defined, profile_fun is called with a proplist of a subset of the mochiweb_socket_server state and timing information.
 %%      The proplist is as follows: [{name, Name}, {port, Port}, {active_sockets, ActiveSockets}, {timing, Timing}].
 %% @end
 start(Options) ->
     ok = ensure_started(mochiweb_clock),
     mochiweb_socket_server:start(parse_options(Options)).

 start_link(Options) ->
     ok = ensure_started(mochiweb_clock),
     mochiweb_socket_server:start_link(parse_options(Options)).

 ensure_started(M) when is_atom(M) ->
     case M:start() of
       {ok, _Pid} -> ok;
       {error, {already_started, _Pid}} -> ok
     end.

 loop(Socket, Opts, Body) ->
     ok =
 	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
 							       [{packet,
 								 http}])),
     request(Socket, Opts, Body).

 request(Socket, Opts, Body) ->
     ok =
 	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
 							       [{active,
 								 once}])),
     receive
       {Protocol, _, {http_request, Method, Path, Version}}
 	  when Protocol == http orelse Protocol == ssl ->
 	  ok =
 	      mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
 								     [{packet,
 								       httph}])),
 	  headers(Socket, Opts, {Method, Path, Version}, [], Body,
 		  0);
       {Protocol, _, {http_error, "\r\n"}}
 	  when Protocol == http orelse Protocol == ssl ->
 	  request(Socket, Opts, Body);
       {Protocol, _, {http_error, "\n"}}
 	  when Protocol == http orelse Protocol == ssl ->
 	  request(Socket, Opts, Body);
       {tcp_closed, _} ->
 	  mochiweb_socket:close(Socket), exit(normal);
       {tcp_error, _, emsgsize} = Other ->
 	  handle_invalid_msg_request(Other, Socket, Opts);
       {ssl_closed, _} ->
 	  mochiweb_socket:close(Socket), exit(normal)
       after ?REQUEST_RECV_TIMEOUT ->
 		mochiweb_socket:close(Socket), exit(normal)
     end.

 reentry(Body) ->
     fun (Req) -> (?MODULE):after_response(Body, Req) end.

 headers(Socket, Opts, Request, Headers, _Body,
 	?MAX_HEADERS) ->
     %% Too many headers sent, bad request.
     ok =
 	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
 							       [{packet,
 								 raw}])),
     handle_invalid_request(Socket, Opts, Request, Headers);
 headers(Socket, Opts, Request, Headers, Body,
 	HeaderCount) ->
     ok =
 	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
 							       [{active,
 								 once}])),
     receive
       {Protocol, _, http_eoh}
 	  when Protocol == http orelse Protocol == ssl ->
 	  Req = new_request(Socket, Opts, Request, Headers),
 	  call_body(Body, Req),
 	  (?MODULE):after_response(Body, Req);
       {Protocol, _, {http_header, _, Name, _, Value}}
 	  when Protocol == http orelse Protocol == ssl ->
 	  headers(Socket, Opts, Request,
 		  [{Name, Value} | Headers], Body, 1 + HeaderCount);
       {tcp_closed, _} ->
 	  mochiweb_socket:close(Socket), exit(normal);
       {tcp_error, _, emsgsize} = Other ->
 	  handle_invalid_msg_request(Other, Socket, Opts, Request,
 				     Headers)
       after ?HEADERS_RECV_TIMEOUT ->
 		mochiweb_socket:close(Socket), exit(normal)
     end.

 call_body({M, F, A}, Req) when is_atom(M) ->
     erlang:apply(M, F, [Req | A]);
 call_body({M, F}, Req) when is_atom(M) -> M:F(Req);
 call_body(Body, Req) -> Body(Req).

 -spec handle_invalid_msg_request(term(), term(),
 				 term()) -> no_return().

 handle_invalid_msg_request(Msg, Socket, Opts) ->
     handle_invalid_msg_request(Msg, Socket, Opts,
 			       {'GET', {abs_path, "/"}, {0, 9}}, []).

 -spec handle_invalid_msg_request(term(), term(), term(),
 				 term(), term()) -> no_return().

 handle_invalid_msg_request(Msg, Socket, Opts, Request,
 			   RevHeaders) ->
     case {Msg, r15b_workaround()} of
       {{tcp_error, _, emsgsize}, true} ->
 	  %% R15B02 returns this then closes the socket, so close and exit
 	  mochiweb_socket:close(Socket),
 	  exit(normal);
       _ ->
 	  handle_invalid_request(Socket, Opts, Request,
 				 RevHeaders)
     end.

 -spec handle_invalid_request(term(), term(), term(),
 			     term()) -> no_return().

 handle_invalid_request(Socket, Opts, Request,
 		       RevHeaders) ->
     {ReqM, _} = Req = new_request(Socket, Opts, Request,
 				  RevHeaders),
     ReqM:respond({400, [], []}, Req),
     mochiweb_socket:close(Socket),
     exit(normal).

 new_request(Socket, Opts, Request, RevHeaders) ->
     ok =
 	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
 							       [{packet,
 								 raw}])),
     mochiweb:new_request({Socket, Opts, Request,
 			  lists:reverse(RevHeaders)}).

 after_response(Body, {ReqM, _} = Req) ->
     Socket = ReqM:get(socket, Req),
     case ReqM:should_close(Req) of
       true -> mochiweb_socket:close(Socket), exit(normal);
       false ->
 	  ReqM:cleanup(Req),
 	  erlang:garbage_collect(),
 	  (?MODULE):loop(Socket, mochiweb_request:get(opts, Req),
 			 Body)
     end.

 parse_range_request(RawRange) when is_list(RawRange) ->
     try "bytes=" ++ RangeString = RawRange,
 	RangeTokens = [string:strip(R)
 		       || R <- string:tokens(RangeString, ",")],
 	Ranges = [R || R <- RangeTokens, string:len(R) > 0],
 	[parse_range_request_1(V1) || V1 <- Ranges]
     catch
       _:_ -> fail
     end.

 parse_range_request_1("-" ++ V) ->
     {none, list_to_integer(V)};
 parse_range_request_1(R) ->
     case string:tokens(R, "-") of
       [S1, S2] -> {list_to_integer(S1), list_to_integer(S2)};
       [S] -> {list_to_integer(S), none}
     end.

 range_skip_length(Spec, Size) ->
     case Spec of
       {none, R} when R =< Size, R >= 0 -> {Size - R, R};
       {none, _OutOfRange} -> {0, Size};
       {R, none} when R >= 0, R < Size -> {R, Size - R};
       {_OutOfRange, none} -> invalid_range;
       {Start, End}
 	  when Start >= 0, Start < Size, Start =< End ->
 	  {Start, erlang:min(End + 1, Size) - Start};
       {_InvalidStart, _InvalidEnd} -> invalid_range
     end.

 %%
 %% Tests
 %%
 -ifdef(TEST).

 -include_lib("eunit/include/eunit.hrl").

 range_test() ->
     %% valid, single ranges
     ?assertEqual([{20, 30}],
 		 (parse_range_request("bytes=20-30"))),
     ?assertEqual([{20, none}],
 		 (parse_range_request("bytes=20-"))),
     ?assertEqual([{none, 20}],
 		 (parse_range_request("bytes=-20"))),
     %% trivial single range
     ?assertEqual([{0, none}],
 		 (parse_range_request("bytes=0-"))),
     %% invalid, single ranges
     ?assertEqual(fail, (parse_range_request(""))),
     ?assertEqual(fail, (parse_range_request("garbage"))),
     ?assertEqual(fail,
 		 (parse_range_request("bytes=-20-30"))),
     %% valid, multiple range
     ?assertEqual([{20, 30}, {50, 100}, {110, 200}],
 		 (parse_range_request("bytes=20-30,50-100,110-200"))),
     ?assertEqual([{20, none}, {50, 100}, {none, 200}],
 		 (parse_range_request("bytes=20-,50-100,-200"))),
     %% valid, multiple range with whitespace
     ?assertEqual([{20, 30}, {50, 100}, {110, 200}],
 		 (parse_range_request("bytes=20-30, 50-100 , 110-200"))),
     %% valid, multiple range with extra commas
     ?assertEqual([{20, 30}, {50, 100}, {110, 200}],
 		 (parse_range_request("bytes=20-30,,50-100,110-200"))),
     ?assertEqual([{20, 30}, {50, 100}, {110, 200}],
 		 (parse_range_request("bytes=20-30, ,50-100,,,110-200"))),
     %% no ranges
     ?assertEqual([], (parse_range_request("bytes="))),
     ok.

 range_skip_length_test() ->
     Body = <<"012345678901234567890123456789012345678901234"
 	     "567890123456789">>,
     BodySize = byte_size(Body), %% 60
     BodySize = 60,
     %% these values assume BodySize =:= 60
     ?assertEqual({1, 9},
 		 (range_skip_length({1, 9}, BodySize))), %% 1-9
     ?assertEqual({10, 10},
 		 (range_skip_length({10, 19}, BodySize))), %% 10-19
     ?assertEqual({40, 20},
 		 (range_skip_length({none, 20}, BodySize))), %% -20
     ?assertEqual({30, 30},
 		 (range_skip_length({30, none}, BodySize))), %% 30-
     %% valid edge cases for range_skip_length
     ?assertEqual({BodySize, 0},
 		 (range_skip_length({none, 0}, BodySize))),
     ?assertEqual({0, BodySize},
 		 (range_skip_length({none, BodySize}, BodySize))),
     ?assertEqual({0, BodySize},
 		 (range_skip_length({0, none}, BodySize))),
     ?assertEqual({0, BodySize},
 		 (range_skip_length({0, BodySize + 1}, BodySize))),
     BodySizeLess1 = BodySize - 1,
     ?assertEqual({BodySizeLess1, 1},
 		 (range_skip_length({BodySize - 1, none}, BodySize))),
     ?assertEqual({BodySizeLess1, 1},
 		 (range_skip_length({BodySize - 1, BodySize + 5},
 				    BodySize))),
     ?assertEqual({BodySizeLess1, 1},
 		 (range_skip_length({BodySize - 1, BodySize},
 				    BodySize))),
     %% out of range, return whole thing
     ?assertEqual({0, BodySize},
 		 (range_skip_length({none, BodySize + 1}, BodySize))),
     ?assertEqual({0, BodySize},
 		 (range_skip_length({none, -1}, BodySize))),
     ?assertEqual({0, BodySize},
 		 (range_skip_length({0, BodySize + 1}, BodySize))),
     %% invalid ranges
     ?assertEqual(invalid_range,
 		 (range_skip_length({-1, 30}, BodySize))),
     ?assertEqual(invalid_range,
 		 (range_skip_length({-1, BodySize + 1}, BodySize))),
     ?assertEqual(invalid_range,
 		 (range_skip_length({BodySize, 40}, BodySize))),
     ?assertEqual(invalid_range,
 		 (range_skip_length({-1, none}, BodySize))),
     ?assertEqual(invalid_range,
 		 (range_skip_length({BodySize, none}, BodySize))),
     ?assertEqual(invalid_range,
 		 (range_skip_length({BodySize + 1, BodySize + 5},
 				    BodySize))),
     ok.

 -endif.
	%% @author Bob Ippolito <bob@mochimedia.com>
	%% @copyright 2007 Mochi Media, Inc.
	%%
	%% Permission is hereby granted, free of charge, to any person obtaining a
	%% copy of this software and associated documentation files (the "Software"),
	%% to deal in the Software without restriction, including without limitation
	%% the rights to use, copy, modify, merge, publish, distribute, sublicense,
	%% and/or sell copies of the Software, and to permit persons to whom the
	%% Software is furnished to do so, subject to the following conditions:
	%%
	%% The above copyright notice and this permission notice shall be included in
	%% all copies or substantial portions of the Software.
	%%
	%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	%% THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	%% FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	%% DEALINGS IN THE SOFTWARE.

	%% @doc HTTP server.

	-module(mochiweb_http).

	-author('bob@mochimedia.com').

	-export([start/1, start_link/1, stop/0, stop/1]).

	-export([loop/3]).

	-export([after_response/2, reentry/1]).

	-export([parse_range_request/1, range_skip_length/2]).

	-define(REQUEST_RECV_TIMEOUT,
	300000). %% timeout waiting for request line

	-define(HEADERS_RECV_TIMEOUT,
	30000). %% timeout waiting for headers

	-define(MAX_HEADERS, 1000).

	-define(DEFAULTS, [{name, ?MODULE}, {port, 8888}]).

	-ifdef(gen_tcp_r15b_workaround).

	r15b_workaround() -> false.

	-else.

	r15b_workaround() -> false.

	-endif.

	parse_options(Options) ->
	{loop, HttpLoop} = proplists:lookup(loop, Options),
	Loop = {?MODULE, loop, [HttpLoop]},
	Options1 = [{loop, Loop} \| proplists:delete(loop,
	Options)],
	mochilists:set_defaults(?DEFAULTS, Options1).

	stop() -> mochiweb_socket_server:stop(?MODULE).

	stop(Name) -> mochiweb_socket_server:stop(Name).

	%% @spec start(Options) -> ServerRet
	%% Options = [option()]
	%% Option = {name, atom()} \| {ip, string() \| tuple()} \| {backlog, integer()}
	%% \| {nodelay, boolean()} \| {acceptor_pool_size, integer()}
	%% \| {ssl, boolean()} \| {profile_fun, undefined \| (Props) -> ok}
	%% \| {link, false} \| {recbuf, undefined \| non_negative_integer()}
	%% @doc Start a mochiweb server.
	%% profile_fun is used to profile accept timing.
	%% After each accept, if defined, profile_fun is called with a proplist of a subset of the mochiweb_socket_server state and timing information.
	%% The proplist is as follows: [{name, Name}, {port, Port}, {active_sockets, ActiveSockets}, {timing, Timing}].
	%% @end
	start(Options) ->
	ok = ensure_started(mochiweb_clock),
	mochiweb_socket_server:start(parse_options(Options)).

	start_link(Options) ->
	ok = ensure_started(mochiweb_clock),
	mochiweb_socket_server:start_link(parse_options(Options)).

	ensure_started(M) when is_atom(M) ->
	case M:start() of
	{ok, _Pid} -> ok;
	{error, {already_started, _Pid}} -> ok
	end.

	loop(Socket, Opts, Body) ->
	ok =
	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
	[{packet,
	http}])),
	request(Socket, Opts, Body).

	request(Socket, Opts, Body) ->
	ok =
	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
	[{active,
	once}])),
	receive
	{Protocol, _, {http_request, Method, Path, Version}}
	when Protocol == http orelse Protocol == ssl ->
	ok =
	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
	[{packet,
	httph}])),
	headers(Socket, Opts, {Method, Path, Version}, [], Body,
	0);
	{Protocol, _, {http_error, "\r\n"}}
	when Protocol == http orelse Protocol == ssl ->
	request(Socket, Opts, Body);
	{Protocol, _, {http_error, "\n"}}
	when Protocol == http orelse Protocol == ssl ->
	request(Socket, Opts, Body);
	{tcp_closed, _} ->
	mochiweb_socket:close(Socket), exit(normal);
	{tcp_error, _, emsgsize} = Other ->
	handle_invalid_msg_request(Other, Socket, Opts);
	{ssl_closed, _} ->
	mochiweb_socket:close(Socket), exit(normal)
	after ?REQUEST_RECV_TIMEOUT ->
	mochiweb_socket:close(Socket), exit(normal)
	end.

	reentry(Body) ->
	fun (Req) -> (?MODULE):after_response(Body, Req) end.

	headers(Socket, Opts, Request, Headers, _Body,
	?MAX_HEADERS) ->
	%% Too many headers sent, bad request.
	ok =
	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
	[{packet,
	raw}])),
	handle_invalid_request(Socket, Opts, Request, Headers);
	headers(Socket, Opts, Request, Headers, Body,
	HeaderCount) ->
	ok =
	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
	[{active,
	once}])),
	receive
	{Protocol, _, http_eoh}
	when Protocol == http orelse Protocol == ssl ->
	Req = new_request(Socket, Opts, Request, Headers),
	call_body(Body, Req),
	(?MODULE):after_response(Body, Req);
	{Protocol, _, {http_header, _, Name, _, Value}}
	when Protocol == http orelse Protocol == ssl ->
	headers(Socket, Opts, Request,
	[{Name, Value} \| Headers], Body, 1 + HeaderCount);
	{tcp_closed, _} ->
	mochiweb_socket:close(Socket), exit(normal);
	{tcp_error, _, emsgsize} = Other ->
	handle_invalid_msg_request(Other, Socket, Opts, Request,
	Headers)
	after ?HEADERS_RECV_TIMEOUT ->
	mochiweb_socket:close(Socket), exit(normal)
	end.

	call_body({M, F, A}, Req) when is_atom(M) ->
	erlang:apply(M, F, [Req \| A]);
	call_body({M, F}, Req) when is_atom(M) -> M:F(Req);
	call_body(Body, Req) -> Body(Req).

	-spec handle_invalid_msg_request(term(), term(),
	term()) -> no_return().

	handle_invalid_msg_request(Msg, Socket, Opts) ->
	handle_invalid_msg_request(Msg, Socket, Opts,
	{'GET', {abs_path, "/"}, {0, 9}}, []).

	-spec handle_invalid_msg_request(term(), term(), term(),
	term(), term()) -> no_return().

	handle_invalid_msg_request(Msg, Socket, Opts, Request,
	RevHeaders) ->
	case {Msg, r15b_workaround()} of
	{{tcp_error, _, emsgsize}, true} ->
	%% R15B02 returns this then closes the socket, so close and exit
	mochiweb_socket:close(Socket),
	exit(normal);
	_ ->
	handle_invalid_request(Socket, Opts, Request,
	RevHeaders)
	end.

	-spec handle_invalid_request(term(), term(), term(),
	term()) -> no_return().

	handle_invalid_request(Socket, Opts, Request,
	RevHeaders) ->
	{ReqM, _} = Req = new_request(Socket, Opts, Request,
	RevHeaders),
	ReqM:respond({400, [], []}, Req),
	mochiweb_socket:close(Socket),
	exit(normal).

	new_request(Socket, Opts, Request, RevHeaders) ->
	ok =
	mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
	[{packet,
	raw}])),
	mochiweb:new_request({Socket, Opts, Request,
	lists:reverse(RevHeaders)}).

	after_response(Body, {ReqM, _} = Req) ->
	Socket = ReqM:get(socket, Req),
	case ReqM:should_close(Req) of
	true -> mochiweb_socket:close(Socket), exit(normal);
	false ->
	ReqM:cleanup(Req),
	erlang:garbage_collect(),
	(?MODULE):loop(Socket, mochiweb_request:get(opts, Req),
	Body)
	end.

	parse_range_request(RawRange) when is_list(RawRange) ->
	try "bytes=" ++ RangeString = RawRange,
	RangeTokens = [string:strip(R)
	\|\| R <- string:tokens(RangeString, ",")],
	Ranges = [R \|\| R <- RangeTokens, string:len(R) > 0],
	[parse_range_request_1(V1) \|\| V1 <- Ranges]
	catch
	_:_ -> fail
	end.

	parse_range_request_1("-" ++ V) ->
	{none, list_to_integer(V)};
	parse_range_request_1(R) ->
	case string:tokens(R, "-") of
	[S1, S2] -> {list_to_integer(S1), list_to_integer(S2)};
	[S] -> {list_to_integer(S), none}
	end.

	range_skip_length(Spec, Size) ->
	case Spec of
	{none, R} when R =< Size, R >= 0 -> {Size - R, R};
	{none, _OutOfRange} -> {0, Size};
	{R, none} when R >= 0, R < Size -> {R, Size - R};
	{_OutOfRange, none} -> invalid_range;
	{Start, End}
	when Start >= 0, Start < Size, Start =< End ->
	{Start, erlang:min(End + 1, Size) - Start};
	{_InvalidStart, _InvalidEnd} -> invalid_range
	end.

	%%
	%% Tests
	%%
	-ifdef(TEST).

	-include_lib("eunit/include/eunit.hrl").

	range_test() ->
	%% valid, single ranges
	?assertEqual([{20, 30}],
	(parse_range_request("bytes=20-30"))),
	?assertEqual([{20, none}],
	(parse_range_request("bytes=20-"))),
	?assertEqual([{none, 20}],
	(parse_range_request("bytes=-20"))),
	%% trivial single range
	?assertEqual([{0, none}],
	(parse_range_request("bytes=0-"))),
	%% invalid, single ranges
	?assertEqual(fail, (parse_range_request(""))),
	?assertEqual(fail, (parse_range_request("garbage"))),
	?assertEqual(fail,
	(parse_range_request("bytes=-20-30"))),
	%% valid, multiple range
	?assertEqual([{20, 30}, {50, 100}, {110, 200}],
	(parse_range_request("bytes=20-30,50-100,110-200"))),
	?assertEqual([{20, none}, {50, 100}, {none, 200}],
	(parse_range_request("bytes=20-,50-100,-200"))),
	%% valid, multiple range with whitespace
	?assertEqual([{20, 30}, {50, 100}, {110, 200}],
	(parse_range_request("bytes=20-30, 50-100 , 110-200"))),
	%% valid, multiple range with extra commas
	?assertEqual([{20, 30}, {50, 100}, {110, 200}],
	(parse_range_request("bytes=20-30,,50-100,110-200"))),
	?assertEqual([{20, 30}, {50, 100}, {110, 200}],
	(parse_range_request("bytes=20-30, ,50-100,,,110-200"))),
	%% no ranges
	?assertEqual([], (parse_range_request("bytes="))),
	ok.

	range_skip_length_test() ->
	Body = <<"012345678901234567890123456789012345678901234"
	"567890123456789">>,
	BodySize = byte_size(Body), %% 60
	BodySize = 60,
	%% these values assume BodySize =:= 60
	?assertEqual({1, 9},
	(range_skip_length({1, 9}, BodySize))), %% 1-9
	?assertEqual({10, 10},
	(range_skip_length({10, 19}, BodySize))), %% 10-19
	?assertEqual({40, 20},
	(range_skip_length({none, 20}, BodySize))), %% -20
	?assertEqual({30, 30},
	(range_skip_length({30, none}, BodySize))), %% 30-
	%% valid edge cases for range_skip_length
	?assertEqual({BodySize, 0},
	(range_skip_length({none, 0}, BodySize))),
	?assertEqual({0, BodySize},
	(range_skip_length({none, BodySize}, BodySize))),
	?assertEqual({0, BodySize},
	(range_skip_length({0, none}, BodySize))),
	?assertEqual({0, BodySize},
	(range_skip_length({0, BodySize + 1}, BodySize))),
	BodySizeLess1 = BodySize - 1,
	?assertEqual({BodySizeLess1, 1},
	(range_skip_length({BodySize - 1, none}, BodySize))),
	?assertEqual({BodySizeLess1, 1},
	(range_skip_length({BodySize - 1, BodySize + 5},
	BodySize))),
	?assertEqual({BodySizeLess1, 1},
	(range_skip_length({BodySize - 1, BodySize},
	BodySize))),
	%% out of range, return whole thing
	?assertEqual({0, BodySize},
	(range_skip_length({none, BodySize + 1}, BodySize))),
	?assertEqual({0, BodySize},
	(range_skip_length({none, -1}, BodySize))),
	?assertEqual({0, BodySize},
	(range_skip_length({0, BodySize + 1}, BodySize))),
	%% invalid ranges
	?assertEqual(invalid_range,
	(range_skip_length({-1, 30}, BodySize))),
	?assertEqual(invalid_range,
	(range_skip_length({-1, BodySize + 1}, BodySize))),
	?assertEqual(invalid_range,
	(range_skip_length({BodySize, 40}, BodySize))),
	?assertEqual(invalid_range,
	(range_skip_length({-1, none}, BodySize))),
	?assertEqual(invalid_range,
	(range_skip_length({BodySize, none}, BodySize))),
	?assertEqual(invalid_range,
	(range_skip_length({BodySize + 1, BodySize + 5},
	BodySize))),
	ok.

	-endif.