>} -> Chunk;
_ -> exit({shutdown, read_chunk_recv_error})
end.
read_sub_chunks(Length, MaxChunkSize, Fun, FunState,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS)
when Length > MaxChunkSize ->
Bin = recv(MaxChunkSize, THIS),
NewState = Fun({size(Bin), Bin}, FunState),
read_sub_chunks(Length - MaxChunkSize, MaxChunkSize,
Fun, NewState, THIS);
read_sub_chunks(Length, _MaxChunkSize, Fun, FunState,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
Fun({Length, read_chunk(Length, THIS)}, FunState).
%% @spec serve_file(Path, DocRoot, request()) -> Response
%% @doc Serve a file relative to DocRoot.
serve_file(Path, DocRoot,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
serve_file(Path, DocRoot, [], THIS).
%% @spec serve_file(Path, DocRoot, ExtraHeaders, request()) -> Response
%% @doc Serve a file relative to DocRoot.
serve_file(Path, DocRoot, ExtraHeaders,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
case mochiweb_util:safe_relative_path(Path) of
undefined -> not_found(ExtraHeaders, THIS);
RelPath ->
FullPath = filename:join([DocRoot, RelPath]),
case filelib:is_dir(FullPath) of
true ->
maybe_redirect(RelPath, FullPath, ExtraHeaders, THIS);
false -> maybe_serve_file(FullPath, ExtraHeaders, THIS)
end
end.
%% Internal API
%% This has the same effect as the DirectoryIndex directive in httpd
directory_index(FullPath) ->
filename:join([FullPath, "index.html"]).
maybe_redirect([], FullPath, ExtraHeaders,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
maybe_serve_file(directory_index(FullPath),
ExtraHeaders, THIS);
maybe_redirect(RelPath, FullPath, ExtraHeaders,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
Headers]} =
THIS) ->
case string:right(RelPath, 1) of
"/" ->
maybe_serve_file(directory_index(FullPath),
ExtraHeaders, THIS);
_ ->
Host = mochiweb_headers:get_value("host", Headers),
Location = "http://" ++ Host ++ "/" ++ RelPath ++ "/",
LocationBin = list_to_binary(Location),
MoreHeaders = [{"Location", Location},
{"Content-Type", "text/html"}
| ExtraHeaders],
Top = <<"301 "
"Moved PermanentlyMov"
"ed Permanently
The document has "
"moved >,
Bottom = <<">here.
\n">>,
Body = <>,
respond({301, MoreHeaders, Body}, THIS)
end.
maybe_serve_file(File, ExtraHeaders,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
case file:read_file_info(File) of
{ok, FileInfo} ->
LastModified =
httpd_util:rfc1123_date(FileInfo#file_info.mtime),
case get_header_value("if-modified-since", THIS) of
LastModified -> respond({304, ExtraHeaders, ""}, THIS);
_ ->
case file:open(File, [raw, binary]) of
{ok, IoDevice} ->
ContentType = mochiweb_util:guess_mime(File),
Res = ok({ContentType,
[{"last-modified", LastModified}
| ExtraHeaders],
{file, IoDevice}},
THIS),
ok = file:close(IoDevice),
Res;
_ -> not_found(ExtraHeaders, THIS)
end
end;
{error, _} -> not_found(ExtraHeaders, THIS)
end.
server_headers() ->
[{"Server", "MochiWeb/1.0 (" ++ (?QUIP) ++ ")"},
{"Date", mochiweb_clock:rfc1123()}].
make_code(X) when is_integer(X) ->
[integer_to_list(X),
[" " | httpd_util:reason_phrase(X)]];
make_code(Io) when is_list(Io); is_binary(Io) -> Io.
make_version({1, 0}) -> <<"HTTP/1.0 ">>;
make_version(_) -> <<"HTTP/1.1 ">>.
range_parts({file, IoDevice}, Ranges) ->
Size = mochiweb_io:iodevice_size(IoDevice),
F = fun (Spec, Acc) ->
case mochiweb_http:range_skip_length(Spec, Size) of
invalid_range -> Acc;
V -> [V | Acc]
end
end,
LocNums = lists:foldr(F, [], Ranges),
{ok, Data} = file:pread(IoDevice, LocNums),
Bodies = lists:zipwith(fun ({Skip, Length},
PartialBody) ->
case Length of
0 -> {Skip, Skip, <<>>};
_ -> {Skip, Skip + Length - 1, PartialBody}
end
end,
LocNums, Data),
{Bodies, Size};
range_parts(Body0, Ranges) ->
Body = iolist_to_binary(Body0),
Size = size(Body),
F = fun (Spec, Acc) ->
case mochiweb_http:range_skip_length(Spec, Size) of
invalid_range -> Acc;
{Skip, Length} ->
<<_:Skip/binary, PartialBody:Length/binary, _/binary>> =
Body,
[{Skip, Skip + Length - 1, PartialBody} | Acc]
end
end,
{lists:foldr(F, [], Ranges), Size}.
%% @spec accepted_encodings([encoding()], request()) -> [encoding()] | bad_accept_encoding_value
%% @type encoding() = string().
%%
%% @doc Returns a list of encodings accepted by a request. Encodings that are
%% not supported by the server will not be included in the return list.
%% This list is computed from the "Accept-Encoding" header and
%% its elements are ordered, descendingly, according to their Q values.
%%
%% Section 14.3 of the RFC 2616 (HTTP 1.1) describes the "Accept-Encoding"
%% header and the process of determining which server supported encodings
%% can be used for encoding the body for the request's response.
%%
%% Examples
%%
%% 1) For a missing "Accept-Encoding" header:
%% accepted_encodings(["gzip", "identity"]) -> ["identity"]
%%
%% 2) For an "Accept-Encoding" header with value "gzip, deflate":
%% accepted_encodings(["gzip", "identity"]) -> ["gzip", "identity"]
%%
%% 3) For an "Accept-Encoding" header with value "gzip;q=0.5, deflate":
%% accepted_encodings(["gzip", "deflate", "identity"]) ->
%% ["deflate", "gzip", "identity"]
%%
accepted_encodings(SupportedEncodings,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
AcceptEncodingHeader = case
get_header_value("Accept-Encoding", THIS)
of
undefined -> "";
Value -> Value
end,
case mochiweb_util:parse_qvalues(AcceptEncodingHeader)
of
invalid_qvalue_string -> bad_accept_encoding_value;
QList ->
mochiweb_util:pick_accepted_encodings(QList,
SupportedEncodings, "identity")
end.
%% @spec accepts_content_type(string() | binary(), request()) -> boolean() | bad_accept_header
%%
%% @doc Determines whether a request accepts a given media type by analyzing its
%% "Accept" header.
%%
%% Examples
%%
%% 1) For a missing "Accept" header:
%% accepts_content_type("application/json") -> true
%%
%% 2) For an "Accept" header with value "text/plain, application/*":
%% accepts_content_type("application/json") -> true
%%
%% 3) For an "Accept" header with value "text/plain, */*; q=0.0":
%% accepts_content_type("application/json") -> false
%%
%% 4) For an "Accept" header with value "text/plain; q=0.5, */*; q=0.1":
%% accepts_content_type("application/json") -> true
%%
%% 5) For an "Accept" header with value "text/*; q=0.0, */*":
%% accepts_content_type("text/plain") -> false
%%
accepts_content_type(ContentType1,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
ContentType = re:replace(ContentType1, "\\s", "",
[global, {return, list}]),
AcceptHeader = accept_header(THIS),
case mochiweb_util:parse_qvalues(AcceptHeader) of
invalid_qvalue_string -> bad_accept_header;
QList ->
[MainType, _SubType] = string:tokens(ContentType, "/"),
SuperType = MainType ++ "/*",
lists:any(fun ({"*/*", Q}) when Q > 0.0 -> true;
({Type, Q}) when Q > 0.0 ->
Type =:= ContentType orelse Type =:= SuperType;
(_) -> false
end,
QList)
andalso
not lists:member({ContentType, 0.0}, QList) andalso
not lists:member({SuperType, 0.0}, QList)
end.
%% @spec accepted_content_types([string() | binary()], request()) -> [string()] | bad_accept_header
%%
%% @doc Filters which of the given media types this request accepts. This filtering
%% is performed by analyzing the "Accept" header. The returned list is sorted
%% according to the preferences specified in the "Accept" header (higher Q values
%% first). If two or more types have the same preference (Q value), they're order
%% in the returned list is the same as they're order in the input list.
%%
%% Examples
%%
%% 1) For a missing "Accept" header:
%% accepted_content_types(["text/html", "application/json"]) ->
%% ["text/html", "application/json"]
%%
%% 2) For an "Accept" header with value "text/html, application/*":
%% accepted_content_types(["application/json", "text/html"]) ->
%% ["application/json", "text/html"]
%%
%% 3) For an "Accept" header with value "text/html, */*; q=0.0":
%% accepted_content_types(["text/html", "application/json"]) ->
%% ["text/html"]
%%
%% 4) For an "Accept" header with value "text/html; q=0.5, */*; q=0.1":
%% accepts_content_types(["application/json", "text/html"]) ->
%% ["text/html", "application/json"]
%%
accepted_content_types(Types1,
{?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
Types = [accepted_content_types_1(V1) || V1 <- Types1],
AcceptHeader = accept_header(THIS),
case mochiweb_util:parse_qvalues(AcceptHeader) of
invalid_qvalue_string -> bad_accept_header;
QList ->
TypesQ = lists:foldr(fun (T, Acc) ->
case proplists:get_value(T, QList) of
undefined ->
[MainType, _SubType] =
string:tokens(T, "/"),
case proplists:get_value(MainType
++ "/*",
QList)
of
undefined ->
case
proplists:get_value("*/*",
QList)
of
Q
when is_float(Q),
Q > 0.0 ->
[{Q, T} | Acc];
_ -> Acc
end;
Q when Q > 0.0 -> [{Q, T} | Acc];
_ -> Acc
end;
Q when Q > 0.0 -> [{Q, T} | Acc];
_ -> Acc
end
end,
[], Types),
% Note: Stable sort. If 2 types have the same Q value we leave them in the
% same order as in the input list.
SortFun = fun ({Q1, _}, {Q2, _}) -> Q1 >= Q2 end,
[Type || {_Q, Type} <- lists:sort(SortFun, TypesQ)]
end.
accepted_content_types_1(T) ->
re:replace(T, "\\s", "", [global, {return, list}]).
accept_header({?MODULE,
[_Socket, _Opts, _Method, _RawPath, _Version,
_Headers]} =
THIS) ->
case get_header_value("Accept", THIS) of
undefined -> "*/*";
Value -> Value
end.
%% @spec is_closed(request()) -> true | false | undefined
%% @doc Check if a request connection is closing or already closed. This may be
%% useful when processing long running request callbacks, when the client
%% disconnects after a short timeout. This function works on Linux, NetBSD,
%% OpenBSD, FreeBSD and MacOS. On other operating systems, like Windows for
%% instance, it will return undefined.
is_closed({?MODULE,
[Socket, _Opts, _Method, _RawPath, _Version, _Headers]}) ->
mochiweb_socket:is_closed(Socket).
mochiweb-3.2.1/src/mochiweb_response.erl 0000664 0000000 0000000 00000006535 14503332274 0020334 0 ustar 00root root 0000000 0000000 %% @author Bob Ippolito
%% @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 Response abstraction.
-module(mochiweb_response).
-author('bob@mochimedia.com').
-define(QUIP, "Any of you quaids got a smint?").
-export([dump/1, get/2, get_header_value/2, new/3]).
-export([send/2, write_chunk/2]).
%% @type response(). A mochiweb_response parameterized module instance.
%% @spec new(Request, Code, Headers) -> response()
%% @doc Create a new mochiweb_response instance.
new(Request, Code, Headers) ->
{?MODULE, [Request, Code, Headers]}.
%% @spec get_header_value(string() | atom() | binary(), response()) ->
%% string() | undefined
%% @doc Get the value of the given response header.
get_header_value(K,
{?MODULE, [_Request, _Code, Headers]}) ->
mochiweb_headers:get_value(K, Headers).
%% @spec get(request | code | headers, response()) -> term()
%% @doc Return the internal representation of the given field.
get(request, {?MODULE, [Request, _Code, _Headers]}) ->
Request;
get(code, {?MODULE, [_Request, Code, _Headers]}) ->
Code;
get(headers, {?MODULE, [_Request, _Code, Headers]}) ->
Headers.
%% @spec dump(response()) -> {mochiweb_request, [{atom(), term()}]}
%% @doc Dump the internal representation to a "human readable" set of terms
%% for debugging/inspection purposes.
dump({?MODULE, [{ReqM, _} = Request, Code, Headers]}) ->
[{request, ReqM:dump(Request)}, {code, Code},
{headers, mochiweb_headers:to_list(Headers)}].
%% @spec send(iodata(), response()) -> ok
%% @doc Send data over the socket if the method is not HEAD.
send(Data,
{?MODULE, [{ReqM, _} = Request, _Code, _Headers]}) ->
case ReqM:get(method, Request) of
'HEAD' -> ok;
_ -> ReqM:send(Data, Request)
end.
%% @spec write_chunk(iodata(), response()) -> ok
%% @doc Write a chunk of a HTTP chunked response. If Data is zero length,
%% then the chunked response will be finished.
write_chunk(Data,
{?MODULE, [{ReqM, _} = Request, _Code, _Headers]} =
THIS) ->
case ReqM:get(version, Request) of
Version when Version >= {1, 1} ->
Length = iolist_size(Data),
send([io_lib:format("~.16b\r\n", [Length]), Data,
<<"\r\n">>],
THIS);
_ -> send(Data, THIS)
end.
%%
%% Tests
%%
-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").
-endif.
mochiweb-3.2.1/src/mochiweb_session.erl 0000664 0000000 0000000 00000021566 14503332274 0020162 0 ustar 00root root 0000000 0000000 %% @author Asier Azkuenaga Batiz
%% @copyright 2013 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 Cookie session. Note that the expiration time travels unencrypted
%% as far as this module is concerned. In order to achieve more security,
%% it is advised to use https.
%% Based on the paper
%%
%% "A Secure Cookie Protocol".
%% This module is only supported on R15B02 and later, the AES CFB mode is not
%% available in earlier releases of crypto.
-module(mochiweb_session).
-export([generate_session_data/4, generate_session_cookie/4,
check_session_cookie/4]).
-export_types([expiration_time/0]).
-type expiration_time() :: integer().
-type key_fun() :: fun((string()) -> iolist()).
%% TODO: Import this from elsewhere after attribute types refactor.
-type header() :: {string(), string()}.
%% @doc Generates a secure encrypted binary combining all the parameters. The
%% expiration time must be a 32-bit integer.
-spec generate_session_data(
ExpirationTime :: expiration_time(),
Data :: iolist(),
FSessionKey :: key_fun(),
ServerKey :: iolist()) -> binary().
generate_session_data(ExpirationTime, Data, FSessionKey, ServerKey)
when is_integer(ExpirationTime), is_function(FSessionKey)->
BData = ensure_binary(Data),
ExpTime = integer_to_list(ExpirationTime),
Key = gen_key(ExpTime, ServerKey),
Hmac = gen_hmac(ExpTime, BData, FSessionKey(ExpTime), Key),
EData = encrypt_data(BData, Key),
mochiweb_base64url:encode(
<>).
%% @doc Convenience wrapper for generate_session_data that returns a
%% mochiweb cookie with "id" as the key, a max_age of 20000 seconds,
%% and the current local time as local time.
-spec generate_session_cookie(
ExpirationTime :: expiration_time(),
Data :: iolist(),
FSessionKey :: key_fun(),
ServerKey :: iolist()) -> header().
generate_session_cookie(ExpirationTime, Data, FSessionKey, ServerKey)
when is_integer(ExpirationTime), is_function(FSessionKey)->
CookieData = generate_session_data(ExpirationTime, Data,
FSessionKey, ServerKey),
mochiweb_cookies:cookie("id", CookieData,
[{max_age, 20000},
{local_time,
calendar:universal_time_to_local_time(
calendar:universal_time())}]).
%% TODO: This return type is messy to express in the type system.
-spec check_session_cookie(
ECookie :: binary(),
ExpirationTime :: string(),
FSessionKey :: key_fun(),
ServerKey :: iolist()) ->
{Success :: boolean(),
ExpTimeAndData :: [integer() | binary()]}.
check_session_cookie(ECookie, ExpirationTime, FSessionKey, ServerKey)
when is_binary(ECookie), is_integer(ExpirationTime),
is_function(FSessionKey) ->
case mochiweb_base64url:decode(ECookie) of
<> ->
ETString = integer_to_list(ExpirationTime1),
Key = gen_key(ETString, ServerKey),
Data = decrypt_data(EData, Key),
Hmac2 = gen_hmac(ETString,
Data,
FSessionKey(ETString),
Key),
{ExpirationTime1 >= ExpirationTime andalso eq(Hmac2, BHmac),
[ExpirationTime1, binary_to_list(Data)]};
_ ->
{false, []}
end;
check_session_cookie(_ECookie, _ExpirationTime, _FSessionKey, _ServerKey) ->
{false, []}.
%% 'Constant' time =:= operator for binary, to mitigate timing attacks.
-spec eq(binary(), binary()) -> boolean().
eq(A, B) when is_binary(A) andalso is_binary(B) ->
eq(A, B, 0).
eq(<>, <>, Acc) ->
eq(As, Bs, Acc bor (A bxor B));
eq(<<>>, <<>>, 0) ->
true;
eq(_As, _Bs, _Acc) ->
false.
-spec ensure_binary(iolist()) -> binary().
ensure_binary(B) when is_binary(B) ->
B;
ensure_binary(L) when is_list(L) ->
iolist_to_binary(L).
-ifdef(new_crypto_unavailable).
-spec encrypt_data(binary(), binary()) -> binary().
encrypt_data(Data, Key) ->
IV = crypto:strong_rand_bytes(16),
Crypt = crypto:block_encrypt(aes_cfb128, Key, IV, Data),
<>.
-spec decrypt_data(binary(), binary()) -> binary().
decrypt_data(<>, Key) ->
crypto:block_decrypt(aes_cfb128, Key, IV, Crypt).
-spec gen_key(iolist(), iolist()) -> binary().
gen_key(ExpirationTime, ServerKey) ->
crypto:hmac(md5, ServerKey, [ExpirationTime]).
-spec gen_hmac(iolist(), binary(), iolist(), binary()) -> binary().
gen_hmac(ExpirationTime, Data, SessionKey, Key) ->
crypto:hmac(sha, Key, [ExpirationTime, Data, SessionKey]).
-else. % new crypto available (OTP 23+)
-spec encrypt_data(binary(), binary()) -> binary().
encrypt_data(Data, Key) ->
IV = crypto:strong_rand_bytes(16),
Crypt = crypto:crypto_one_time(aes_128_cfb128, Key, IV, Data, true),
<>.
-spec decrypt_data(binary(), binary()) -> binary().
decrypt_data(<>, Key) ->
crypto:crypto_one_time(aes_128_cfb128, Key, IV, Crypt, false).
-spec gen_key(iolist(), iolist()) -> binary().
gen_key(ExpirationTime, ServerKey) ->
crypto:mac(hmac, md5, ServerKey, [ExpirationTime]).
-spec gen_hmac(iolist(), binary(), iolist(), binary()) -> binary().
gen_hmac(ExpirationTime, Data, SessionKey, Key) ->
crypto:mac(hmac, sha, Key, [ExpirationTime, Data, SessionKey]).
-endif.
-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").
generate_check_session_cookie_test_() ->
{setup,
fun setup_server_key/0,
fun generate_check_session_cookie/1}.
setup_server_key() ->
crypto:start(),
["adfasdfasfs",30000].
generate_check_session_cookie([ServerKey, TS]) ->
Id = fun (A) -> A end,
TSFuture = TS + 1000,
TSPast = TS - 1,
[?_assertEqual(
{true, [TSFuture, "alice"]},
check_session_cookie(
generate_session_data(TSFuture, "alice", Id, ServerKey),
TS, Id, ServerKey)),
?_assertEqual(
{true, [TSFuture, "alice and"]},
check_session_cookie(
generate_session_data(TSFuture, "alice and", Id, ServerKey),
TS, Id, ServerKey)),
?_assertEqual(
{true, [TSFuture, "alice and"]},
check_session_cookie(
generate_session_data(TSFuture, "alice and", Id, ServerKey),
TS, Id,ServerKey)),
?_assertEqual(
{true, [TSFuture, "alice and bob"]},
check_session_cookie(
generate_session_data(TSFuture, "alice and bob",
Id, ServerKey),
TS, Id, ServerKey)),
?_assertEqual(
{true, [TSFuture, "alice jlkjfkjsdfg sdkfjgldsjgl"]},
check_session_cookie(
generate_session_data(TSFuture, "alice jlkjfkjsdfg sdkfjgldsjgl",
Id, ServerKey),
TS, Id, ServerKey)),
?_assertEqual(
{true, [TSFuture, "alice .'¡'ç+-$%/(&\""]},
check_session_cookie(
generate_session_data(TSFuture, "alice .'¡'ç+-$%/(&\""
,Id, ServerKey),
TS, Id, ServerKey)),
?_assertEqual(
{true,[TSFuture,"alice456689875"]},
check_session_cookie(
generate_session_data(TSFuture, ["alice","456689875"],
Id, ServerKey),
TS, Id, ServerKey)),
?_assertError(
function_clause,
check_session_cookie(
generate_session_data(TSFuture, {tuple,one},
Id, ServerKey),
TS, Id,ServerKey)),
?_assertEqual(
{false, [TSPast, "bob"]},
check_session_cookie(
generate_session_data(TSPast, "bob", Id,ServerKey),
TS, Id, ServerKey))
].
-endif.
mochiweb-3.2.1/src/mochiweb_socket.erl 0000664 0000000 0000000 00000020603 14503332274 0017756 0 ustar 00root root 0000000 0000000 %% @copyright 2010 Mochi Media, Inc.
%% @doc MochiWeb socket - wrapper for plain and ssl sockets.
-module(mochiweb_socket).
-export([listen/4,
accept/1, transport_accept/1, finish_accept/1,
recv/3, send/2, close/1, port/1, peername/1,
setopts/2, getopts/2, type/1, exit_if_closed/1,
is_closed/1]).
-define(ACCEPT_TIMEOUT, 2000).
-define(SSL_TIMEOUT, 10000).
-define(SSL_HANDSHAKE_TIMEOUT, 20000).
listen(Ssl, Port, Opts, SslOpts) ->
case Ssl of
true ->
Opts1 = add_safe_protocol_versions(Opts),
Opts2 = add_unbroken_ciphers_default(Opts1 ++ SslOpts),
case ssl:listen(Port, Opts2) of
{ok, ListenSocket} ->
{ok, {ssl, ListenSocket}};
{error, _} = Err ->
Err
end;
false ->
gen_tcp:listen(Port, Opts)
end.
-ifdef(new_crypto_unavailable).
add_unbroken_ciphers_default(Opts) ->
Default = filter_unsecure_cipher_suites(ssl:cipher_suites()),
Ciphers = filter_broken_cipher_suites(proplists:get_value(ciphers, Opts, Default)),
[{ciphers, Ciphers} | proplists:delete(ciphers, Opts)].
%% Filter old map style cipher suites
filter_unsecure_cipher_suites(Ciphers) ->
lists:filter(fun
({_,des_cbc,_}) -> false;
({_,_,md5}) -> false;
(_) -> true
end,
Ciphers).
-else.
add_unbroken_ciphers_default(Opts) ->
%% add_safe_protocol_versions/1 must have been called to ensure a {versions, _} tuple is present
Versions = proplists:get_value(versions, Opts),
CipherSuites = lists:append([ssl:cipher_suites(all, Version) || Version <- Versions]),
Default = filter_unsecure_cipher_suites(CipherSuites),
Ciphers = filter_broken_cipher_suites(proplists:get_value(ciphers, Opts, Default)),
[{ciphers, Ciphers} | proplists:delete(ciphers, Opts)].
%% Filter new map style cipher suites
filter_unsecure_cipher_suites(Ciphers) ->
ssl:filter_cipher_suites(Ciphers, [
{key_exchange, fun(des_cbc) -> false; (_) -> true end},
{mac, fun(md5) -> false; (_) -> true end}
]).
-endif.
filter_broken_cipher_suites(Ciphers) ->
case proplists:get_value(ssl_app, ssl:versions()) of
"5.3" ++ _ ->
lists:filter(fun(Suite) ->
string:left(atom_to_list(element(1, Suite)), 4) =/= "ecdh"
end, Ciphers);
_ ->
Ciphers
end.
add_safe_protocol_versions(Opts) ->
case proplists:is_defined(versions, Opts) of
true ->
Opts;
false ->
Versions = filter_unsafe_protcol_versions(proplists:get_value(available, ssl:versions())),
[{versions, Versions} | Opts]
end.
filter_unsafe_protcol_versions(Versions) ->
lists:filter(fun
(sslv3) -> false;
(_) -> true
end,
Versions).
%% Provided for backwards compatibility only
accept(ListenSocket) ->
case transport_accept(ListenSocket) of
{ok, Socket} ->
finish_accept(Socket);
{error, _} = Err ->
Err
end.
transport_accept({ssl, ListenSocket}) ->
case ssl:transport_accept(ListenSocket, ?SSL_TIMEOUT) of
{ok, Socket} ->
{ok, {ssl, Socket}};
{error, _} = Err ->
Err
end;
transport_accept(ListenSocket) ->
gen_tcp:accept(ListenSocket, ?ACCEPT_TIMEOUT).
-ifdef(ssl_handshake_unavailable).
finish_accept({ssl, Socket}) ->
case ssl:ssl_accept(Socket, ?SSL_HANDSHAKE_TIMEOUT) of
ok ->
{ok, {ssl, Socket}};
{error, _} = Err ->
Err
end;
finish_accept(Socket) ->
{ok, Socket}.
-else.
finish_accept({ssl, Socket}) ->
case ssl:handshake(Socket, ?SSL_HANDSHAKE_TIMEOUT) of
{ok, SslSocket} ->
{ok, {ssl, SslSocket}};
{error, _} = Err ->
Err
end;
finish_accept(Socket) ->
{ok, Socket}.
-endif.
recv({ssl, Socket}, Length, Timeout) ->
ssl:recv(Socket, Length, Timeout);
recv(Socket, Length, Timeout) ->
gen_tcp:recv(Socket, Length, Timeout).
send({ssl, Socket}, Data) ->
ssl:send(Socket, Data);
send(Socket, Data) ->
gen_tcp:send(Socket, Data).
close({ssl, Socket}) ->
ssl:close(Socket);
close(Socket) ->
gen_tcp:close(Socket).
port({ssl, Socket}) ->
case ssl:sockname(Socket) of
{ok, {_, Port}} ->
{ok, Port};
{error, _} = Err ->
Err
end;
port(Socket) ->
inet:port(Socket).
peername({ssl, Socket}) ->
ssl:peername(Socket);
peername(Socket) ->
inet:peername(Socket).
setopts({ssl, Socket}, Opts) ->
ssl:setopts(Socket, Opts);
setopts(Socket, Opts) ->
inet:setopts(Socket, Opts).
getopts({ssl, Socket}, Opts) ->
ssl:getopts(Socket, Opts);
getopts(Socket, Opts) ->
inet:getopts(Socket, Opts).
type({ssl, _}) ->
ssl;
type(_) ->
plain.
exit_if_closed({error, closed = Error}) ->
exit({shutdown, Error});
exit_if_closed({error, einval = Error}) ->
exit({shutdown, Error});
exit_if_closed(Res) ->
Res.
%% @doc Check if the socket is closing or already closed. This function works
%% with passive mode sockets on Linux, OpenBSD, NetBSD, FreeBSD and MacOS. On
%% unsupported OS-es, like Windows, it returns undefined.
is_closed(Socket) ->
OsType = os:type(),
case tcp_info_opt(OsType) of
{raw, _, _, _} = InfoOpt ->
case getopts(Socket, [InfoOpt]) of
{ok, [{raw, _, _, <>}]} ->
tcp_is_closed(State, OsType);
{ok, []} ->
undefined;
{error, einval} ->
% Already cleaned up
true;
{error, _} ->
undefined
end;
undefined ->
undefined
end.
% All OS-es have the tcpi_state (uint8) as first member of tcp_info struct
tcp_info_opt({unix, linux}) ->
%% netinet/in.h
%% IPPROTO_TCP = 6
%%
%% netinet/tcp.h
%% #define TCP_INFO 11
%%
{raw, 6, 11, 1};
tcp_info_opt({unix, darwin}) ->
%% netinet/in.h
%% #define IPPROTO_TCP 6
%%
%% netinet/tcp.h
%% #define TCP_CONNECTION_INFO 0x106
%%
{raw, 6, 16#106, 1};
tcp_info_opt({unix, freebsd}) ->
%% sys/netinet/in.h
%% #define IPPROTO_TCP 6
%%
%% sys/netinet/tcp.h
%% #define TCP_INFO 32
%%
{raw, 6, 32, 1};
tcp_info_opt({unix, netbsd}) ->
%% sys/netinet/in.h
%% #define IPPROTO_TCP 6
%%
%% sys/netinet/tcp.h
%% #define TCP_INFO 9
{raw, 6, 9, 1};
tcp_info_opt({unix, openbsd}) ->
%% sys/netinet/in.h
%% #define IPPROTO_TCP 6
%%
%% sys/netinet/tcp.h
%% #define TCP_INFO 0x09
{raw, 6, 16#09, 1};
tcp_info_opt({_, _}) ->
undefined.
tcp_is_closed(State, {unix, linux}) ->
%% netinet/tcp.h
%% enum
%% {
%% TCP_ESTABLISHED = 1,
%% TCP_SYN_SENT,
%% TCP_SYN_RECV,
%% TCP_FIN_WAIT1,
%% TCP_FIN_WAIT2,
%% TCP_TIME_WAIT,
%% TCP_CLOSE,
%% TCP_CLOSE_WAIT,
%% TCP_LAST_ACK,
%% TCP_LISTEN,
%% TCP_CLOSING
%% }
%%
lists:member(State, [4, 5, 6, 7, 8, 9, 11]);
tcp_is_closed(State, {unix, Type})
when
Type =:= darwin;
Type =:= freebsd;
Type =:= netbsd;
Type =:= openbsd
->
%% tcp_fsm.h states are the same on macos, freebsd, netbsd and openbsd
%%
%% netinet/tcp_fsm.h
%% #define TCPS_CLOSED 0 /* closed */
%% #define TCPS_LISTEN 1 /* listening for connection */
%% #define TCPS_SYN_SENT 2 /* active, have sent syn */
%% #define TCPS_SYN_RECEIVED 3 /* have send and received syn */
%% #define TCPS_ESTABLISHED 4 /* established */
%% #define TCPS_CLOSE_WAIT 5 /* rcvd fin, waiting for close */
%% #define TCPS_FIN_WAIT_1 6 /* have closed, sent fin */
%% #define TCPS_CLOSING 7 /* closed xchd FIN; await FIN ACK */
%% #define TCPS_LAST_ACK 8 /* had fin and close; await FIN ACK */
%% #define TCPS_FIN_WAIT_2 9 /* have closed, fin is acked */
%% #define TCPS_TIME_WAIT 10 /* in 2*msl quiet wait after close */
%%
lists:member(State, [0, 5, 6, 7, 8, 9, 10]).
mochiweb-3.2.1/src/mochiweb_socket_server.erl 0000664 0000000 0000000 00000042302 14503332274 0021344 0 ustar 00root root 0000000 0000000 %% @author Bob Ippolito
%% @copyright 2007 Mochi Media, Inc.
%% @doc MochiWeb socket server.
-module(mochiweb_socket_server).
-author('bob@mochimedia.com').
-behaviour(gen_server).
-include("internal.hrl").
-export([start/1, start_link/1, stop/1]).
-export([init/1, handle_call/3, handle_cast/2, terminate/2, code_change/3,
handle_info/2]).
-export([get/2, set/3]).
-record(mochiweb_socket_server,
{port,
loop,
name=undefined,
max=2048,
ip=any,
listen=null,
nodelay=false,
recbuf=?RECBUF_SIZE,
buffer=undefined,
backlog=128,
active_sockets=0,
acceptor_pool_size=16,
ssl=false,
ssl_opts=[{ssl_imp, new}],
acceptor_pool=sets:new(),
profile_fun=undefined}).
-define(is_old_state(State), not is_record(State, mochiweb_socket_server)).
start_link(Options) ->
start_server(start_link, parse_options(Options)).
start(Options) ->
case lists:keytake(link, 1, Options) of
{value, {_Key, false}, Options1} ->
start_server(start, parse_options(Options1));
_ ->
%% TODO: https://github.com/mochi/mochiweb/issues/58
%% [X] Phase 1: Add new APIs (Sep 2011)
%% [_] Phase 2: Add deprecation warning
%% [_] Phase 3: Change default to {link, false} and ignore link
%% [_] Phase 4: Add deprecation warning for {link, _} option
%% [_] Phase 5: Remove support for {link, _} option
start_link(Options)
end.
get(Name, Property) ->
gen_server:call(Name, {get, Property}).
set(Name, profile_fun, Fun) ->
gen_server:cast(Name, {set, profile_fun, Fun});
set(Name, Property, _Value) ->
error_logger:info_msg("?MODULE:set for ~p with ~p not implemented~n",
[Name, Property]).
stop(Name) when is_atom(Name) orelse is_pid(Name) ->
gen_server:call(Name, stop);
stop({Scope, Name}) when Scope =:= local orelse Scope =:= global ->
stop(Name);
stop(Options) ->
State = parse_options(Options),
stop(State#mochiweb_socket_server.name).
%% Internal API
parse_options(State=#mochiweb_socket_server{}) ->
State;
parse_options(Options) ->
parse_options(Options, #mochiweb_socket_server{}).
parse_options([], State=#mochiweb_socket_server{acceptor_pool_size=PoolSize,
max=Max}) ->
case Max < PoolSize of
true ->
error_logger:info_report([{warning, "max is set lower than acceptor_pool_size"},
{max, Max},
{acceptor_pool_size, PoolSize}]);
false ->
ok
end,
State;
parse_options([{name, L} | Rest], State) when is_list(L) ->
Name = {local, list_to_atom(L)},
parse_options(Rest, State#mochiweb_socket_server{name=Name});
parse_options([{name, A} | Rest], State) when A =:= undefined ->
parse_options(Rest, State#mochiweb_socket_server{name=A});
parse_options([{name, A} | Rest], State) when is_atom(A) ->
Name = {local, A},
parse_options(Rest, State#mochiweb_socket_server{name=Name});
parse_options([{name, Name} | Rest], State) ->
parse_options(Rest, State#mochiweb_socket_server{name=Name});
parse_options([{port, L} | Rest], State) when is_list(L) ->
Port = list_to_integer(L),
parse_options(Rest, State#mochiweb_socket_server{port=Port});
parse_options([{port, Port} | Rest], State) ->
parse_options(Rest, State#mochiweb_socket_server{port=Port});
parse_options([{ip, Ip} | Rest], State) ->
ParsedIp = case Ip of
any ->
any;
Ip when is_tuple(Ip) ->
Ip;
Ip when is_list(Ip) ->
{ok, IpTuple} = inet_parse:address(Ip),
IpTuple
end,
parse_options(Rest, State#mochiweb_socket_server{ip=ParsedIp});
parse_options([{loop, Loop} | Rest], State) ->
parse_options(Rest, State#mochiweb_socket_server{loop=Loop});
parse_options([{backlog, Backlog} | Rest], State) ->
parse_options(Rest, State#mochiweb_socket_server{backlog=Backlog});
parse_options([{nodelay, NoDelay} | Rest], State) ->
parse_options(Rest, State#mochiweb_socket_server{nodelay=NoDelay});
parse_options([{recbuf, RecBuf} | Rest], State) when is_integer(RecBuf) orelse
RecBuf == undefined ->
%% XXX: `recbuf' value which is passed to `gen_tcp'
%% and value reported by `inet:getopts(P, [recbuf])' may
%% differ. They depends on underlying OS. From linux mans:
%%
%% The kernel doubles this value (to allow space for
%% bookkeeping overhead) when it is set using setsockopt(2),
%% and this doubled value is returned by getsockopt(2).
%%
%% See: man 7 socket | grep SO_RCVBUF
%%
%% In case undefined is passed instead of the default buffer
%% size ?RECBUF_SIZE, no size is set and the OS can control it dynamically
parse_options(Rest, State#mochiweb_socket_server{recbuf=RecBuf});
parse_options([{buffer, Buffer} | Rest], State) when is_integer(Buffer) orelse
Buffer == undefined ->
%% `buffer` sets Erlang's userland socket buffer size. The size of this
%% buffer affects the maximum URL path that can be parsed. URL sizes that
%% are larger than this plus the size of the HTTP verb and some whitespace
%% will result in an `emsgsize` TCP error.
%%
%% If this value is not set Erlang sets it to 1460 which might be too low.
parse_options(Rest, State#mochiweb_socket_server{buffer=Buffer});
parse_options([{acceptor_pool_size, Max} | Rest], State) ->
MaxInt = ensure_int(Max),
parse_options(Rest,
State#mochiweb_socket_server{acceptor_pool_size=MaxInt});
parse_options([{max, Max} | Rest], State) ->
MaxInt = ensure_int(Max),
parse_options(Rest, State#mochiweb_socket_server{max=MaxInt});
parse_options([{ssl, Ssl} | Rest], State) when is_boolean(Ssl) ->
parse_options(Rest, State#mochiweb_socket_server{ssl=Ssl});
parse_options([{ssl_opts, SslOpts} | Rest], State) when is_list(SslOpts) ->
SslOpts1 = [{ssl_imp, new} | proplists:delete(ssl_imp, SslOpts)],
parse_options(Rest, State#mochiweb_socket_server{ssl_opts=SslOpts1});
parse_options([{profile_fun, ProfileFun} | Rest], State) when is_function(ProfileFun) ->
parse_options(Rest, State#mochiweb_socket_server{profile_fun=ProfileFun}).
start_server(F, State=#mochiweb_socket_server{ssl=Ssl, name=Name}) ->
ok = prep_ssl(Ssl),
case Name of
undefined ->
gen_server:F(?MODULE, State, []);
_ ->
gen_server:F(Name, ?MODULE, State, [])
end.
-ifdef(otp_21).
check_ssl_compatibility() ->
case lists:keyfind(ssl, 1, application:loaded_applications()) of
{_, _, V} when V =:= "9.1" orelse V =:= "9.1.1" ->
{error, "ssl-" ++ V ++ " (OTP 21.2 to 21.2.2) has a regression and is not safe to use with mochiweb. See https://bugs.erlang.org/browse/ERL-830"};
_ ->
ok
end.
-else.
check_ssl_compatibility() ->
ok.
-endif.
prep_ssl(true) ->
ok = mochiweb:ensure_started(crypto),
ok = mochiweb:ensure_started(asn1),
ok = mochiweb:ensure_started(public_key),
ok = mochiweb:ensure_started(ssl),
ok = check_ssl_compatibility(),
ok;
prep_ssl(false) ->
ok.
ensure_int(N) when is_integer(N) ->
N;
ensure_int(S) when is_list(S) ->
list_to_integer(S).
ipv6_supported() ->
case (catch inet:getaddr("localhost", inet6)) of
{ok, _Addr} ->
true;
{error, _} ->
false
end.
init(State=#mochiweb_socket_server{ip=Ip, port=Port, backlog=Backlog,
nodelay=NoDelay, recbuf=RecBuf,
buffer=Buffer}) ->
process_flag(trap_exit, true),
BaseOpts = [binary,
{reuseaddr, true},
{packet, 0},
{backlog, Backlog},
{exit_on_close, false},
{active, false},
{nodelay, NoDelay}],
Opts = case Ip of
any ->
case ipv6_supported() of % IPv4, and IPv6 if supported
true -> [inet, inet6 | BaseOpts];
_ -> BaseOpts
end;
{_, _, _, _} -> % IPv4
[inet, {ip, Ip} | BaseOpts];
{_, _, _, _, _, _, _, _} -> % IPv6
[inet6, {ip, Ip} | BaseOpts]
end,
OptsBuf = set_buffer_opts(RecBuf, Buffer, Opts),
listen(Port, OptsBuf, State).
set_buffer_opts(undefined, undefined, Opts) ->
% If recbuf is undefined, user space buffer is set to the default 1460
% value. That unexpectedly break the {packet, http} parser and any URL
% lines longer than 1460 would error out with emsgsize. So when recbuf is
% undefined, use previous value of recbuf for buffer in order to keep older
% code from breaking.
[{buffer, ?RECBUF_SIZE} | Opts];
set_buffer_opts(RecBuf, undefined, Opts) ->
[{recbuf, RecBuf} | Opts];
set_buffer_opts(undefined, Buffer, Opts) ->
[{buffer, Buffer} | Opts];
set_buffer_opts(RecBuf, Buffer, Opts) ->
% Note: order matters, recbuf will override buffer unless buffer value
% comes first, except on older versions of Erlang (ex. 17.0) where it works
% exactly the opposite.
[{buffer, Buffer}, {recbuf, RecBuf} | Opts].
new_acceptor_pool(State=#mochiweb_socket_server{acceptor_pool_size=Size}) ->
lists:foldl(fun (_, S) -> new_acceptor(S) end, State, lists:seq(1, Size)).
new_acceptor(State=#mochiweb_socket_server{acceptor_pool=Pool,
recbuf=RecBuf,
loop=Loop,
listen=Listen}) ->
LoopOpts = [{recbuf, RecBuf}],
Pid = mochiweb_acceptor:start_link(self(), Listen, Loop, LoopOpts),
State#mochiweb_socket_server{
acceptor_pool=sets:add_element(Pid, Pool)}.
listen(Port, Opts, State=#mochiweb_socket_server{ssl=Ssl, ssl_opts=SslOpts}) ->
case mochiweb_socket:listen(Ssl, Port, Opts, SslOpts) of
{ok, Listen} ->
{ok, ListenPort} = mochiweb_socket:port(Listen),
{ok, new_acceptor_pool(State#mochiweb_socket_server{
listen=Listen,
port=ListenPort})};
{error, Reason} ->
{stop, Reason}
end.
do_get(port, #mochiweb_socket_server{port=Port}) ->
Port;
do_get(waiting_acceptors, #mochiweb_socket_server{acceptor_pool=Pool}) ->
sets:size(Pool);
do_get(active_sockets, #mochiweb_socket_server{active_sockets=ActiveSockets}) ->
ActiveSockets.
state_to_proplist(#mochiweb_socket_server{name=Name,
port=Port,
active_sockets=ActiveSockets}) ->
[{name, Name}, {port, Port}, {active_sockets, ActiveSockets}].
upgrade_state(State = #mochiweb_socket_server{}) ->
State;
upgrade_state({mochiweb_socket_server, Port, Loop, Name,
Max, IP, Listen, NoDelay, Backlog, ActiveSockets,
AcceptorPoolSize, SSL, SSL_opts,
AcceptorPool}) ->
#mochiweb_socket_server{port=Port, loop=Loop, name=Name, max=Max, ip=IP,
listen=Listen, nodelay=NoDelay, backlog=Backlog,
active_sockets=ActiveSockets,
acceptor_pool_size=AcceptorPoolSize,
ssl=SSL,
ssl_opts=SSL_opts,
acceptor_pool=AcceptorPool}.
handle_call(Req, From, State) when ?is_old_state(State) ->
handle_call(Req, From, upgrade_state(State));
handle_call({get, Property}, _From, State) ->
Res = do_get(Property, State),
{reply, Res, State};
handle_call(stop, _From, State) ->
{stop, normal, ok, State};
handle_call(_Message, _From, State) ->
Res = error,
{reply, Res, State}.
handle_cast(Req, State) when ?is_old_state(State) ->
handle_cast(Req, upgrade_state(State));
handle_cast({accepted, Pid, Timing},
State=#mochiweb_socket_server{active_sockets=ActiveSockets}) ->
State1 = State#mochiweb_socket_server{active_sockets=1 + ActiveSockets},
case State#mochiweb_socket_server.profile_fun of
undefined ->
undefined;
F when is_function(F) ->
catch F([{timing, Timing} | state_to_proplist(State1)])
end,
{noreply, recycle_acceptor(Pid, State1)};
handle_cast({set, profile_fun, ProfileFun}, State) ->
State1 = case ProfileFun of
ProfileFun when is_function(ProfileFun); ProfileFun =:= undefined ->
State#mochiweb_socket_server{profile_fun=ProfileFun};
_ ->
State
end,
{noreply, State1}.
terminate(Reason, State) when ?is_old_state(State) ->
terminate(Reason, upgrade_state(State));
terminate(_Reason, #mochiweb_socket_server{listen=Listen}) ->
mochiweb_socket:close(Listen).
code_change(_OldVsn, State, _Extra) ->
State.
recycle_acceptor(Pid, State=#mochiweb_socket_server{
acceptor_pool=Pool,
acceptor_pool_size=PoolSize,
max=Max,
active_sockets=ActiveSockets}) ->
%% A socket is considered to be active from immediately after it
%% has been accepted (see the {accepted, Pid, Timing} cast above).
%% This function will be called when an acceptor is transitioning
%% to an active socket, or when either type of Pid dies. An acceptor
%% Pid will always be in the acceptor_pool set, and an active socket
%% will be in that set during the transition but not afterwards.
Pool1 = sets:del_element(Pid, Pool),
NewSize = sets:size(Pool1),
ActiveSockets1 = case NewSize =:= sets:size(Pool) of
%% Pid has died and it is not in the acceptor set,
%% it must be an active socket.
true -> max(0, ActiveSockets - 1);
false -> ActiveSockets
end,
State1 = State#mochiweb_socket_server{
acceptor_pool=Pool1,
active_sockets=ActiveSockets1},
%% Spawn a new acceptor only if it will not overrun the maximum socket
%% count or the maximum pool size.
case NewSize + ActiveSockets1 < Max andalso NewSize < PoolSize of
true -> new_acceptor(State1);
false -> State1
end.
handle_info(Msg, State) when ?is_old_state(State) ->
handle_info(Msg, upgrade_state(State));
handle_info({'EXIT', Pid, normal}, State) ->
{noreply, recycle_acceptor(Pid, State)};
handle_info({'EXIT', Pid, {shutdown, _Error}}, State) ->
{noreply, recycle_acceptor(Pid, State)};
handle_info({'EXIT', Pid, Reason},
State=#mochiweb_socket_server{acceptor_pool=Pool}) ->
case sets:is_element(Pid, Pool) of
true ->
%% If there was an unexpected error accepting, log and sleep.
error_logger:error_report({?MODULE, ?LINE,
{acceptor_error, Reason}}),
timer:sleep(100);
false ->
ok
end,
{noreply, recycle_acceptor(Pid, State)};
% this is what release_handler needs to get a list of modules,
% since our supervisor modules list is set to 'dynamic'
% see sasl-2.1.9.2/src/release_handler_1.erl get_dynamic_mods
handle_info({From, Tag, get_modules}, State = #mochiweb_socket_server{name={local,Mod}}) ->
From ! {element(2,Tag), [Mod]},
{noreply, State};
% If for some reason we can't get the module name, send empty list to avoid release_handler timeout:
handle_info({From, Tag, get_modules}, State) ->
error_logger:info_msg("mochiweb_socket_server replying to dynamic modules request as '[]'~n",[]),
From ! {element(2,Tag), []},
{noreply, State};
handle_info(Info, State) ->
error_logger:info_report([{'INFO', Info}, {'State', State}]),
{noreply, State}.
%%
%% Tests
%%
-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").
upgrade_state_test() ->
OldState = {mochiweb_socket_server,
port, loop, name,
max, ip, listen,
nodelay, backlog,
active_sockets,
acceptor_pool_size,
ssl, ssl_opts, acceptor_pool},
State = upgrade_state(OldState),
CmpState = #mochiweb_socket_server{port=port, loop=loop,
name=name, max=max, ip=ip,
listen=listen, nodelay=nodelay,
backlog=backlog,
active_sockets=active_sockets,
acceptor_pool_size=acceptor_pool_size,
ssl=ssl, ssl_opts=ssl_opts,
acceptor_pool=acceptor_pool,
profile_fun=undefined},
?assertEqual(CmpState, State).
set_buffer_opts_test() ->
?assertEqual([{buffer, 8192}], set_buffer_opts(undefined, undefined, [])),
?assertEqual([{recbuf, 5}], set_buffer_opts(5, undefined, [])),
?assertEqual([{buffer, 6}], set_buffer_opts(undefined, 6, [])),
?assertEqual([{buffer, 6}, {recbuf, 5}], set_buffer_opts(5, 6, [])).
-endif.
mochiweb-3.2.1/src/mochiweb_util.erl 0000664 0000000 0000000 00000106413 14503332274 0017447 0 ustar 00root root 0000000 0000000 %% @author Bob Ippolito
%% @copyright 2007 Mochi Media, Inc.
%% @doc Utilities for parsing and quoting.
-module(mochiweb_util).
-author('bob@mochimedia.com').
-export([join/2, quote_plus/1, urlencode/1, parse_qs/1, unquote/1, unquote_path/1]).
-export([path_split/1]).
-export([urlsplit/1, urlsplit_path/1, urlunsplit/1, urlunsplit_path/1]).
-export([guess_mime/1, parse_header/1]).
-export([shell_quote/1, cmd/1, cmd_string/1, cmd_port/2, cmd_status/1, cmd_status/2]).
-export([record_to_proplist/2, record_to_proplist/3]).
-export([safe_relative_path/1, partition/2]).
-export([parse_qvalues/1, pick_accepted_encodings/3]).
-export([make_io/1]).
-export([normalize_path/1]).
-export([rand_uniform/2]).
-define(PERCENT, 37). % $\%
-define(FULLSTOP, 46). % $\.
-define(IS_HEX(C), ((C >= $0 andalso C =< $9) orelse
(C >= $a andalso C =< $f) orelse
(C >= $A andalso C =< $F))).
-define(QS_SAFE(C), ((C >= $a andalso C =< $z) orelse
(C >= $A andalso C =< $Z) orelse
(C >= $0 andalso C =< $9) orelse
(C =:= ?FULLSTOP orelse C =:= $- orelse C =:= $~ orelse
C =:= $_))).
hexdigit(C) when C < 10 -> $0 + C;
hexdigit(C) when C < 16 -> $A + (C - 10).
unhexdigit(C) when C >= $0, C =< $9 -> C - $0;
unhexdigit(C) when C >= $a, C =< $f -> C - $a + 10;
unhexdigit(C) when C >= $A, C =< $F -> C - $A + 10.
unhexdigit(Hi, Lo) ->
unhexdigit(Lo) bor (unhexdigit(Hi) bsl 4).
%% @spec partition(String, Sep) -> {String, [], []} | {Prefix, Sep, Postfix}
%% @doc Inspired by Python 2.5's str.partition:
%% partition("foo/bar", "/") = {"foo", "/", "bar"},
%% partition("foo", "/") = {"foo", "", ""}.
partition(String, Sep) ->
case partition(String, Sep, []) of
undefined ->
{String, "", ""};
Result ->
Result
end.
partition("", _Sep, _Acc) ->
undefined;
partition(S, Sep, Acc) ->
case partition2(S, Sep) of
undefined ->
[C | Rest] = S,
partition(Rest, Sep, [C | Acc]);
Rest ->
{lists:reverse(Acc), Sep, Rest}
end.
partition2(Rest, "") ->
Rest;
partition2([C | R1], [C | R2]) ->
partition2(R1, R2);
partition2(_S, _Sep) ->
undefined.
%% @spec safe_relative_path(string()) -> string() | undefined
%% @doc Return the reduced version of a relative path or undefined if it
%% is not safe. safe relative paths can be joined with an absolute path
%% and will result in a subdirectory of the absolute path. Safe paths
%% never contain a backslash character.
safe_relative_path("/" ++ _) ->
undefined;
safe_relative_path(P) ->
case string:chr(P, $\\) of
0 ->
safe_relative_path(P, []);
_ ->
undefined
end.
safe_relative_path("", Acc) ->
case Acc of
[] ->
"";
_ ->
string:join(lists:reverse(Acc), "/")
end;
safe_relative_path(P, Acc) ->
case partition(P, "/") of
{"", "/", _} ->
%% /foo or foo//bar
undefined;
{"..", _, _} when Acc =:= [] ->
undefined;
{"..", _, Rest} ->
safe_relative_path(Rest, tl(Acc));
{Part, "/", ""} ->
safe_relative_path("", ["", Part | Acc]);
{Part, _, Rest} ->
safe_relative_path(Rest, [Part | Acc])
end.
%% @spec shell_quote(string()) -> string()
%% @doc Quote a string according to UNIX shell quoting rules, returns a string
%% surrounded by double quotes.
shell_quote(L) ->
shell_quote(L, [$\"]).
%% @spec cmd_port([string()], Options) -> port()
%% @doc open_port({spawn, mochiweb_util:cmd_string(Argv)}, Options).
cmd_port(Argv, Options) ->
open_port({spawn, cmd_string(Argv)}, Options).
%% @spec cmd([string()]) -> string()
%% @doc os:cmd(cmd_string(Argv)).
cmd(Argv) ->
os:cmd(cmd_string(Argv)).
%% @spec cmd_string([string()]) -> string()
%% @doc Create a shell quoted command string from a list of arguments.
cmd_string(Argv) ->
string:join([shell_quote(X) || X <- Argv], " ").
%% @spec cmd_status([string()]) -> {ExitStatus::integer(), Stdout::binary()}
%% @doc Accumulate the output and exit status from the given application,
%% will be spawned with cmd_port/2.
cmd_status(Argv) ->
cmd_status(Argv, []).
%% @spec cmd_status([string()], [atom()]) -> {ExitStatus::integer(), Stdout::binary()}
%% @doc Accumulate the output and exit status from the given application,
%% will be spawned with cmd_port/2.
cmd_status(Argv, Options) ->
Port = cmd_port(Argv, [exit_status, stderr_to_stdout,
use_stdio, binary | Options]),
try cmd_loop(Port, [])
after catch port_close(Port)
end.
%% @spec cmd_loop(port(), list()) -> {ExitStatus::integer(), Stdout::binary()}
%% @doc Accumulate the output and exit status from a port.
cmd_loop(Port, Acc) ->
receive
{Port, {exit_status, Status}} ->
{Status, iolist_to_binary(lists:reverse(Acc))};
{Port, {data, Data}} ->
cmd_loop(Port, [Data | Acc])
end.
%% @spec join([iolist()], iolist()) -> iolist()
%% @doc Join a list of strings or binaries together with the given separator
%% string or char or binary. The output is flattened, but may be an
%% iolist() instead of a string() if any of the inputs are binary().
join([], _Separator) ->
[];
join([S], _Separator) ->
lists:flatten(S);
join(Strings, Separator) ->
lists:flatten(revjoin(lists:reverse(Strings), Separator, [])).
revjoin([], _Separator, Acc) ->
Acc;
revjoin([S | Rest], Separator, []) ->
revjoin(Rest, Separator, [S]);
revjoin([S | Rest], Separator, Acc) ->
revjoin(Rest, Separator, [S, Separator | Acc]).
%% @spec quote_plus(atom() | integer() | float() | string() | binary()) -> string()
%% @doc URL safe encoding of the given term.
quote_plus(Atom) when is_atom(Atom) ->
quote_plus(atom_to_list(Atom));
quote_plus(Int) when is_integer(Int) ->
quote_plus(integer_to_list(Int));
quote_plus(Binary) when is_binary(Binary) ->
quote_plus(binary_to_list(Binary));
quote_plus(Float) when is_float(Float) ->
quote_plus(mochinum:digits(Float));
quote_plus(String) ->
quote_plus(String, []).
quote_plus([], Acc) ->
lists:reverse(Acc);
quote_plus([C | Rest], Acc) when ?QS_SAFE(C) ->
quote_plus(Rest, [C | Acc]);
quote_plus([$\s | Rest], Acc) ->
quote_plus(Rest, [$+ | Acc]);
quote_plus([C | Rest], Acc) ->
<> = <>,
quote_plus(Rest, [hexdigit(Lo), hexdigit(Hi), ?PERCENT | Acc]).
%% @spec urlencode([{Key, Value}]) -> string()
%% @doc URL encode the property list.
urlencode(Props) ->
Pairs = lists:foldr(
fun ({K, V}, Acc) ->
[quote_plus(K) ++ "=" ++ quote_plus(V) | Acc]
end, [], Props),
string:join(Pairs, "&").
%% @spec parse_qs(string() | binary()) -> [{Key, Value}]
%% @doc Parse a query string or application/x-www-form-urlencoded.
parse_qs(Binary) when is_binary(Binary) ->
parse_qs(binary_to_list(Binary));
parse_qs(String) ->
parse_qs(String, []).
parse_qs([], Acc) ->
lists:reverse(Acc);
parse_qs(String, Acc) ->
{Key, Rest} = parse_qs_key(String),
{Value, Rest1} = parse_qs_value(Rest),
parse_qs(Rest1, [{Key, Value} | Acc]).
parse_qs_key(String) ->
parse_qs_key(String, []).
parse_qs_key([], Acc) ->
{qs_revdecode(Acc), ""};
parse_qs_key([$= | Rest], Acc) ->
{qs_revdecode(Acc), Rest};
parse_qs_key(Rest=[$; | _], Acc) ->
{qs_revdecode(Acc), Rest};
parse_qs_key(Rest=[$& | _], Acc) ->
{qs_revdecode(Acc), Rest};
parse_qs_key([C | Rest], Acc) ->
parse_qs_key(Rest, [C | Acc]).
parse_qs_value(String) ->
parse_qs_value(String, []).
parse_qs_value([], Acc) ->
{qs_revdecode(Acc), ""};
parse_qs_value([$; | Rest], Acc) ->
{qs_revdecode(Acc), Rest};
parse_qs_value([$& | Rest], Acc) ->
{qs_revdecode(Acc), Rest};
parse_qs_value([C | Rest], Acc) ->
parse_qs_value(Rest, [C | Acc]).
%% @spec unquote(string() | binary()) -> string()
%% @doc Unquote a URL encoded string.
unquote(Binary) when is_binary(Binary) ->
unquote(binary_to_list(Binary));
unquote(String) ->
qs_revdecode(lists:reverse(String)).
qs_revdecode(S) ->
qs_revdecode(S, []).
qs_revdecode([], Acc) ->
Acc;
qs_revdecode([$+ | Rest], Acc) ->
qs_revdecode(Rest, [$\s | Acc]);
qs_revdecode([Lo, Hi, ?PERCENT | Rest], Acc) when ?IS_HEX(Lo), ?IS_HEX(Hi) ->
qs_revdecode(Rest, [(unhexdigit(Hi, Lo)) | Acc]);
qs_revdecode([C | Rest], Acc) ->
qs_revdecode(Rest, [C | Acc]).
%% @spec unquote_path(string() | binary()) -> string()
%% @doc Unquote a URL encoded string, does not encode + into space.
unquote_path(Binary) when is_binary(Binary) ->
unquote_path(binary_to_list(Binary));
unquote_path(String) ->
qs_revdecode_path(lists:reverse(String)).
qs_revdecode_path(S) ->
qs_revdecode_path(S, []).
qs_revdecode_path([], Acc) ->
Acc;
qs_revdecode_path([Lo, Hi, ?PERCENT | Rest], Acc) when ?IS_HEX(Lo), ?IS_HEX(Hi) ->
qs_revdecode_path(Rest, [(unhexdigit(Hi, Lo)) | Acc]);
qs_revdecode_path([C | Rest], Acc) ->
qs_revdecode_path(Rest, [C | Acc]).
%% @spec urlsplit(Url) -> {Scheme, Netloc, Path, Query, Fragment}
%% @doc Return a 5-tuple, does not expand % escapes. Only supports HTTP style
%% URLs.
urlsplit(Url) ->
{Scheme, Url1} = urlsplit_scheme(Url),
{Netloc, Url2} = urlsplit_netloc(Url1),
{Path, Query, Fragment} = urlsplit_path(Url2),
{Scheme, Netloc, Path, Query, Fragment}.
urlsplit_scheme(Url) ->
case urlsplit_scheme(Url, []) of
no_scheme ->
{"", Url};
Res ->
Res
end.
urlsplit_scheme([C | Rest], Acc) when ((C >= $a andalso C =< $z) orelse
(C >= $A andalso C =< $Z) orelse
(C >= $0 andalso C =< $9) orelse
C =:= $+ orelse C =:= $- orelse
C =:= $.) ->
urlsplit_scheme(Rest, [C | Acc]);
urlsplit_scheme([$: | Rest], Acc=[_ | _]) ->
{string:to_lower(lists:reverse(Acc)), Rest};
urlsplit_scheme(_Rest, _Acc) ->
no_scheme.
urlsplit_netloc("//" ++ Rest) ->
urlsplit_netloc(Rest, []);
urlsplit_netloc(Path) ->
{"", Path}.
urlsplit_netloc("", Acc) ->
{lists:reverse(Acc), ""};
urlsplit_netloc(Rest=[C | _], Acc) when C =:= $/; C =:= $?; C =:= $# ->
{lists:reverse(Acc), Rest};
urlsplit_netloc([C | Rest], Acc) ->
urlsplit_netloc(Rest, [C | Acc]).
%% @spec path_split(string()) -> {Part, Rest}
%% @doc Split a path starting from the left, as in URL traversal.
%% path_split("foo/bar") = {"foo", "bar"},
%% path_split("/foo/bar") = {"", "foo/bar"}.
path_split(S) ->
path_split(S, []).
path_split("", Acc) ->
{lists:reverse(Acc), ""};
path_split("/" ++ Rest, Acc) ->
{lists:reverse(Acc), Rest};
path_split([C | Rest], Acc) ->
path_split(Rest, [C | Acc]).
%% @spec urlunsplit({Scheme, Netloc, Path, Query, Fragment}) -> string()
%% @doc Assemble a URL from the 5-tuple. Path must be absolute.
urlunsplit({Scheme, Netloc, Path, Query, Fragment}) ->
lists:flatten([case Scheme of "" -> ""; _ -> [Scheme, "://"] end,
Netloc,
urlunsplit_path({Path, Query, Fragment})]).
%% @spec urlunsplit_path({Path, Query, Fragment}) -> string()
%% @doc Assemble a URL path from the 3-tuple.
urlunsplit_path({Path, Query, Fragment}) ->
lists:flatten([Path,
case Query of "" -> ""; _ -> [$? | Query] end,
case Fragment of "" -> ""; _ -> [$# | Fragment] end]).
%% @spec urlsplit_path(Url) -> {Path, Query, Fragment}
%% @doc Return a 3-tuple, does not expand % escapes. Only supports HTTP style
%% paths.
urlsplit_path(Path) ->
urlsplit_path(Path, []).
urlsplit_path("", Acc) ->
{lists:reverse(Acc), "", ""};
urlsplit_path("?" ++ Rest, Acc) ->
{Query, Fragment} = urlsplit_query(Rest),
{lists:reverse(Acc), Query, Fragment};
urlsplit_path("#" ++ Rest, Acc) ->
{lists:reverse(Acc), "", Rest};
urlsplit_path([C | Rest], Acc) ->
urlsplit_path(Rest, [C | Acc]).
urlsplit_query(Query) ->
urlsplit_query(Query, []).
urlsplit_query("", Acc) ->
{lists:reverse(Acc), ""};
urlsplit_query("#" ++ Rest, Acc) ->
{lists:reverse(Acc), Rest};
urlsplit_query([C | Rest], Acc) ->
urlsplit_query(Rest, [C | Acc]).
extension(Name) ->
case filename:extension(Name) of
"" -> Name;
Ext -> Ext
end.
%% @spec guess_mime(string()) -> string()
%% @doc Guess the mime type of a file by the extension of its filename.
guess_mime(File) ->
case filename:basename(File) of
"crossdomain.xml" ->
"text/x-cross-domain-policy";
Name ->
case mochiweb_mime:from_extension(extension(Name)) of
undefined ->
"text/plain";
Mime ->
Mime
end
end.
%% @spec parse_header(string()) -> {Type, [{K, V}]}
%% @doc Parse a Content-Type like header, return the main Content-Type
%% and a property list of options.
parse_header(String) ->
%% TODO: This is exactly as broken as Python's cgi module.
%% Should parse properly like mochiweb_cookies.
[Type | Parts] = [string:strip(S) || S <- string:tokens(String, ";")],
F = fun (S, Acc) ->
case lists:splitwith(fun (C) -> C =/= $= end, S) of
{"", _} ->
%% Skip anything with no name
Acc;
{_, ""} ->
%% Skip anything with no value
Acc;
{Name, [$\= | Value]} ->
[{string:to_lower(string:strip(Name)),
unquote_header(string:strip(Value))} | Acc]
end
end,
{string:to_lower(Type),
lists:foldr(F, [], Parts)}.
unquote_header("\"" ++ Rest) ->
unquote_header(Rest, []);
unquote_header(S) ->
S.
unquote_header("", Acc) ->
lists:reverse(Acc);
unquote_header("\"", Acc) ->
lists:reverse(Acc);
unquote_header([$\\, C | Rest], Acc) ->
unquote_header(Rest, [C | Acc]);
unquote_header([C | Rest], Acc) ->
unquote_header(Rest, [C | Acc]).
%% @spec record_to_proplist(Record, Fields) -> proplist()
%% @doc calls record_to_proplist/3 with a default TypeKey of '__record'
record_to_proplist(Record, Fields) ->
record_to_proplist(Record, Fields, '__record').
%% @spec record_to_proplist(Record, Fields, TypeKey) -> proplist()
%% @doc Return a proplist of the given Record with each field in the
%% Fields list set as a key with the corresponding value in the Record.
%% TypeKey is the key that is used to store the record type
%% Fields should be obtained by calling record_info(fields, record_type)
%% where record_type is the record type of Record
record_to_proplist(Record, Fields, TypeKey)
when tuple_size(Record) - 1 =:= length(Fields) ->
lists:zip([TypeKey | Fields], tuple_to_list(Record)).
shell_quote([], Acc) ->
lists:reverse([$\" | Acc]);
shell_quote([C | Rest], Acc) when C =:= $\" orelse C =:= $\` orelse
C =:= $\\ orelse C =:= $\$ ->
shell_quote(Rest, [C, $\\ | Acc]);
shell_quote([C | Rest], Acc) ->
shell_quote(Rest, [C | Acc]).
%% @spec parse_qvalues(string()) -> [qvalue()] | invalid_qvalue_string
%% @type qvalue() = {media_type() | encoding() , float()}.
%% @type media_type() = string().
%% @type encoding() = string().
%%
%% @doc Parses a list (given as a string) of elements with Q values associated
%% to them. Elements are separated by commas and each element is separated
%% from its Q value by a semicolon. Q values are optional but when missing
%% the value of an element is considered as 1.0. A Q value is always in the
%% range [0.0, 1.0]. A Q value list is used for example as the value of the
%% HTTP "Accept" and "Accept-Encoding" headers.
%%
%% Q values are described in section 2.9 of the RFC 2616 (HTTP 1.1).
%%
%% Example:
%%
%% parse_qvalues("gzip; q=0.5, deflate, identity;q=0.0") ->
%% [{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 0.0}]
%%
parse_qvalues(QValuesStr) ->
try
lists:map(
fun(Pair) ->
[Type | Params] = string:tokens(Pair, ";"),
NormParams = normalize_media_params(Params),
{Q, NonQParams} = extract_q(NormParams),
{string:join([string:strip(Type) | NonQParams], ";"), Q}
end,
string:tokens(string:to_lower(QValuesStr), ",")
)
catch
_Type:_Error ->
invalid_qvalue_string
end.
normalize_media_params(Params) ->
{ok, Re} = re:compile("\\s"),
normalize_media_params(Re, Params, []).
normalize_media_params(_Re, [], Acc) ->
lists:reverse(Acc);
normalize_media_params(Re, [Param | Rest], Acc) ->
NormParam = re:replace(Param, Re, "", [global, {return, list}]),
normalize_media_params(Re, Rest, [NormParam | Acc]).
extract_q(NormParams) ->
{ok, KVRe} = re:compile("^([^=]+)=([^=]+)$"),
{ok, QRe} = re:compile("^((?:0|1)(?:\\.\\d{1,3})?)$"),
extract_q(KVRe, QRe, NormParams, []).
extract_q(_KVRe, _QRe, [], Acc) ->
{1.0, lists:reverse(Acc)};
extract_q(KVRe, QRe, [Param | Rest], Acc) ->
case re:run(Param, KVRe, [{capture, [1, 2], list}]) of
{match, [Name, Value]} ->
case Name of
"q" ->
{match, [Q]} = re:run(Value, QRe, [{capture, [1], list}]),
QVal = case Q of
"0" ->
0.0;
"1" ->
1.0;
Else ->
list_to_float(Else)
end,
case QVal < 0.0 orelse QVal > 1.0 of
false ->
{QVal, lists:reverse(Acc) ++ Rest}
end;
_ ->
extract_q(KVRe, QRe, Rest, [Param | Acc])
end
end.
%% @spec pick_accepted_encodings([qvalue()], [encoding()], encoding()) ->
%% [encoding()]
%%
%% @doc Determines which encodings specified in the given Q values list are
%% valid according to a list of supported encodings and a default encoding.
%%
%% The returned list of encodings is sorted, descendingly, according to the
%% Q values of the given list. The last element of this list is the given
%% default encoding unless this encoding is explicitly or implicitily
%% marked with a Q value of 0.0 in the given Q values list.
%% Note: encodings with the same Q value are kept in the same order as
%% found in the input Q values list.
%%
%% This encoding picking process is described in section 14.3 of the
%% RFC 2616 (HTTP 1.1).
%%
%% Example:
%%
%% pick_accepted_encodings(
%% [{"gzip", 0.5}, {"deflate", 1.0}],
%% ["gzip", "identity"],
%% "identity"
%% ) ->
%% ["gzip", "identity"]
%%
pick_accepted_encodings(AcceptedEncs, SupportedEncs, DefaultEnc) ->
SortedQList = lists:reverse(
lists:sort(fun({_, Q1}, {_, Q2}) -> Q1 < Q2 end, AcceptedEncs)
),
{Accepted, Refused} = lists:foldr(
fun({E, Q}, {A, R}) ->
case Q > 0.0 of
true ->
{[E | A], R};
false ->
{A, [E | R]}
end
end,
{[], []},
SortedQList
),
Refused1 = lists:foldr(
fun(Enc, Acc) ->
case Enc of
"*" ->
lists:subtract(SupportedEncs, Accepted) ++ Acc;
_ ->
[Enc | Acc]
end
end,
[],
Refused
),
Accepted1 = lists:foldr(
fun(Enc, Acc) ->
case Enc of
"*" ->
lists:subtract(SupportedEncs, Accepted ++ Refused1) ++ Acc;
_ ->
[Enc | Acc]
end
end,
[],
Accepted
),
Accepted2 = case lists:member(DefaultEnc, Accepted1) of
true ->
Accepted1;
false ->
Accepted1 ++ [DefaultEnc]
end,
[E || E <- Accepted2, lists:member(E, SupportedEncs),
not lists:member(E, Refused1)].
make_io(Atom) when is_atom(Atom) ->
atom_to_list(Atom);
make_io(Integer) when is_integer(Integer) ->
integer_to_list(Integer);
make_io(Io) when is_list(Io); is_binary(Io) ->
Io.
%% @spec normalize_path(string()) -> string()
%% @doc Remove duplicate slashes from an uri path ("//foo///bar////" becomes
%% "/foo/bar/").
%% Per RFC 3986, all but the last path segment must be non-empty.
normalize_path(Path) ->
normalize_path(Path, []).
normalize_path([], Acc) ->
lists:reverse(Acc);
normalize_path("/" ++ Path, "/" ++ _ = Acc) ->
normalize_path(Path, Acc);
normalize_path([C|Path], Acc) ->
normalize_path(Path, [C|Acc]).
rand_uniform(Start, End) ->
Start + rand:uniform(End - Start) - 1.
%%
%% Tests
%%
-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").
make_io_test() ->
?assertEqual(
<<"atom">>,
iolist_to_binary(make_io(atom))),
?assertEqual(
<<"20">>,
iolist_to_binary(make_io(20))),
?assertEqual(
<<"list">>,
iolist_to_binary(make_io("list"))),
?assertEqual(
<<"binary">>,
iolist_to_binary(make_io(<<"binary">>))),
ok.
-record(test_record, {field1=f1, field2=f2}).
record_to_proplist_test() ->
?assertEqual(
[{'__record', test_record},
{field1, f1},
{field2, f2}],
record_to_proplist(#test_record{}, record_info(fields, test_record))),
?assertEqual(
[{'typekey', test_record},
{field1, f1},
{field2, f2}],
record_to_proplist(#test_record{},
record_info(fields, test_record),
typekey)),
ok.
shell_quote_test() ->
?assertEqual(
"\"foo \\$bar\\\"\\`' baz\"",
shell_quote("foo $bar\"`' baz")),
ok.
cmd_port_test_spool(Port, Acc) ->
receive
{Port, eof} ->
Acc;
{Port, {data, {eol, Data}}} ->
cmd_port_test_spool(Port, ["\n", Data | Acc]);
{Port, Unknown} ->
throw({unknown, Unknown})
after 1000 ->
throw(timeout)
end.
cmd_port_test() ->
Port = cmd_port(["echo", "$bling$ `word`!"],
[eof, stream, {line, 4096}]),
Res = try lists:append(lists:reverse(cmd_port_test_spool(Port, [])))
after catch port_close(Port)
end,
self() ! {Port, wtf},
try cmd_port_test_spool(Port, [])
catch throw:{unknown, wtf} -> ok
end,
try cmd_port_test_spool(Port, [])
catch throw:timeout -> ok
end,
?assertEqual(
"$bling$ `word`!\n",
Res).
cmd_test() ->
?assertEqual(
"$bling$ `word`!\n",
cmd(["echo", "$bling$ `word`!"])),
ok.
cmd_string_test() ->
?assertEqual(
"\"echo\" \"\\$bling\\$ \\`word\\`!\"",
cmd_string(["echo", "$bling$ `word`!"])),
ok.
cmd_status_test() ->
?assertEqual(
{0, <<"$bling$ `word`!\n">>},
cmd_status(["echo", "$bling$ `word`!"])),
ok.
parse_header_test() ->
?assertEqual(
{"multipart/form-data", [{"boundary", "AaB03x"}]},
parse_header("multipart/form-data; boundary=AaB03x")),
%% This tests (currently) intentionally broken behavior
?assertEqual(
{"multipart/form-data",
[{"b", ""},
{"cgi", "is"},
{"broken", "true\"e"}]},
parse_header("multipart/form-data;b=;cgi=\"i\\s;broken=true\"e;=z;z")),
ok.
guess_mime_test() ->
?assertEqual("text/plain", guess_mime("")),
?assertEqual("text/plain", guess_mime(".text")),
?assertEqual("application/zip", guess_mime(".zip")),
?assertEqual("application/zip", guess_mime("x.zip")),
?assertEqual("text/html", guess_mime("x.html")),
?assertEqual("application/xhtml+xml", guess_mime("x.xhtml")),
?assertEqual("text/x-cross-domain-policy", guess_mime("crossdomain.xml")),
?assertEqual("text/x-cross-domain-policy", guess_mime("www/crossdomain.xml")),
ok.
path_split_test() ->
{"", "foo/bar"} = path_split("/foo/bar"),
{"foo", "bar"} = path_split("foo/bar"),
{"bar", ""} = path_split("bar"),
ok.
urlsplit_test() ->
{"", "", "/foo", "", "bar?baz"} = urlsplit("/foo#bar?baz"),
{"http", "host:port", "/foo", "", "bar?baz"} =
urlsplit("http://host:port/foo#bar?baz"),
{"http", "host", "", "", ""} = urlsplit("http://host"),
{"", "", "/wiki/Category:Fruit", "", ""} =
urlsplit("/wiki/Category:Fruit"),
ok.
urlsplit_path_test() ->
{"/foo/bar", "", ""} = urlsplit_path("/foo/bar"),
{"/foo", "baz", ""} = urlsplit_path("/foo?baz"),
{"/foo", "", "bar?baz"} = urlsplit_path("/foo#bar?baz"),
{"/foo", "", "bar?baz#wibble"} = urlsplit_path("/foo#bar?baz#wibble"),
{"/foo", "bar", "baz"} = urlsplit_path("/foo?bar#baz"),
{"/foo", "bar?baz", "baz"} = urlsplit_path("/foo?bar?baz#baz"),
ok.
urlunsplit_test() ->
"/foo#bar?baz" = urlunsplit({"", "", "/foo", "", "bar?baz"}),
"http://host:port/foo#bar?baz" =
urlunsplit({"http", "host:port", "/foo", "", "bar?baz"}),
ok.
urlunsplit_path_test() ->
"/foo/bar" = urlunsplit_path({"/foo/bar", "", ""}),
"/foo?baz" = urlunsplit_path({"/foo", "baz", ""}),
"/foo#bar?baz" = urlunsplit_path({"/foo", "", "bar?baz"}),
"/foo#bar?baz#wibble" = urlunsplit_path({"/foo", "", "bar?baz#wibble"}),
"/foo?bar#baz" = urlunsplit_path({"/foo", "bar", "baz"}),
"/foo?bar?baz#baz" = urlunsplit_path({"/foo", "bar?baz", "baz"}),
ok.
join_test() ->
?assertEqual("foo,bar,baz",
join(["foo", "bar", "baz"], $,)),
?assertEqual("foo,bar,baz",
join(["foo", "bar", "baz"], ",")),
?assertEqual("foo bar",
join([["foo", " bar"]], ",")),
?assertEqual("foo bar,baz",
join([["foo", " bar"], "baz"], ",")),
?assertEqual("foo",
join(["foo"], ",")),
?assertEqual("foobarbaz",
join(["foo", "bar", "baz"], "")),
?assertEqual("foo" ++ [<<>>] ++ "bar" ++ [<<>>] ++ "baz",
join(["foo", "bar", "baz"], <<>>)),
?assertEqual("foobar" ++ [<<"baz">>],
join(["foo", "bar", <<"baz">>], "")),
?assertEqual("",
join([], "any")),
ok.
quote_plus_test() ->
"foo" = quote_plus(foo),
"1" = quote_plus(1),
"1.1" = quote_plus(1.1),
"foo" = quote_plus("foo"),
"foo+bar" = quote_plus("foo bar"),
"foo%0A" = quote_plus("foo\n"),
"foo%0A" = quote_plus("foo\n"),
"foo%3B%26%3D" = quote_plus("foo;&="),
"foo%3B%26%3D" = quote_plus(<<"foo;&=">>),
ok.
unquote_test() ->
?assertEqual("foo bar",
unquote("foo+bar")),
?assertEqual("foo bar",
unquote("foo%20bar")),
?assertEqual("foo\r\n",
unquote("foo%0D%0A")),
?assertEqual("foo\r\n",
unquote(<<"foo%0D%0A">>)),
ok.
urlencode_test() ->
"foo=bar&baz=wibble+%0D%0A&z=1" = urlencode([{foo, "bar"},
{"baz", "wibble \r\n"},
{z, 1}]),
ok.
parse_qs_test() ->
?assertEqual(
[{"foo", "bar"}, {"baz", "wibble \r\n"}, {"z", "1"}],
parse_qs("foo=bar&baz=wibble+%0D%0a&z=1")),
?assertEqual(
[{"", "bar"}, {"baz", "wibble \r\n"}, {"z", ""}],
parse_qs("=bar&baz=wibble+%0D%0a&z=")),
?assertEqual(
[{"foo", "bar"}, {"baz", "wibble \r\n"}, {"z", "1"}],
parse_qs(<<"foo=bar&baz=wibble+%0D%0a&z=1">>)),
?assertEqual(
[],
parse_qs("")),
?assertEqual(
[{"foo", ""}, {"bar", ""}, {"baz", ""}],
parse_qs("foo;bar&baz")),
ok.
partition_test() ->
{"foo", "", ""} = partition("foo", "/"),
{"foo", "/", "bar"} = partition("foo/bar", "/"),
{"foo", "/", ""} = partition("foo/", "/"),
{"", "/", "bar"} = partition("/bar", "/"),
{"f", "oo/ba", "r"} = partition("foo/bar", "oo/ba"),
ok.
safe_relative_path_test() ->
"foo" = safe_relative_path("foo"),
"foo/" = safe_relative_path("foo/"),
"foo" = safe_relative_path("foo/bar/.."),
"bar" = safe_relative_path("foo/../bar"),
"bar/" = safe_relative_path("foo/../bar/"),
"" = safe_relative_path("foo/.."),
"" = safe_relative_path("foo/../"),
undefined = safe_relative_path("/foo"),
undefined = safe_relative_path("../foo"),
undefined = safe_relative_path("foo/../.."),
undefined = safe_relative_path("foo//"),
undefined = safe_relative_path("foo\\bar"),
ok.
parse_qvalues_test() ->
[] = parse_qvalues(""),
[{"identity", 0.0}] = parse_qvalues("identity;q=0"),
[{"identity", 0.0}] = parse_qvalues("identity ;q=0"),
[{"identity", 0.0}] = parse_qvalues(" identity; q =0 "),
[{"identity", 0.0}] = parse_qvalues("identity ; q = 0"),
[{"identity", 0.0}] = parse_qvalues("identity ; q= 0.0"),
[{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
"gzip,deflate,identity;q=0.0"
),
[{"deflate", 1.0}, {"gzip", 1.0}, {"identity", 0.0}] = parse_qvalues(
"deflate,gzip,identity;q=0.0"
),
[{"gzip", 1.0}, {"deflate", 1.0}, {"gzip", 1.0}, {"identity", 0.0}] =
parse_qvalues("gzip,deflate,gzip,identity;q=0"),
[{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
"gzip, deflate , identity; q=0.0"
),
[{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
"gzip; q=1, deflate;q=1.0, identity;q=0.0"
),
[{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
"gzip; q=0.5, deflate;q=1.0, identity;q=0"
),
[{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 0.0}] = parse_qvalues(
"gzip; q=0.5, deflate , identity;q=0.0"
),
[{"gzip", 0.5}, {"deflate", 0.8}, {"identity", 0.0}] = parse_qvalues(
"gzip; q=0.5, deflate;q=0.8, identity;q=0.0"
),
[{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 1.0}] = parse_qvalues(
"gzip; q=0.5,deflate,identity"
),
[{"gzip", 0.5}, {"deflate", 1.0}, {"identity", 1.0}, {"identity", 1.0}] =
parse_qvalues("gzip; q=0.5,deflate,identity, identity "),
[{"text/html;level=1", 1.0}, {"text/plain", 0.5}] =
parse_qvalues("text/html;level=1, text/plain;q=0.5"),
[{"text/html;level=1", 0.3}, {"text/plain", 1.0}] =
parse_qvalues("text/html;level=1;q=0.3, text/plain"),
[{"text/html;level=1", 0.3}, {"text/plain", 1.0}] =
parse_qvalues("text/html; level = 1; q = 0.3, text/plain"),
[{"text/html;level=1", 0.3}, {"text/plain", 1.0}] =
parse_qvalues("text/html;q=0.3;level=1, text/plain"),
invalid_qvalue_string = parse_qvalues("gzip; q=1.1, deflate"),
invalid_qvalue_string = parse_qvalues("gzip; q=0.5, deflate;q=2"),
invalid_qvalue_string = parse_qvalues("gzip, deflate;q=AB"),
invalid_qvalue_string = parse_qvalues("gzip; q=2.1, deflate"),
invalid_qvalue_string = parse_qvalues("gzip; q=0.1234, deflate"),
invalid_qvalue_string = parse_qvalues("text/html;level=1;q=0.3, text/html;level"),
ok.
pick_accepted_encodings_test() ->
["identity"] = pick_accepted_encodings(
[],
["gzip", "identity"],
"identity"
),
["gzip", "identity"] = pick_accepted_encodings(
[{"gzip", 1.0}],
["gzip", "identity"],
"identity"
),
["identity"] = pick_accepted_encodings(
[{"gzip", 0.0}],
["gzip", "identity"],
"identity"
),
["gzip", "identity"] = pick_accepted_encodings(
[{"gzip", 1.0}, {"deflate", 1.0}],
["gzip", "identity"],
"identity"
),
["gzip", "identity"] = pick_accepted_encodings(
[{"gzip", 0.5}, {"deflate", 1.0}],
["gzip", "identity"],
"identity"
),
["identity"] = pick_accepted_encodings(
[{"gzip", 0.0}, {"deflate", 0.0}],
["gzip", "identity"],
"identity"
),
["gzip"] = pick_accepted_encodings(
[{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}],
["gzip", "identity"],
"identity"
),
["gzip", "deflate", "identity"] = pick_accepted_encodings(
[{"gzip", 1.0}, {"deflate", 1.0}],
["gzip", "deflate", "identity"],
"identity"
),
["gzip", "deflate"] = pick_accepted_encodings(
[{"gzip", 1.0}, {"deflate", 1.0}, {"identity", 0.0}],
["gzip", "deflate", "identity"],
"identity"
),
["deflate", "gzip", "identity"] = pick_accepted_encodings(
[{"gzip", 0.2}, {"deflate", 1.0}],
["gzip", "deflate", "identity"],
"identity"
),
["deflate", "deflate", "gzip", "identity"] = pick_accepted_encodings(
[{"gzip", 0.2}, {"deflate", 1.0}, {"deflate", 1.0}],
["gzip", "deflate", "identity"],
"identity"
),
["deflate", "gzip", "gzip", "identity"] = pick_accepted_encodings(
[{"gzip", 0.2}, {"deflate", 1.0}, {"gzip", 1.0}],
["gzip", "deflate", "identity"],
"identity"
),
["gzip", "deflate", "gzip", "identity"] = pick_accepted_encodings(
[{"gzip", 0.2}, {"deflate", 0.9}, {"gzip", 1.0}],
["gzip", "deflate", "identity"],
"identity"
),
[] = pick_accepted_encodings(
[{"*", 0.0}],
["gzip", "deflate", "identity"],
"identity"
),
["gzip", "deflate", "identity"] = pick_accepted_encodings(
[{"*", 1.0}],
["gzip", "deflate", "identity"],
"identity"
),
["gzip", "deflate", "identity"] = pick_accepted_encodings(
[{"*", 0.6}],
["gzip", "deflate", "identity"],
"identity"
),
["gzip"] = pick_accepted_encodings(
[{"gzip", 1.0}, {"*", 0.0}],
["gzip", "deflate", "identity"],
"identity"
),
["gzip", "deflate"] = pick_accepted_encodings(
[{"gzip", 1.0}, {"deflate", 0.6}, {"*", 0.0}],
["gzip", "deflate", "identity"],
"identity"
),
["deflate", "gzip"] = pick_accepted_encodings(
[{"gzip", 0.5}, {"deflate", 1.0}, {"*", 0.0}],
["gzip", "deflate", "identity"],
"identity"
),
["gzip", "identity"] = pick_accepted_encodings(
[{"deflate", 0.0}, {"*", 1.0}],
["gzip", "deflate", "identity"],
"identity"
),
["gzip", "identity"] = pick_accepted_encodings(
[{"*", 1.0}, {"deflate", 0.0}],
["gzip", "deflate", "identity"],
"identity"
),
ok.
normalize_path_test() ->
"" = normalize_path(""),
"/" = normalize_path("/"),
"/" = normalize_path("//"),
"/" = normalize_path("///"),
"foo" = normalize_path("foo"),
"/foo" = normalize_path("/foo"),
"/foo" = normalize_path("//foo"),
"/foo" = normalize_path("///foo"),
"foo/" = normalize_path("foo/"),
"foo/" = normalize_path("foo//"),
"foo/" = normalize_path("foo///"),
"foo/bar" = normalize_path("foo/bar"),
"foo/bar" = normalize_path("foo//bar"),
"foo/bar" = normalize_path("foo///bar"),
"foo/bar" = normalize_path("foo////bar"),
"/foo/bar" = normalize_path("/foo/bar"),
"/foo/bar" = normalize_path("/foo////bar"),
"/foo/bar" = normalize_path("////foo/bar"),
"/foo/bar" = normalize_path("////foo///bar"),
"/foo/bar" = normalize_path("////foo////bar"),
"/foo/bar/" = normalize_path("/foo/bar/"),
"/foo/bar/" = normalize_path("////foo/bar/"),
"/foo/bar/" = normalize_path("/foo////bar/"),
"/foo/bar/" = normalize_path("/foo/bar////"),
"/foo/bar/" = normalize_path("///foo////bar/"),
"/foo/bar/" = normalize_path("////foo/bar////"),
"/foo/bar/" = normalize_path("/foo///bar////"),
"/foo/bar/" = normalize_path("////foo///bar////"),
ok.
-endif.
mochiweb-3.2.1/src/mochiweb_websocket.erl 0000664 0000000 0000000 00000022046 14503332274 0020457 0 ustar 00root root 0000000 0000000 -module(mochiweb_websocket).
-author('lukasz.lalik@zadane.pl').
%% The MIT License (MIT)
%% Copyright (c) 2012 Zadane.pl sp. z o.o.
%% 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 Websockets module for Mochiweb. Based on Misultin websockets module.
-export([loop/5, request/5, upgrade_connection/2]).
-export([send/3]).
-ifdef(TEST).
-export([hixie_handshake/7, make_handshake/1,
parse_hixie_frames/2, parse_hybi_frames/3]).
-endif.
loop(Socket, Body, State, WsVersion, ReplyChannel) ->
ok =
mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
[{packet, 0},
{active,
once}])),
proc_lib:hibernate(?MODULE, request,
[Socket, Body, State, WsVersion, ReplyChannel]).
request(Socket, Body, State, WsVersion, ReplyChannel) ->
receive
{tcp_closed = Error, _} ->
mochiweb_socket:close(Socket), exit({shutdown, Error});
{ssl_closed = Error, _} ->
mochiweb_socket:close(Socket), exit({shutdown, Error});
{tcp_error, _, Error} ->
mochiweb_socket:close(Socket), exit({shutdown, {tcp_error, Error}});
{Proto, _, WsFrames}
when Proto =:= tcp orelse Proto =:= ssl ->
case parse_frames(WsVersion, WsFrames, Socket) of
close -> mochiweb_socket:close(Socket), exit({shutdown, websocket_parse_frames_close});
error -> mochiweb_socket:close(Socket), exit({shutdown, websocket_parse_frames_error});
Payload ->
NewState = call_body(Body, Payload, State,
ReplyChannel),
loop(Socket, Body, NewState, WsVersion, ReplyChannel)
end;
_ -> mochiweb_socket:close(Socket), exit({shutdown, websocket_request_error})
end.
call_body({M, F, A}, Payload, State, ReplyChannel) ->
erlang:apply(M, F, [Payload, State, ReplyChannel | A]);
call_body({M, F}, Payload, State, ReplyChannel) ->
M:F(Payload, State, ReplyChannel);
call_body(Body, Payload, State, ReplyChannel) ->
Body(Payload, State, ReplyChannel).
send(Socket, Payload, hybi) ->
Prefix = <<1:1, 0:3, 1:4,
(payload_length(iolist_size(Payload)))/binary>>,
mochiweb_socket:send(Socket, [Prefix, Payload]);
send(Socket, Payload, hixie) ->
mochiweb_socket:send(Socket, [0, Payload, 255]).
upgrade_connection({ReqM, _} = Req, Body) ->
case make_handshake(Req) of
{Version, Response} ->
ReqM:respond(Response, Req),
Socket = ReqM:get(socket, Req),
ReplyChannel = fun (Payload) ->
(?MODULE):send(Socket, Payload, Version)
end,
Reentry = fun (State) ->
(?MODULE):loop(Socket, Body, State, Version,
ReplyChannel)
end,
{Reentry, ReplyChannel};
_ ->
mochiweb_socket:close(ReqM:get(socket, Req)),
exit({shutdown, websocket_handshake_error})
end.
make_handshake({ReqM, _} = Req) ->
SecKey = ReqM:get_header_value("sec-websocket-key",
Req),
Sec1Key = ReqM:get_header_value("Sec-WebSocket-Key1",
Req),
Sec2Key = ReqM:get_header_value("Sec-WebSocket-Key2",
Req),
Origin = ReqM:get_header_value(origin, Req),
if SecKey =/= undefined -> hybi_handshake(SecKey);
Sec1Key =/= undefined andalso Sec2Key =/= undefined ->
Host = ReqM:get_header_value("Host", Req),
Path = ReqM:get(path, Req),
Body = ReqM:recv(8, Req),
Scheme = scheme(Req),
hixie_handshake(Scheme, Host, Path, Sec1Key, Sec2Key,
Body, Origin);
true -> error
end.
hybi_handshake(SecKey) ->
BinKey = list_to_binary(SecKey),
Bin = <>,
Challenge = base64:encode(crypto:hash(sha, Bin)),
Response = {101,
[{"Connection", "Upgrade"}, {"Upgrade", "websocket"},
{"Sec-Websocket-Accept", Challenge}],
""},
{hybi, Response}.
scheme(Req) ->
case mochiweb_request:get(scheme, Req) of
http -> "ws://";
https -> "wss://"
end.
hixie_handshake(Scheme, Host, Path, Key1, Key2, Body,
Origin) ->
Ikey1 = [D || D <- Key1, $0 =< D, D =< $9],
Ikey2 = [D || D <- Key2, $0 =< D, D =< $9],
Blank1 = length([D || D <- Key1, D =:= 32]),
Blank2 = length([D || D <- Key2, D =:= 32]),
Part1 = erlang:list_to_integer(Ikey1) div Blank1,
Part2 = erlang:list_to_integer(Ikey2) div Blank2,
Ckey = <>,
Challenge = erlang:md5(Ckey),
Location = lists:concat([Scheme, Host, Path]),
Response = {101,
[{"Upgrade", "WebSocket"}, {"Connection", "Upgrade"},
{"Sec-WebSocket-Origin", Origin},
{"Sec-WebSocket-Location", Location}],
Challenge},
{hixie, Response}.
parse_frames(hybi, Frames, Socket) ->
try parse_hybi_frames(Socket, Frames, []) of
Parsed -> process_frames(Parsed, [])
catch
_:_ -> error
end;
parse_frames(hixie, Frames, _Socket) ->
try parse_hixie_frames(Frames, []) of
Payload -> Payload
catch
_:_ -> error
end.
%%
%% Websockets internal functions for RFC6455 and hybi draft
%%
process_frames([], Acc) -> lists:reverse(Acc);
process_frames([{Opcode, Payload} | Rest], Acc) ->
case Opcode of
8 -> close;
_ -> process_frames(Rest, [Payload | Acc])
end.
parse_hybi_frames(_, <<>>, Acc) -> lists:reverse(Acc);
parse_hybi_frames(S,
<<_Fin:1, _Rsv:3, Opcode:4, _Mask:1, PayloadLen:7,
MaskKey:4/binary, Payload:PayloadLen/binary-unit:8,
Rest/binary>>,
Acc)
when PayloadLen < 126 ->
Payload2 = hybi_unmask(Payload, MaskKey, <<>>),
parse_hybi_frames(S, Rest, [{Opcode, Payload2} | Acc]);
parse_hybi_frames(S,
<<_Fin:1, _Rsv:3, Opcode:4, _Mask:1, 126:7,
PayloadLen:16, MaskKey:4/binary,
Payload:PayloadLen/binary-unit:8, Rest/binary>>,
Acc) ->
Payload2 = hybi_unmask(Payload, MaskKey, <<>>),
parse_hybi_frames(S, Rest, [{Opcode, Payload2} | Acc]);
parse_hybi_frames(Socket,
<<_Fin:1, _Rsv:3, _Opcode:4, _Mask:1, 126:7,
_PayloadLen:16, _MaskKey:4/binary, _/binary-unit:8>> =
PartFrame,
Acc) ->
ok =
mochiweb_socket:exit_if_closed(mochiweb_socket:setopts(Socket,
[{packet, 0},
{active,
once}])),
receive
{tcp_closed = Error, _} ->
mochiweb_socket:close(Socket), exit({shutdown, Error});
{ssl_closed = Error, _} ->
mochiweb_socket:close(Socket), exit({shutdown, Error});
{tcp_error, _, Error} ->
mochiweb_socket:close(Socket), exit({shutdown, {tcp_error, Error}});
{Proto, _, Continuation}
when Proto =:= tcp orelse Proto =:= ssl ->
parse_hybi_frames(Socket,
<>, Acc);
_ -> mochiweb_socket:close(Socket), exit({shutdown, parse_hybi_frames_error})
after 5000 ->
mochiweb_socket:close(Socket), exit({shutdown, parse_hybi_frames_timeout})
end;
parse_hybi_frames(S,
<<_Fin:1, _Rsv:3, Opcode:4, _Mask:1, 127:7, 0:1,
PayloadLen:63, MaskKey:4/binary,
Payload:PayloadLen/binary-unit:8, Rest/binary>>,
Acc) ->
Payload2 = hybi_unmask(Payload, MaskKey, <<>>),
parse_hybi_frames(S, Rest, [{Opcode, Payload2} | Acc]).
%% Unmasks RFC 6455 message
hybi_unmask(<>, MaskKey, Acc) ->
<> = MaskKey,
hybi_unmask(Rest, MaskKey,
<>);
hybi_unmask(<>, MaskKey, Acc) ->
<> = MaskKey,
<>;
hybi_unmask(<>, MaskKey, Acc) ->
<> = MaskKey,
<>;
hybi_unmask(<>, MaskKey, Acc) ->
<> = MaskKey,
<>;
hybi_unmask(<<>>, _MaskKey, Acc) -> Acc.
payload_length(N) ->
case N of
N when N =< 125 -> <>;
N when N =< 65535 -> <<126, N:16>>;
N when N =< 9223372036854775807 -> <<127, N:64>>
end.
%%
%% Websockets internal functions for hixie-76 websocket version
%%
parse_hixie_frames(<<>>, Frames) ->
lists:reverse(Frames);
parse_hixie_frames(<<0, T/binary>>, Frames) ->
{Frame, Rest} = parse_hixie(T, <<>>),
parse_hixie_frames(Rest, [Frame | Frames]).
parse_hixie(<<255, Rest/binary>>, Buffer) ->
{Buffer, Rest};
parse_hixie(<>, Buffer) ->
parse_hixie(T, <>).
mochiweb-3.2.1/src/reloader.erl 0000664 0000000 0000000 00000013416 14503332274 0016412 0 ustar 00root root 0000000 0000000 %% @author Matthew Dempsky
%% @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 Erlang module for automatically reloading modified modules
%% during development.
-module(reloader).
-author("Matthew Dempsky ").
-include_lib("kernel/include/file.hrl").
-behaviour(gen_server).
-export([start/0, start_link/0]).
-export([stop/0]).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2, terminate/2, code_change/3]).
-export([all_changed/0]).
-export([is_changed/1]).
-export([reload_modules/1]).
-record(state, {last, tref}).
%% External API
%% @spec start() -> ServerRet
%% @doc Start the reloader.
start() ->
gen_server:start({local, ?MODULE}, ?MODULE, [], []).
%% @spec start_link() -> ServerRet
%% @doc Start the reloader.
start_link() ->
gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
%% @spec stop() -> ok
%% @doc Stop the reloader.
stop() ->
gen_server:call(?MODULE, stop).
%% gen_server callbacks
%% @spec init([]) -> {ok, State}
%% @doc gen_server init, opens the server in an initial state.
init([]) ->
{ok, TRef} = timer:send_interval(timer:seconds(1), doit),
{ok, #state{last = stamp(), tref = TRef}}.
%% @spec handle_call(Args, From, State) -> tuple()
%% @doc gen_server callback.
handle_call(stop, _From, State) ->
{stop, shutdown, stopped, State};
handle_call(_Req, _From, State) ->
{reply, {error, badrequest}, State}.
%% @spec handle_cast(Cast, State) -> tuple()
%% @doc gen_server callback.
handle_cast(_Req, State) ->
{noreply, State}.
%% @spec handle_info(Info, State) -> tuple()
%% @doc gen_server callback.
handle_info(doit, State) ->
Now = stamp(),
_ = doit(State#state.last, Now),
{noreply, State#state{last = Now}};
handle_info(_Info, State) ->
{noreply, State}.
%% @spec terminate(Reason, State) -> ok
%% @doc gen_server termination callback.
terminate(_Reason, State) ->
{ok, cancel} = timer:cancel(State#state.tref),
ok.
%% @spec code_change(_OldVsn, State, _Extra) -> State
%% @doc gen_server code_change callback (trivial).
code_change(_Vsn, State, _Extra) ->
{ok, State}.
%% @spec reload_modules([atom()]) -> [{module, atom()} | {error, term()}]
%% @doc code:purge/1 and code:load_file/1 the given list of modules in order,
%% return the results of code:load_file/1.
reload_modules(Modules) ->
[begin code:purge(M), code:load_file(M) end || M <- Modules].
%% @spec all_changed() -> [atom()]
%% @doc Return a list of beam modules that have changed.
all_changed() ->
[M || {M, Fn} <- code:all_loaded(), is_list(Fn), is_changed(M)].
%% @spec is_changed(atom()) -> boolean()
%% @doc true if the loaded module is a beam with a vsn attribute
%% and does not match the on-disk beam file, returns false otherwise.
is_changed(M) ->
try
module_vsn(M:module_info()) =/= module_vsn(code:get_object_code(M))
catch _:_ ->
false
end.
%% Internal API
module_vsn({M, Beam, _Fn}) ->
{ok, {M, Vsn}} = beam_lib:version(Beam),
Vsn;
module_vsn(L) when is_list(L) ->
{_, Attrs} = lists:keyfind(attributes, 1, L),
{_, Vsn} = lists:keyfind(vsn, 1, Attrs),
Vsn.
doit(From, To) ->
[case file:read_file_info(Filename) of
{ok, #file_info{mtime = Mtime}} when Mtime >= From, Mtime < To ->
reload(Module);
{ok, _} ->
unmodified;
{error, enoent} ->
%% The Erlang compiler deletes existing .beam files if
%% recompiling fails. Maybe it's worth spitting out a
%% warning here, but I'd want to limit it to just once.
gone;
{error, Reason} ->
io:format("Error reading ~s's file info: ~p~n",
[Filename, Reason]),
error
end || {Module, Filename} <- code:all_loaded(), is_list(Filename)].
reload(Module) ->
io:format("Reloading ~p ...", [Module]),
code:purge(Module),
case code:load_file(Module) of
{module, Module} ->
io:format(" ok.~n"),
case erlang:function_exported(Module, test, 0) of
true ->
io:format(" - Calling ~p:test() ...", [Module]),
case catch Module:test() of
ok ->
io:format(" ok.~n"),
reload;
Reason ->
io:format(" fail: ~p.~n", [Reason]),
reload_but_test_failed
end;
false ->
reload
end;
{error, Reason} ->
io:format(" fail: ~p.~n", [Reason]),
error
end.
stamp() ->
erlang:localtime().
%%
%% Tests
%%
-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").
-endif.
mochiweb-3.2.1/support/ 0000775 0000000 0000000 00000000000 14503332274 0015031 5 ustar 00root root 0000000 0000000 mochiweb-3.2.1/support/test-materials/ 0000775 0000000 0000000 00000000000 14503332274 0017767 5 ustar 00root root 0000000 0000000 mochiweb-3.2.1/support/test-materials/test_ssl_cert.pem 0000664 0000000 0000000 00000002167 14503332274 0023355 0 ustar 00root root 0000000 0000000 -----BEGIN CERTIFICATE-----
MIIDIDCCAgigAwIBAgIJAJLkNZzERPIUMA0GCSqGSIb3DQEBBQUAMBQxEjAQBgNV
BAMTCWxvY2FsaG9zdDAeFw0xMDAzMTgxOTM5MThaFw0yMDAzMTUxOTM5MThaMBQx
EjAQBgNVBAMTCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
ggEBAJeUCOZxbmtngF4S5lXckjSDLc+8C+XjMBYBPyy5eKdJY20AQ1s9/hhp3ulI
8pAvl+xVo4wQ+iBSvOzcy248Q+Xi6+zjceF7UNRgoYPgtJjKhdwcHV3mvFFrS/fp
9ggoAChaJQWDO1OCfUgTWXImhkw+vcDR11OVMAJ/h73dqzJPI9mfq44PTTHfYtgr
v4LAQAOlhXIAa2B+a6PlF6sqDqJaW5jLTcERjsBwnRhUGi7JevQzkejujX/vdA+N
jRBjKH/KLU5h3Q7wUchvIez0PXWVTCnZjpA9aR4m7YV05nKQfxtGd71czYDYk+j8
hd005jetT4ir7JkAWValBybJVksCAwEAAaN1MHMwHQYDVR0OBBYEFJl9s51SnjJt
V/wgKWqV5Q6jnv1ZMEQGA1UdIwQ9MDuAFJl9s51SnjJtV/wgKWqV5Q6jnv1ZoRik
FjAUMRIwEAYDVQQDEwlsb2NhbGhvc3SCCQCS5DWcxETyFDAMBgNVHRMEBTADAQH/
MA0GCSqGSIb3DQEBBQUAA4IBAQB2ldLeLCc+lxK5i0EZquLamMBJwDIjGpT0JMP9
b4XQOK2JABIu54BQIZhwcjk3FDJz/uOW5vm8k1kYni8FCjNZAaRZzCUfiUYTbTKL
Rq9LuIAODyP2dnTqyKaQOOJHvrx9MRZ3XVecXPS0Tib4aO57vCaAbIkmhtYpTWmw
e3t8CAIDVtgvjR6Se0a1JA4LktR7hBu22tDImvCSJn1nVAaHpani6iPBPPdMuMsP
TBoeQfj8VpqBUjCStqJGa8ytjDFX73YaxV2mgrtGwPNme1x3YNRR11yTu7tksyMO
GrmgxNriqYRchBhNEf72AKF0LR1ByKwfbDB9rIsV00HtCgOp
-----END CERTIFICATE-----
mochiweb-3.2.1/support/test-materials/test_ssl_key.pem 0000664 0000000 0000000 00000003217 14503332274 0023205 0 ustar 00root root 0000000 0000000 -----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEAl5QI5nFua2eAXhLmVdySNIMtz7wL5eMwFgE/LLl4p0ljbQBD
Wz3+GGne6UjykC+X7FWjjBD6IFK87NzLbjxD5eLr7ONx4XtQ1GChg+C0mMqF3Bwd
Xea8UWtL9+n2CCgAKFolBYM7U4J9SBNZciaGTD69wNHXU5UwAn+Hvd2rMk8j2Z+r
jg9NMd9i2Cu/gsBAA6WFcgBrYH5ro+UXqyoOolpbmMtNwRGOwHCdGFQaLsl69DOR
6O6Nf+90D42NEGMof8otTmHdDvBRyG8h7PQ9dZVMKdmOkD1pHibthXTmcpB/G0Z3
vVzNgNiT6PyF3TTmN61PiKvsmQBZVqUHJslWSwIDAQABAoIBACI8Ky5xHDFh9RpK
Rn/KC7OUlTpADKflgizWJ0Cgu2F9L9mkn5HyFHvLHa+u7CootbWJOiEejH/UcBtH
WyMQtX0snYCpdkUpJv5wvMoebGu+AjHOn8tfm9T/2O6rhwgckLyMb6QpGbMo28b1
p9QiY17BJPZx7qJQJcHKsAvwDwSThlb7MFmWf42LYWlzybpeYQvwpd+UY4I0WXLu
/dqJIS9Npq+5Y5vbo2kAEAssb2hSCvhCfHmwFdKmBzlvgOn4qxgZ1iHQgfKI6Z3Y
J0573ZgOVTuacn+lewtdg5AaHFcl/zIYEr9SNqRoPNGbPliuv6k6N2EYcufWL5lR
sCmmmHECgYEAxm+7OpepGr++K3+O1e1MUhD7vSPkKJrCzNtUxbOi2NWj3FFUSPRU
adWhuxvUnZgTcgM1+KuQ0fB2VmxXe9IDcrSFS7PKFGtd2kMs/5mBw4UgDZkOQh+q
kDiBEV3HYYJWRq0w3NQ/9Iy1jxxdENHtGmG9aqamHxNtuO608wGW2S8CgYEAw4yG
ZyAic0Q/U9V2OHI0MLxLCzuQz17C2wRT1+hBywNZuil5YeTuIt2I46jro6mJmWI2
fH4S/geSZzg2RNOIZ28+aK79ab2jWBmMnvFCvaru+odAuser4N9pfAlHZvY0pT+S
1zYX3f44ygiio+oosabLC5nWI0zB2gG8pwaJlaUCgYEAgr7poRB+ZlaCCY0RYtjo
mYYBKD02vp5BzdKSB3V1zeLuBWM84pjB6b3Nw0fyDig+X7fH3uHEGN+USRs3hSj6
BqD01s1OT6fyfbYXNw5A1r+nP+5h26Wbr0zblcKxdQj4qbbBZC8hOJNhqTqqA0Qe
MmzF7jiBaiZV/Cyj4x1f9BcCgYEAhjL6SeuTuOctTqs/5pz5lDikh6DpUGcH8qaV
o6aRAHHcMhYkZzpk8yh1uUdD7516APmVyvn6rrsjjhLVq4ZAJjwB6HWvE9JBN0TR
bILF+sREHUqU8Zn2Ku0nxyfXCKIOnxlx/J/y4TaGYqBqfXNFWiXNUrjQbIlQv/xR
K48g/MECgYBZdQlYbMSDmfPCC5cxkdjrkmAl0EgV051PWAi4wR+hLxIMRjHBvAk7
IweobkFvT4TICulgroLkYcSa5eOZGxB/DHqcQCbWj3reFV0VpzmTDoFKG54sqBRl
vVntGt0pfA40fF17VoS7riAdHF53ippTtsovHEsg5tq5NrBl5uKm2g==
-----END RSA PRIVATE KEY-----
mochiweb-3.2.1/test/ 0000775 0000000 0000000 00000000000 14503332274 0014274 5 ustar 00root root 0000000 0000000 mochiweb-3.2.1/test/mochiweb_base64url_tests.erl 0000664 0000000 0000000 00000001253 14503332274 0021707 0 ustar 00root root 0000000 0000000 -module(mochiweb_base64url_tests).
-include_lib("eunit/include/eunit.hrl").
id(X) ->
?assertEqual(
X,
mochiweb_base64url:decode(mochiweb_base64url:encode(X))),
?assertEqual(
X,
mochiweb_base64url:decode(
binary_to_list(mochiweb_base64url:encode(binary_to_list(X))))).
random_binary(Short,Long) ->
<< <<(rand:uniform(256) - 1)>>
|| _ <- lists:seq(1, Short + rand:uniform(1 + Long - Short) - 1) >>.
empty_test() ->
id(<<>>).
onechar_test() ->
[id(<>) || C <- lists:seq(0,255)],
ok.
nchar_test() ->
%% 1000 tests of 2-6 char strings
[id(B) || _ <- lists:seq(1,1000), B <- [random_binary(2, 6)]],
ok.
mochiweb-3.2.1/test/mochiweb_html_tests.erl 0000664 0000000 0000000 00000063100 14503332274 0021043 0 ustar 00root root 0000000 0000000 -module(mochiweb_html_tests).
-include_lib("eunit/include/eunit.hrl").
to_html_test() ->
?assertEqual(
<<"hey!what's up
sucka
RAW!">>,
iolist_to_binary(
mochiweb_html:to_html({html, [],
[{<<"head">>, [],
[{title, <<"hey!">>}]},
{body, [],
[{p, [{class, foo}], [<<"what's">>, <<" up">>, {br}]},
{'div', <<"sucka">>},
{'=', <<"RAW!">>},
{comment, <<" comment! ">>}]}]}))),
?assertEqual(
<<"">>,
iolist_to_binary(
mochiweb_html:to_html({doctype,
[<<"html">>, <<"PUBLIC">>,
<<"-//W3C//DTD XHTML 1.0 Transitional//EN">>,
<<"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">>]}))),
?assertEqual(
<<"">>,
iolist_to_binary(
mochiweb_html:to_html({<<"html">>,[],
[{pi, <<"xml:namespace">>,
[{<<"prefix">>,<<"o">>},
{<<"ns">>,<<"urn:schemas-microsoft-com:office:office">>}]}]}))),
ok.
escape_test() ->
?assertEqual(
<<""\"word ><<up!"">>,
mochiweb_html:escape(<<""\"word ><>)),
?assertEqual(
<<""\"word ><<up!"">>,
mochiweb_html:escape(""\"word ><>,
mochiweb_html:escape('"\"word ><
?assertEqual(
<<"""word ><<up!"">>,
mochiweb_html:escape_attr(<<""\"word ><>)),
?assertEqual(
<<"""word ><<up!"">>,
mochiweb_html:escape_attr(""\"word ><>,
mochiweb_html:escape_attr('"\"word ><>,
mochiweb_html:escape_attr(12345)),
?assertEqual(
<<"1.5">>,
mochiweb_html:escape_attr(1.5)),
ok.
tokens_test() ->
?assertEqual(
[{start_tag, <<"foo">>, [{<<"bar">>, <<"baz">>},
{<<"wibble">>, <<"wibble">>},
{<<"alice">>, <<"bob">>}], true}],
mochiweb_html:tokens(<<"">>)),
?assertEqual(
[{start_tag, <<"foo">>, [{<<"bar">>, <<"baz">>},
{<<"wibble">>, <<"wibble">>},
{<<"alice">>, <<"bob">>}], true}],
mochiweb_html:tokens(<<"">>)),
?assertEqual(
[{comment, <<"[if lt IE 7]>\n\n>}],
mochiweb_html:tokens(<<"">>)),
?assertEqual(
[{start_tag, <<"script">>, [{<<"type">>, <<"text/javascript">>}], false},
{data, <<" A= B <= C ">>, false},
{end_tag, <<"script">>}],
mochiweb_html:tokens(<<"">>)),
?assertEqual(
[{start_tag, <<"script">>, [{<<"type">>, <<"text/javascript">>}], false},
{data, <<" A= B <= C ">>, false},
{end_tag, <<"script">>}],
mochiweb_html:tokens(<<"">>)),
?assertEqual(
[{start_tag, <<"script">>, [{<<"type">>, <<"text/javascript">>}], false},
{data, <<" A= B <= C ">>, false},
{end_tag, <<"script">>}],
mochiweb_html:tokens(<<"">>)),
?assertEqual(
[{start_tag, <<"script">>, [{<<"type">>, <<"text/javascript">>}], false},
{data, <<" A= B <= C ">>, false},
{end_tag, <<"script">>}],
mochiweb_html:tokens(<<"">>)),
?assertEqual(
[{start_tag, <<"textarea">>, [], false},
{data, <<"">>, false},
{end_tag, <<"textarea">>}],
mochiweb_html:tokens(<<"">>)),
?assertEqual(
[{start_tag, <<"textarea">>, [], false},
{data, <<"">>, false}],
mochiweb_html:tokens(<<"