umgeher/cowboy
0
Fork 0
mirror of https://github.com/ninenines/cowboy.git synced 2025-07-14 20:30:23 +00:00
Code Issues Wiki Activity
cowboy/src/cowboy_http_req.erl

289 lines
9.8 KiB
Erlang
Raw Normal View History

Initial commit.
2011-03-07 22:59:22 +01:00
%% Copyright (c) 2011, Loïc Hoguin <essen@dev-extend.eu>
Make HTTP req accessors call themselves with their default default value Use lists:keyfind/3 in qs_val/3, binding/3 and header/3 and make qs_val/2, binding/2 and header/2 call those.
2011-03-29 13:49:48 +02:00
%% Copyright (c) 2011, Anthony Ramine <nox@dev-extend.eu>
Initial commit.
2011-03-07 22:59:22 +01:00
%%
%% Permission to use, copy, modify, and/or distribute this software for any
%% purpose with or without fee is hereby granted, provided that the above
%% copyright notice and this permission notice appear in all copies.
%%
%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-module(cowboy_http_req).
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
Initial commit.
2011-03-07 22:59:22 +01:00
-export([
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
method/1, version/1, peer/1,
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.
2011-05-04 12:05:57 +02:00
host/1, raw_host/1, port/1,
Initial commit.
2011-03-07 22:59:22 +01:00
path/1, raw_path/1,
qs_val/2, qs_val/3, qs_vals/1, raw_qs/1,
binding/2, binding/3, bindings/1,
header/2, header/3, headers/1
%% cookie/2, cookie/3, cookies/1 @todo
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
]). %% Request API.
Skip the request body if it hasn't been read by the handler.
2011-03-21 17:26:00 +01:00
-export([
Introduce cowboy_http_req:body_qs/1 for automated urlencoded body parsing.
2011-03-22 13:20:21 +01:00
body/1, body/2, body_qs/1
Skip the request body if it hasn't been read by the handler.
2011-03-21 17:26:00 +01:00
]). %% Request Body API.
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
-export([
reply/4
]). %% Response API.
Initial commit.
2011-03-07 22:59:22 +01:00
-include("include/http.hrl").
-include_lib("eunit/include/eunit.hrl").
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
%% Request API.
Initial commit.
2011-03-07 22:59:22 +01:00
-spec method(Req::#http_req{}) -> {Method::http_method(), Req::#http_req{}}.
method(Req) ->
{Req#http_req.method, Req}.
-spec version(Req::#http_req{}) -> {Version::http_version(), Req::#http_req{}}.
version(Req) ->
{Req#http_req.version, Req}.
-spec peer(Req::#http_req{})
Replace port_number() by ip_port() from kernel/include/inet.hrl.
2011-04-18 13:52:32 +02:00
-> {{Address::ip_address(), Port::ip_port()}, Req::#http_req{}}.
Lazy-retrieve the peer name and port to avoid wasting time each request.
2011-03-20 16:09:05 +01:00
peer(Req=#http_req{socket=Socket, transport=Transport, peer=undefined}) ->
{ok, Peer} = Transport:peername(Socket),
{Peer, Req#http_req{peer=Peer}};
Initial commit.
2011-03-07 22:59:22 +01:00
peer(Req) ->
{Req#http_req.peer, Req}.
Move the dispatcher related types into cowboy_dispatcher.
2011-04-18 13:24:27 +02:00
-spec host(Req::#http_req{})
-> {Host::cowboy_dispatcher:path_tokens(), Req::#http_req{}}.
Initial commit.
2011-03-07 22:59:22 +01:00
host(Req) ->
{Req#http_req.host, Req}.
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec raw_host(Req::#http_req{}) -> {RawHost::binary(), Req::#http_req{}}.
Initial commit.
2011-03-07 22:59:22 +01:00
raw_host(Req) ->
{Req#http_req.raw_host, Req}.
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.
2011-05-04 12:05:57 +02:00
-spec port(Req::#http_req{}) -> {Port::ip_port(), Req::#http_req{}}.
port(Req) ->
{Req#http_req.port, Req}.
Move the dispatcher related types into cowboy_dispatcher.
2011-04-18 13:24:27 +02:00
-spec path(Req::#http_req{})
-> {Path::cowboy_dispatcher:path_tokens(), Req::#http_req{}}.
Initial commit.
2011-03-07 22:59:22 +01:00
path(Req) ->
{Req#http_req.path, Req}.
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec raw_path(Req::#http_req{}) -> {RawPath::binary(), Req::#http_req{}}.
Initial commit.
2011-03-07 22:59:22 +01:00
raw_path(Req) ->
{Req#http_req.raw_path, Req}.
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec qs_val(Name::binary(), Req::#http_req{})
-> {Value::binary() | true | undefined, Req::#http_req{}}.
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
%% @equiv qs_val(Name, Req) -> qs_val(Name, Req, undefined)
Initial commit.
2011-03-07 22:59:22 +01:00
qs_val(Name, Req) ->
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
qs_val(Name, Req, undefined).
Initial commit.
2011-03-07 22:59:22 +01:00
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec qs_val(Name::binary(), Req::#http_req{}, Default)
-> {Value::binary() | true | Default, Req::#http_req{}}
Make HTTP req accessors call themselves with their default default value Use lists:keyfind/3 in qs_val/3, binding/3 and header/3 and make qs_val/2, binding/2 and header/2 call those.
2011-03-29 13:49:48 +02:00
when Default::term().
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
qs_val(Name, Req=#http_req{raw_qs=RawQs, qs_vals=undefined}, Default) ->
Initial commit.
2011-03-07 22:59:22 +01:00
QsVals = parse_qs(RawQs),
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
qs_val(Name, Req#http_req{qs_vals=QsVals}, Default);
qs_val(Name, Req, Default) ->
Make HTTP req accessors call themselves with their default default value Use lists:keyfind/3 in qs_val/3, binding/3 and header/3 and make qs_val/2, binding/2 and header/2 call those.
2011-03-29 13:49:48 +02:00
case lists:keyfind(Name, 1, Req#http_req.qs_vals) of
{Name, Value} -> {Value, Req};
false -> {Default, Req}
end.
Initial commit.
2011-03-07 22:59:22 +01:00
Fix spec for cowboy_http_req:qs_vals/1.
2011-03-21 22:33:42 +01:00
-spec qs_vals(Req::#http_req{})
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-> {list({Name::binary(), Value::binary() | true}), Req::#http_req{}}.
Initial commit.
2011-03-07 22:59:22 +01:00
qs_vals(Req=#http_req{raw_qs=RawQs, qs_vals=undefined}) ->
QsVals = parse_qs(RawQs),
qs_vals(Req#http_req{qs_vals=QsVals});
qs_vals(Req=#http_req{qs_vals=QsVals}) ->
{QsVals, Req}.
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec raw_qs(Req::#http_req{}) -> {RawQs::binary(), Req::#http_req{}}.
Initial commit.
2011-03-07 22:59:22 +01:00
raw_qs(Req) ->
{Req#http_req.raw_qs, Req}.
-spec binding(Name::atom(), Req::#http_req{})
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-> {Value::binary() | undefined, Req::#http_req{}}.
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
%% @equiv binding(Name, Req) -> binding(Name, Req, undefined)
Initial commit.
2011-03-07 22:59:22 +01:00
binding(Name, Req) ->
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
binding(Name, Req, undefined).
Make HTTP req accessors call themselves with their default default value Use lists:keyfind/3 in qs_val/3, binding/3 and header/3 and make qs_val/2, binding/2 and header/2 call those.
2011-03-29 13:49:48 +02:00
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
-spec binding(Name::atom(), Req::#http_req{}, Default)
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-> {Value::binary() | Default, Req::#http_req{}} when Default::term().
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
binding(Name, Req, Default) ->
Return undefined instead of failing or returning "" when a value doesn't exist.
2011-03-27 13:11:57 +02:00
case lists:keyfind(Name, 1, Req#http_req.bindings) of
{Name, Value} -> {Value, Req};
Make HTTP req accessors call themselves with their default default value Use lists:keyfind/3 in qs_val/3, binding/3 and header/3 and make qs_val/2, binding/2 and header/2 call those.
2011-03-29 13:49:48 +02:00
false -> {Default, Req}
Return undefined instead of failing or returning "" when a value doesn't exist.
2011-03-27 13:11:57 +02:00
end.
Initial commit.
2011-03-07 22:59:22 +01:00
-spec bindings(Req::#http_req{})
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-> {list({Name::atom(), Value::binary()}), Req::#http_req{}}.
Initial commit.
2011-03-07 22:59:22 +01:00
bindings(Req) ->
{Req#http_req.bindings, Req}.
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec header(Name::atom() | binary(), Req::#http_req{})
-> {Value::binary() | undefined, Req::#http_req{}}.
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
%% @equiv header(Name, Req) -> header(Name, Req, undefined)
Initial commit.
2011-03-07 22:59:22 +01:00
header(Name, Req) ->
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
header(Name, Req, undefined).
Make HTTP req accessors call themselves with their default default value Use lists:keyfind/3 in qs_val/3, binding/3 and header/3 and make qs_val/2, binding/2 and header/2 call those.
2011-03-29 13:49:48 +02:00
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec header(Name::atom() | binary(), Req::#http_req{}, Default)
-> {Value::binary() | Default, Req::#http_req{}} when Default::term().
Make the default value the last parameter of HTTP req accessors This makes cowboy_http_req's qs_val/3, binding/3 and header/3 behave like proplists:get_value/3.
2011-03-29 13:57:21 +02:00
header(Name, Req, Default) ->
Skip the request body if it hasn't been read by the handler.
2011-03-21 17:26:00 +01:00
case lists:keyfind(Name, 1, Req#http_req.headers) of
{Name, Value} -> {Value, Req};
Make HTTP req accessors call themselves with their default default value Use lists:keyfind/3 in qs_val/3, binding/3 and header/3 and make qs_val/2, binding/2 and header/2 call those.
2011-03-29 13:49:48 +02:00
false -> {Default, Req}
Skip the request body if it hasn't been read by the handler.
2011-03-21 17:26:00 +01:00
end.
Initial commit.
2011-03-07 22:59:22 +01:00
-spec headers(Req::#http_req{})
Use http_headers() type in cowboy_http_req:headers/1.
2011-05-04 11:29:06 +02:00
-> {Headers::http_headers(), Req::#http_req{}}.
Initial commit.
2011-03-07 22:59:22 +01:00
headers(Req) ->
{Req#http_req.headers, Req}.
Skip the request body if it hasn't been read by the handler.
2011-03-21 17:26:00 +01:00
%% Request Body API.
%% @todo We probably want to allow a max length.
Introduce cowboy_http_req:body/1 to read the full request body.
2011-03-21 21:28:24 +01:00
-spec body(Req::#http_req{})
Replace posix() by atom(), for now. The type isn't exported by OTP so we don't win much. Also, inet.erl and file.erl define posix() différently, so OTP needs to stop being so confuse in the first place before we can attempt to use it properly.
2011-04-18 13:32:35 +02:00
-> {ok, Body::binary(), Req::#http_req{}} | {error, Reason::atom()}.
Introduce cowboy_http_req:body/1 to read the full request body.
2011-03-21 21:28:24 +01:00
body(Req) ->
{Length, Req2} = cowboy_http_req:header('Content-Length', Req),
case Length of
Fix cowboy_http_req:body with regard to the new accessors default value header/2 now returns 'undefined' when the header isn't in the request.
2011-03-29 13:55:53 +02:00
undefined -> {error, badarg};
Introduce cowboy_http_req:body/1 to read the full request body.
2011-03-21 21:28:24 +01:00
_Any ->
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
Length2 = list_to_integer(binary_to_list(Length)),
Introduce cowboy_http_req:body/1 to read the full request body.
2011-03-21 21:28:24 +01:00
body(Length2, Req2)
end.
%% @todo We probably want to configure the timeout.
Skip the request body if it hasn't been read by the handler.
2011-03-21 17:26:00 +01:00
-spec body(Length::non_neg_integer(), Req::#http_req{})
Replace posix() by atom(), for now. The type isn't exported by OTP so we don't win much. Also, inet.erl and file.erl define posix() différently, so OTP needs to stop being so confuse in the first place before we can attempt to use it properly.
2011-04-18 13:32:35 +02:00
-> {ok, Body::binary(), Req::#http_req{}} | {error, Reason::atom()}.
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
body(Length, Req=#http_req{body_state=waiting, buffer=Buffer})
when Length =:= byte_size(Buffer) ->
{ok, Buffer, Req#http_req{body_state=done, buffer= <<>>}};
Boring 80-col change.
2011-03-22 13:23:40 +01:00
body(Length, Req=#http_req{socket=Socket, transport=Transport,
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
body_state=waiting, buffer=Buffer}) when Length > byte_size(Buffer) ->
case Transport:recv(Socket, Length - byte_size(Buffer), 5000) of
{ok, Body} -> {ok, << Buffer/binary, Body/binary >>, Req#http_req{body_state=done, buffer= <<>>}};
Skip the request body if it hasn't been read by the handler.
2011-03-21 17:26:00 +01:00
{error, Reason} -> {error, Reason}
end.
Introduce cowboy_http_req:body_qs/1 for automated urlencoded body parsing.
2011-03-22 13:20:21 +01:00
-spec body_qs(Req::#http_req{})
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-> {list({Name::binary(), Value::binary() | true}), Req::#http_req{}}.
Introduce cowboy_http_req:body_qs/1 for automated urlencoded body parsing.
2011-03-22 13:20:21 +01:00
body_qs(Req) ->
{ok, Body, Req2} = body(Req),
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
{parse_qs(Body), Req2}.
Introduce cowboy_http_req:body_qs/1 for automated urlencoded body parsing.
2011-03-22 13:20:21 +01:00
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
%% Response API.
-spec reply(Code::http_status(), Headers::http_headers(),
Fix specs for cowboy_http_req:reply/4. Body is iodata(), not iolist().
2011-04-14 14:13:26 +02:00
Body::iodata(), Req::#http_req{}) -> {ok, Req::#http_req{}}.
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
reply(Code, Headers, Body, Req=#http_req{socket=Socket,
Make sure we can only reply to an HTTP request inside Handler:handle. Of course since requests are a record the response state can be explicitly overriden, but standard use prevents errors by making sure only one reply is sent.
2011-03-20 18:03:11 +01:00
transport=Transport, connection=Connection,
resp_state=waiting}) ->
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
StatusLine = <<"HTTP/1.1 ", (status(Code))/binary, "\r\n">>,
Fix a bug where dupe headers were sent in cowboy_http_req:reply/4. Now the server defines default headers that can be overwritten by the handler simply by passing them to the reply/4 function. Default headers include, for now, Connection and Content-Length headers. Note that it isn't enough to change the Connection header to close a keep-alive connection server-side.
2011-04-14 01:26:02 +02:00
DefaultHeaders = [
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
{<<"Connection">>, atom_to_connection(Connection)},
{<<"Content-Length">>, list_to_binary(integer_to_list(iolist_size(Body)))}
Fix a bug where dupe headers were sent in cowboy_http_req:reply/4. Now the server defines default headers that can be overwritten by the handler simply by passing them to the reply/4 function. Default headers include, for now, Connection and Content-Length headers. Note that it isn't enough to change the Connection header to close a keep-alive connection server-side.
2011-04-14 01:26:02 +02:00
],
Headers2 = lists:keysort(1, Headers),
Headers3 = lists:ukeymerge(1, Headers2, DefaultHeaders),
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
Headers4 = [<< Key/binary, ": ", Value/binary, "\r\n">> || {Key, Value} <- Headers3],
Transport:send(Socket, [StatusLine, Headers4, <<"\r\n">>, Body]),
Make sure we can only reply to an HTTP request inside Handler:handle. Of course since requests are a record the response state can be explicitly overriden, but standard use prevents errors by making sure only one reply is sent.
2011-03-20 18:03:11 +01:00
{ok, Req#http_req{resp_state=done}}.
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
Initial commit.
2011-03-07 22:59:22 +01:00
%% Internal.
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec parse_qs(Qs::binary()) -> list({Name::binary(), Value::binary() | true}).
parse_qs(<<>>) ->
[];
Initial commit.
2011-03-07 22:59:22 +01:00
parse_qs(Qs) ->
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
Tokens = binary:split(Qs, <<"&">>, [global, trim]),
[case binary:split(Token, <<"=">>) of
[Token] -> {Token, true};
[Name, Value] -> {Name, Value}
Initial commit.
2011-03-07 22:59:22 +01:00
end || Token <- Tokens].
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
-spec atom_to_connection(Atom::keepalive | close) -> binary().
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
atom_to_connection(keepalive) ->
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
<<"keep-alive">>;
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
atom_to_connection(close) ->
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
<<"close">>.
-spec status(Code::http_status()) -> binary().
status(100) -> <<"100 Continue">>;
status(101) -> <<"101 Switching Protocols">>;
status(102) -> <<"102 Processing">>;
status(200) -> <<"200 OK">>;
status(201) -> <<"201 Created">>;
status(202) -> <<"202 Accepted">>;
status(203) -> <<"203 Non-Authoritative Information">>;
status(204) -> <<"204 No Content">>;
status(205) -> <<"205 Reset Content">>;
status(206) -> <<"206 Partial Content">>;
status(207) -> <<"207 Multi-Status">>;
status(226) -> <<"226 IM Used">>;
status(300) -> <<"300 Multiple Choices">>;
status(301) -> <<"301 Moved Permanently">>;
status(302) -> <<"302 Found">>;
status(303) -> <<"303 See Other">>;
status(304) -> <<"304 Not Modified">>;
status(305) -> <<"305 Use Proxy">>;
status(306) -> <<"306 Switch Proxy">>;
status(307) -> <<"307 Temporary Redirect">>;
status(400) -> <<"400 Bad Request">>;
status(401) -> <<"401 Unauthorized">>;
status(402) -> <<"402 Payment Required">>;
status(403) -> <<"403 Forbidden">>;
status(404) -> <<"404 Not Found">>;
status(405) -> <<"405 Method Not Allowed">>;
status(406) -> <<"406 Not Acceptable">>;
status(407) -> <<"407 Proxy Authentication Required">>;
status(408) -> <<"408 Request Timeout">>;
status(409) -> <<"409 Conflict">>;
status(410) -> <<"410 Gone">>;
status(411) -> <<"411 Length Required">>;
status(412) -> <<"412 Precondition Failed">>;
status(413) -> <<"413 Request Entity Too Large">>;
status(414) -> <<"414 Request-URI Too Long">>;
status(415) -> <<"415 Unsupported Media Type">>;
status(416) -> <<"416 Requested Range Not Satisfiable">>;
status(417) -> <<"417 Expectation Failed">>;
status(418) -> <<"418 I'm a teapot">>;
status(422) -> <<"422 Unprocessable Entity">>;
status(423) -> <<"423 Locked">>;
status(424) -> <<"424 Failed Dependency">>;
status(425) -> <<"425 Unordered Collection">>;
status(426) -> <<"426 Upgrade Required">>;
status(500) -> <<"500 Internal Server Error">>;
status(501) -> <<"501 Not Implemented">>;
status(502) -> <<"502 Bad Gateway">>;
status(503) -> <<"503 Service Unavailable">>;
status(504) -> <<"504 Gateway Timeout">>;
status(505) -> <<"505 HTTP Version Not Supported">>;
status(506) -> <<"506 Variant Also Negotiates">>;
status(507) -> <<"507 Insufficient Storage">>;
status(510) -> <<"510 Not Extended">>;
status(B) when is_binary(B) -> B.
Move the reply function to cowboy_http_req.
2011-03-18 22:38:26 +01:00
Initial commit.
2011-03-07 22:59:22 +01:00
%% Tests.
-ifdef(TEST).
parse_qs_test_() ->
%% {Qs, Result}
Tests = [
Switch the HTTP protocol to use binary packets instead of lists. The server now does a single recv (or more, but only if needed) which is then sent to erlang:decode_packet/3 multiple times. Since most requests are smaller than the default MTU on many platforms, we benefit from this greatly. In the case of requests with a body, the server usually read at least part of the body on the first recv. This is bufferized properly and used when later retrieving the body. In the case of pipelined requests, we can end up reading many requests in a single recv, which are then handled properly using only the buffer containing the received data.
2011-05-05 14:03:39 +02:00
{<<"">>, []},
{<<"a=b">>, [{<<"a">>, <<"b">>}]},
{<<"aaa=bbb">>, [{<<"aaa">>, <<"bbb">>}]},
{<<"a&b">>, [{<<"a">>, true}, {<<"b">>, true}]},
{<<"a=b&c&d=e">>, [{<<"a">>, <<"b">>}, {<<"c">>, true}, {<<"d">>, <<"e">>}]},
{<<"a=b=c=d=e&f=g">>, [{<<"a">>, <<"b=c=d=e">>}, {<<"f">>, <<"g">>}]}
Initial commit.
2011-03-07 22:59:22 +01:00
],
[{Qs, fun() -> R = parse_qs(Qs) end} || {Qs, R} <- Tests].
-endif.
Reference in a new issue Copy permalink