From 6c1f73c53c9260d99f71676b400a27f0a853f584 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lo=C3=AFc=20Hoguin?= Date: Wed, 4 May 2011 12:05:57 +0200 Subject: Add cowboy_http_req:port/1. Returns the port given in the Host header if present, otherwise the default port of 443 for HTTPS and 80 for HTTP is returned. --- include/http.hrl | 1 + src/cowboy_dispatcher.erl | 52 ++++++++++++++++++++++++++++++------------- src/cowboy_http_protocol.erl | 48 +++++++++++++++++++++++++-------------- src/cowboy_http_req.erl | 6 ++++- src/cowboy_http_websocket.erl | 18 +++++++-------- test/http_SUITE.erl | 2 +- 6 files changed, 84 insertions(+), 43 deletions(-) diff --git a/include/http.hrl b/include/http.hrl index 79bfc7b..52eeb12 100644 --- a/include/http.hrl +++ b/include/http.hrl @@ -50,6 +50,7 @@ peer = undefined :: undefined | {Address::ip_address(), Port::ip_port()}, host = undefined :: undefined | cowboy_dispatcher:path_tokens(), raw_host = undefined :: undefined | string(), + port = undefined :: undefined | ip_port(), path = undefined :: undefined | '*' | cowboy_dispatcher:path_tokens(), raw_path = undefined :: undefined | string(), qs_vals = undefined :: undefined | list({Name::string(), Value::string() | true}), diff --git a/src/cowboy_dispatcher.erl b/src/cowboy_dispatcher.erl index 05faa38..4769da0 100644 --- a/src/cowboy_dispatcher.erl +++ b/src/cowboy_dispatcher.erl @@ -24,17 +24,20 @@ -export_type([bindings/0, path_tokens/0, dispatch_rules/0]). +-include_lib("kernel/include/inet.hrl"). -include_lib("eunit/include/eunit.hrl"). %% API. --spec split_host(Host::string()) -> Tokens::path_tokens(). +-spec split_host(Host::string()) + -> {Tokens::path_tokens(), Host::string(), Port::undefined | ip_port()}. split_host(Host) -> - Host2 = case string:chr(Host, $:) of - 0 -> Host; - N -> lists:sublist(Host, N - 1) - end, - string:tokens(Host2, "."). + case string:chr(Host, $:) of + 0 -> {string:tokens(Host, "."), Host, undefined}; + N -> + {Host2, [$:|Port]} = lists:split(N - 1, Host), + {string:tokens(Host2, "."), Host2, list_to_integer(Port)} + end. -spec split_path(Path::string()) -> {Tokens::path_tokens(), Path::string(), Qs::string()}. @@ -119,19 +122,38 @@ list_match([], [], Binds) -> split_host_test_() -> %% {Host, Result} Tests = [ - {"", []}, - {".........", []}, - {"*", ["*"]}, - {"cowboy.dev-extend.eu", ["cowboy", "dev-extend", "eu"]}, - {"dev-extend..eu", ["dev-extend", "eu"]}, - {"dev-extend.eu", ["dev-extend", "eu"]}, - {"dev-extend.eu:8080", ["dev-extend", "eu"]}, + {"", {[], "", undefined}}, + {".........", {[], ".........", undefined}}, + {"*", {["*"], "*", undefined}}, + {"cowboy.dev-extend.eu", {["cowboy", "dev-extend", "eu"], + "cowboy.dev-extend.eu", undefined}}, + {"dev-extend..eu", + {["dev-extend", "eu"], "dev-extend..eu", undefined}}, + {"dev-extend.eu", {["dev-extend", "eu"], "dev-extend.eu", undefined}}, + {"dev-extend.eu:8080", {["dev-extend", "eu"], "dev-extend.eu", 8080}}, {"a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z", - ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", - "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]} + {["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", + "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"], + "a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z", undefined}} ], [{H, fun() -> R = split_host(H) end} || {H, R} <- Tests]. +split_host_fail_test_() -> + Tests = [ + "dev-extend.eu:owns", + "dev-extend.eu: owns", + "dev-extend.eu:42fun", + "dev-extend.eu: 42fun", + "dev-extend.eu:42 fun", + "dev-extend.eu:fun 42", + "dev-extend.eu: 42", + ":owns", + ":42 fun" + ], + [{H, fun() -> case catch split_host(H) of + {'EXIT', _Reason} -> ok + end end} || H <- Tests]. + split_path_test_() -> %% {Path, Result, QueryString} Tests = [ diff --git a/src/cowboy_http_protocol.erl b/src/cowboy_http_protocol.erl index b68980d..602ea6a 100644 --- a/src/cowboy_http_protocol.erl +++ b/src/cowboy_http_protocol.erl @@ -89,8 +89,6 @@ request({http_error, _Any}, State) -> error_terminate(400, State). -spec wait_header(Req::#http_req{}, State::#state{}) -> ok. -%% @todo We don't want to wait T at each header... -%% We want to wait T total until we reach the body. wait_header(Req, State=#state{socket=Socket, transport=Transport, timeout=T}) -> case Transport:recv(Socket, 0, T) of @@ -101,22 +99,19 @@ wait_header(Req, State=#state{socket=Socket, -spec header({http_header, I::integer(), Field::http_header(), R::term(), Value::string()} | http_eoh, Req::#http_req{}, State::#state{}) -> ok. -header({http_header, _I, 'Host', _R, RawHost}, Req=#http_req{path=Path, - host=undefined}, State=#state{dispatch=Dispatch}) -> +header({http_header, _I, 'Host', _R, RawHost}, Req=#http_req{ + transport=Transport, host=undefined}, State) -> RawHost2 = string_to_lower(RawHost), - Host = cowboy_dispatcher:split_host(RawHost2), - %% @todo We probably want to filter the Host and Path here to allow - %% things like url rewriting. - case cowboy_dispatcher:match(Host, Path, Dispatch) of - {ok, Handler, Opts, Binds} -> - wait_header(Req#http_req{ - host=Host, raw_host=RawHost2, bindings=Binds, - headers=[{'Host', RawHost2}|Req#http_req.headers]}, - State#state{handler={Handler, Opts}}); - {error, notfound, host} -> - error_terminate(400, State); - {error, notfound, path} -> - error_terminate(404, State) + case catch cowboy_dispatcher:split_host(RawHost2) of + {Host, RawHost3, undefined} -> + Port = default_port(Transport:name()), + dispatch(Req#http_req{host=Host, raw_host=RawHost3, port=Port, + headers=[{'Host', RawHost3}|Req#http_req.headers]}, State); + {Host, RawHost3, Port} -> + dispatch(Req#http_req{host=Host, raw_host=RawHost3, port=Port, + headers=[{'Host', RawHost3}|Req#http_req.headers]}, State); + {'EXIT', _Reason} -> + error_terminate(400, State) end; %% Ignore Host headers if we already have it. header({http_header, _I, 'Host', _R, _V}, Req, State) -> @@ -137,6 +132,21 @@ header(http_eoh, Req, State) -> header({http_error, _String}, _Req, State) -> error_terminate(500, State). +-spec dispatch(Req::#http_req{}, State::#state{}) -> ok. +dispatch(Req=#http_req{host=Host, path=Path}, + State=#state{dispatch=Dispatch}) -> + %% @todo We probably want to filter the Host and Path here to allow + %% things like url rewriting. + case cowboy_dispatcher:match(Host, Path, Dispatch) of + {ok, Handler, Opts, Binds} -> + wait_header(Req#http_req{bindings=Binds}, + State#state{handler={Handler, Opts}}); + {error, notfound, host} -> + error_terminate(400, State); + {error, notfound, path} -> + error_terminate(404, State) + end. + -spec handler_init(Req::#http_req{}, State::#state{}) -> ok. handler_init(Req, State=#state{ transport=Transport, handler={Handler, Opts}}) -> @@ -227,6 +237,10 @@ connection_to_atom(Connection) -> _Any -> keepalive end. +-spec default_port(TransportName::atom()) -> 80 | 443. +default_port(ssl) -> 443; +default_port(_) -> 80. + %% More efficient implementation of string:to_lower. %% We are excluding a few characters on purpose. -spec string_to_lower(string()) -> string(). diff --git a/src/cowboy_http_req.erl b/src/cowboy_http_req.erl index 569bb9b..f0fc15c 100644 --- a/src/cowboy_http_req.erl +++ b/src/cowboy_http_req.erl @@ -17,7 +17,7 @@ -export([ method/1, version/1, peer/1, - host/1, raw_host/1, + host/1, raw_host/1, port/1, path/1, raw_path/1, qs_val/2, qs_val/3, qs_vals/1, raw_qs/1, binding/2, binding/3, bindings/1, @@ -63,6 +63,10 @@ host(Req) -> raw_host(Req) -> {Req#http_req.raw_host, Req}. +-spec port(Req::#http_req{}) -> {Port::ip_port(), Req::#http_req{}}. +port(Req) -> + {Req#http_req.port, Req}. + -spec path(Req::#http_req{}) -> {Path::cowboy_dispatcher:path_tokens(), Req::#http_req{}}. path(Req) -> diff --git a/src/cowboy_http_websocket.erl b/src/cowboy_http_websocket.erl index 4cd24dc..0150a6f 100644 --- a/src/cowboy_http_websocket.erl +++ b/src/cowboy_http_websocket.erl @@ -81,9 +81,9 @@ upgrade_error(Req=#http_req{socket=Socket, transport=Transport}) -> -spec websocket_handshake(State::#state{}, Req::#http_req{}, HandlerState::term()) -> ok. websocket_handshake(State=#state{origin=Origin, challenge=Challenge}, - Req=#http_req{transport=Transport, raw_host=Host, raw_path=Path}, - HandlerState) -> - Location = websocket_location(Transport:name(), Host, Path), + Req=#http_req{transport=Transport, raw_host=Host, port=Port, + raw_path=Path}, HandlerState) -> + Location = websocket_location(Transport:name(), Host, Port, Path), {ok, Req2} = cowboy_http_req:reply( "101 WebSocket Protocol Handshake", [{"Connection", "Upgrade"}, @@ -94,12 +94,12 @@ websocket_handshake(State=#state{origin=Origin, challenge=Challenge}, handler_loop(State#state{messages=Transport:messages()}, Req2, HandlerState, <<>>). --spec websocket_location(TransName::atom(), Host::string(), Path::string()) - -> string(). -websocket_location(ssl, Host, Path) -> - "wss://" ++ Host ++ Path; -websocket_location(_Any, Host, Path) -> - "ws://" ++ Host ++ Path. +-spec websocket_location(TransName::atom(), Host::string(), + Port::ip_port(), Path::string()) -> string(). +websocket_location(ssl, Host, Port, Path) -> + "wss://" ++ Host ++ ":" ++ integer_to_list(Port) ++ Path; +websocket_location(_Any, Host, Port, Path) -> + "ws://" ++ Host ++ ":" ++ integer_to_list(Port) ++ Path. -spec handler_loop(State::#state{}, Req::#http_req{}, HandlerState::term(), SoFar::binary()) -> ok. diff --git a/test/http_SUITE.erl b/test/http_SUITE.erl index 6807f78..21681be 100644 --- a/test/http_SUITE.erl +++ b/test/http_SUITE.erl @@ -199,7 +199,7 @@ websocket(Config) -> [Headers, Body] = websocket_headers(erlang:decode_packet(httph, Rest, []), []), {'Connection', "Upgrade"} = lists:keyfind('Connection', 1, Headers), {'Upgrade', "WebSocket"} = lists:keyfind('Upgrade', 1, Headers), - {"sec-websocket-location", "ws://localhost/websocket"} + {"sec-websocket-location", "ws://localhost:80/websocket"} = lists:keyfind("sec-websocket-location", 1, Headers), {"sec-websocket-origin", "http://localhost"} = lists:keyfind("sec-websocket-origin", 1, Headers), -- cgit v1.2.3