diff --git a/src/Makefile.am b/src/Makefile.am index bcae9aaa..0384a997 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -127,6 +127,7 @@ NGHTTPX_SRCS = \ shrpx_mruby.cc shrpx_mruby.h \ shrpx_mruby_module.cc shrpx_mruby_module.h \ shrpx_mruby_module_request.cc shrpx_mruby_module_request.h \ + shrpx_mruby_module_response.cc shrpx_mruby_module_response.h \ buffer.h memchunk.h template.h if HAVE_SPDYLAY diff --git a/src/http2.cc b/src/http2.cc index bba0464a..f00aeb0a 100644 --- a/src/http2.cc +++ b/src/http2.cc @@ -664,6 +664,15 @@ const Headers::value_type *get_header(const HeaderIndex &hdidx, int16_t token, return &nva[i]; } +Headers::value_type *get_header(const HeaderIndex &hdidx, int16_t token, + Headers &nva) { + auto i = hdidx[token]; + if (i == -1) { + return nullptr; + } + return &nva[i]; +} + namespace { template InputIt skip_lws(InputIt first, InputIt last) { for (; first != last; ++first) { diff --git a/src/http2.h b/src/http2.h index 182c45d9..09f04cd2 100644 --- a/src/http2.h +++ b/src/http2.h @@ -262,6 +262,9 @@ bool http2_mandatory_request_headers_presence(const HeaderIndex &hdidx); const Headers::value_type *get_header(const HeaderIndex &hdidx, int16_t token, const Headers &nva); +Headers::value_type *get_header(const HeaderIndex &hdidx, int16_t token, + Headers &nva); + struct LinkHeader { // The region of URI is [uri.first, uri.second). std::pair uri; diff --git a/src/shrpx_downstream.cc b/src/shrpx_downstream.cc index d9325699..9c94a2de 100644 --- a/src/shrpx_downstream.cc +++ b/src/shrpx_downstream.cc @@ -609,6 +609,8 @@ const Headers &Downstream::get_response_headers() const { return response_headers_; } +Headers &Downstream::get_response_headers() { return response_headers_; } + int Downstream::index_response_headers() { return index_headers(response_hdidx_, response_headers_, response_content_length_); @@ -619,6 +621,10 @@ Downstream::get_response_header(int16_t token) const { return http2::get_header(response_hdidx_, token, response_headers_); } +Headers::value_type *Downstream::get_response_header(int16_t token) { + return http2::get_header(response_hdidx_, token, response_headers_); +} + void Downstream::rewrite_location_response_header( const std::string &upstream_scheme) { auto hd = diff --git a/src/shrpx_downstream.h b/src/shrpx_downstream.h index 9139eb5d..860934c5 100644 --- a/src/shrpx_downstream.h +++ b/src/shrpx_downstream.h @@ -208,6 +208,7 @@ public: bool request_submission_ready() const; // downstream response API const Headers &get_response_headers() const; + Headers &get_response_headers(); // Lower the response header field names and indexes response // headers. If there are invalid headers (e.g., multiple // Content-Length with different values), returns -1. @@ -217,6 +218,7 @@ public: // the beginning. If no such header is found, returns nullptr. // This function must be called after response headers are indexed. const Headers::value_type *get_response_header(int16_t token) const; + Headers::value_type *get_response_header(int16_t token); // Rewrites the location response header field. void rewrite_location_response_header(const std::string &upstream_scheme); void add_response_header(std::string name, std::string value); diff --git a/src/shrpx_http2_upstream.cc b/src/shrpx_http2_upstream.cc index ecf10b0e..01f6d380 100644 --- a/src/shrpx_http2_upstream.cc +++ b/src/shrpx_http2_upstream.cc @@ -309,14 +309,20 @@ int Http2Upstream::on_request_headers(Downstream *downstream, downstream->inspect_http2_request(); + downstream->set_request_state(Downstream::HEADER_COMPLETE); + auto upstream = downstream->get_upstream(); auto handler = upstream->get_client_handler(); auto worker = handler->get_worker(); auto mruby_ctx = worker->get_mruby_context(); - mruby_ctx->run_on_request_proc(downstream); + if (mruby_ctx->run_on_request_proc(downstream) != 0) { + if (error_reply(downstream, 500) != 0) { + return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE; + } + return 0; + } - downstream->set_request_state(Downstream::HEADER_COMPLETE); if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) { downstream->disable_upstream_rtimer(); diff --git a/src/shrpx_https_upstream.cc b/src/shrpx_https_upstream.cc index 1e609037..98ceb3e8 100644 --- a/src/shrpx_https_upstream.cc +++ b/src/shrpx_https_upstream.cc @@ -273,10 +273,6 @@ int htp_hdrs_completecb(http_parser *htp) { return -1; } - auto handler = upstream->get_client_handler(); - auto worker = handler->get_worker(); - auto mruby_ctx = worker->get_mruby_context(); - downstream->inspect_http1_request(); if (downstream->get_request_method() != HTTP_CONNECT) { @@ -310,10 +306,17 @@ int htp_hdrs_completecb(http_parser *htp) { } } - mruby_ctx->run_on_request_proc(downstream); - downstream->set_request_state(Downstream::HEADER_COMPLETE); + auto handler = upstream->get_client_handler(); + auto worker = handler->get_worker(); + auto mruby_ctx = worker->get_mruby_context(); + + if (mruby_ctx->run_on_request_proc(downstream) != 0) { + downstream->set_response_http_status(500); + return -1; + } + if (downstream->get_response_state() == Downstream::MSG_COMPLETE) { return 0; } @@ -483,13 +486,16 @@ int HttpsUpstream::on_read() { if (htperr == HPE_INVALID_METHOD) { status_code = 501; } else if (downstream) { - if (downstream->get_request_state() == Downstream::CONNECT_FAIL) { - status_code = 503; - } else if (downstream->get_request_state() == - Downstream::HTTP1_REQUEST_HEADER_TOO_LARGE) { - status_code = 431; - } else { - status_code = 400; + status_code = downstream->get_response_http_status(); + if (status_code == 0) { + if (downstream->get_request_state() == Downstream::CONNECT_FAIL) { + status_code = 503; + } else if (downstream->get_request_state() == + Downstream::HTTP1_REQUEST_HEADER_TOO_LARGE) { + status_code = 431; + } else { + status_code = 400; + } } } else { status_code = 400; diff --git a/src/shrpx_mruby.cc b/src/shrpx_mruby.cc index 39940dd1..52ba2aeb 100644 --- a/src/shrpx_mruby.cc +++ b/src/shrpx_mruby.cc @@ -78,6 +78,10 @@ int run_request_proc(mrb_state *mrb, Downstream *downstream, RProc *proc) { downstream->index_request_headers(); } + if (data.response_headers_dirty) { + downstream->index_response_headers(); + } + if (downstream->get_response_state() == Downstream::MSG_COMPLETE) { downstream->pop_downstream_connection(); } diff --git a/src/shrpx_mruby.h b/src/shrpx_mruby.h index 6494d8f0..6f75db3b 100644 --- a/src/shrpx_mruby.h +++ b/src/shrpx_mruby.h @@ -55,6 +55,7 @@ private: struct MRubyAssocData { Downstream *downstream; bool request_headers_dirty; + bool response_headers_dirty; }; RProc *compile(mrb_state *mrb, const char *filename); diff --git a/src/shrpx_mruby_module.cc b/src/shrpx_mruby_module.cc index 0b58643e..c5e66056 100644 --- a/src/shrpx_mruby_module.cc +++ b/src/shrpx_mruby_module.cc @@ -33,6 +33,7 @@ #include "shrpx_mruby.h" #include "shrpx_mruby_module_request.h" +#include "shrpx_mruby_module_response.h" namespace shrpx { @@ -45,9 +46,10 @@ mrb_value run(mrb_state *mrb, mrb_value self) { auto module = mrb_module_get(mrb, "Nghttpx"); auto request_class = mrb_class_get_under(mrb, module, "Request"); - auto request = mrb_obj_new(mrb, request_class, 0, nullptr); + auto response_class = mrb_class_get_under(mrb, module, "Response"); - std::array args{{request}}; + std::array args{{mrb_obj_new(mrb, response_class, 0, nullptr), + mrb_obj_new(mrb, request_class, 0, nullptr)}}; return mrb_yield_argv(mrb, b, args.size(), args.data()); } } // namespace @@ -58,6 +60,7 @@ void init_module(mrb_state *mrb) { mrb_define_class_method(mrb, module, "run", run, MRB_ARGS_BLOCK()); init_request_class(mrb, module); + init_response_class(mrb, module); } mrb_value create_headers_hash(mrb_state *mrb, const Headers &headers) { diff --git a/src/shrpx_mruby_module_response.cc b/src/shrpx_mruby_module_response.cc new file mode 100644 index 00000000..5e0a2d80 --- /dev/null +++ b/src/shrpx_mruby_module_response.cc @@ -0,0 +1,221 @@ +/* + * nghttp2 - HTTP/2 C Library + * + * Copyright (c) 2015 Tatsuhiro Tsujikawa + * + * 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. + */ +#include "shrpx_mruby_module_response.h" + +#include +#include +#include +#include + +#include "shrpx_downstream.h" +#include "shrpx_upstream.h" +#include "shrpx_mruby.h" +#include "shrpx_mruby_module.h" +#include "util.h" +#include "http2.h" + +namespace shrpx { + +namespace mruby { + +namespace { +mrb_value response_init(mrb_state *mrb, mrb_value self) { return self; } +} // namespace + +namespace { +mrb_value response_get_http_version_major(mrb_state *mrb, mrb_value self) { + auto data = static_cast(mrb->ud); + auto downstream = data->downstream; + return mrb_fixnum_value(downstream->get_response_major()); +} +} // namespace + +namespace { +mrb_value response_get_http_version_minor(mrb_state *mrb, mrb_value self) { + auto data = static_cast(mrb->ud); + auto downstream = data->downstream; + return mrb_fixnum_value(downstream->get_response_minor()); +} +} // namespace + +namespace { +mrb_value response_get_status(mrb_state *mrb, mrb_value self) { + auto data = static_cast(mrb->ud); + auto downstream = data->downstream; + + return mrb_fixnum_value(downstream->get_response_http_status()); +} +} // namespace + +namespace { +mrb_value response_set_status(mrb_state *mrb, mrb_value self) { + auto data = static_cast(mrb->ud); + auto downstream = data->downstream; + + mrb_int status; + mrb_get_args(mrb, "i", &status); + // We don't support 1xx status code for mruby scripting yet. + if (status < 200 || status > 999) { + mrb_raise(mrb, E_RUNTIME_ERROR, + "invalid status; it should be [200, 999], inclusive"); + } + + downstream->set_response_http_status(status); + + return self; +} +} // namespace + +namespace { +mrb_value response_get_headers(mrb_state *mrb, mrb_value self) { + auto data = static_cast(mrb->ud); + auto downstream = data->downstream; + return create_headers_hash(mrb, downstream->get_response_headers()); +} +} // namespace + +namespace { +mrb_value response_set_header(mrb_state *mrb, mrb_value self) { + auto data = static_cast(mrb->ud); + auto downstream = data->downstream; + + mrb_value key, values; + mrb_get_args(mrb, "oo", &key, &values); + + if (RSTRING_LEN(key) == 0) { + mrb_raise(mrb, E_RUNTIME_ERROR, "empty key is not allowed"); + } + + key = mrb_funcall(mrb, key, "downcase", 0); + + // making name empty will effectively delete header fields + for (auto &hd : downstream->get_response_headers()) { + if (util::streq(std::begin(hd.name), hd.name.size(), RSTRING_PTR(key), + RSTRING_LEN(key))) { + hd.name = ""; + } + } + + if (mrb_obj_is_instance_of(mrb, values, mrb->array_class)) { + auto n = mrb_ary_len(mrb, values); + for (int i = 0; i < n; ++i) { + auto value = mrb_ary_entry(values, i); + downstream->add_response_header( + std::string(RSTRING_PTR(key), RSTRING_LEN(key)), + std::string(RSTRING_PTR(value), RSTRING_LEN(value))); + } + } else if (!mrb_nil_p(values)) { + downstream->add_response_header( + std::string(RSTRING_PTR(key), RSTRING_LEN(key)), + std::string(RSTRING_PTR(values), RSTRING_LEN(values))); + } + + data->response_headers_dirty = true; + + return mrb_nil_value(); +} +} // namespace + +namespace { +mrb_value response_end(mrb_state *mrb, mrb_value self) { + auto data = static_cast(mrb->ud); + auto downstream = data->downstream; + int rv; + + if (downstream->get_response_state() == Downstream::MSG_COMPLETE) { + mrb_raise(mrb, E_RUNTIME_ERROR, "response has already been committed"); + } + + mrb_value val; + mrb_get_args(mrb, "|o", &val); + + const char *body = nullptr; + size_t bodylen = 0; + + if (!mrb_nil_p(val)) { + body = RSTRING_PTR(val); + bodylen = RSTRING_LEN(val); + } + + if (downstream->get_response_http_status() == 0) { + downstream->set_response_http_status(200); + } + + if (data->response_headers_dirty) { + downstream->index_response_headers(); + data->response_headers_dirty = false; + } + + auto cl = downstream->get_response_header(http2::HD_CONTENT_LENGTH); + if (cl) { + cl->value = util::utos(bodylen); + } else { + downstream->add_response_header("content-length", util::utos(bodylen), + http2::HD_CONTENT_LENGTH); + } + downstream->set_response_content_length(bodylen); + + auto upstream = downstream->get_upstream(); + + rv = upstream->on_downstream_header_complete(downstream); + if (rv != 0) { + mrb_raise(mrb, E_RUNTIME_ERROR, "could not send response"); + } + + if (downstream->expect_response_body()) { + auto output = downstream->get_response_buf(); + output->append(body, bodylen); + } + + downstream->set_response_state(Downstream::MSG_COMPLETE); + + return self; +} +} // namespace + +void init_response_class(mrb_state *mrb, RClass *module) { + auto response_class = + mrb_define_class_under(mrb, module, "Response", mrb->object_class); + + mrb_define_method(mrb, response_class, "initialize", response_init, + MRB_ARGS_NONE()); + mrb_define_method(mrb, response_class, "http_version_major", + response_get_http_version_major, MRB_ARGS_NONE()); + mrb_define_method(mrb, response_class, "http_version_minor", + response_get_http_version_minor, MRB_ARGS_NONE()); + mrb_define_method(mrb, response_class, "status", response_get_status, + MRB_ARGS_NONE()); + mrb_define_method(mrb, response_class, "status=", response_set_status, + MRB_ARGS_REQ(1)); + mrb_define_method(mrb, response_class, "headers", response_get_headers, + MRB_ARGS_NONE()); + mrb_define_method(mrb, response_class, "set_header", response_set_header, + MRB_ARGS_REQ(2)); + mrb_define_method(mrb, response_class, "end", response_end, MRB_ARGS_OPT(1)); +} + +} // namespace mruby + +} // namespace shrpx diff --git a/src/shrpx_mruby_module_response.h b/src/shrpx_mruby_module_response.h new file mode 100644 index 00000000..32ed0d41 --- /dev/null +++ b/src/shrpx_mruby_module_response.h @@ -0,0 +1,44 @@ +/* + * nghttp2 - HTTP/2 C Library + * + * Copyright (c) 2015 Tatsuhiro Tsujikawa + * + * 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. + */ +#ifndef SHRPX_MRUBY_MODULE_RESPONSE_H +#define SHRPX_MRUBY_MODULE_RESPONSE_H + +#include "shrpx.h" + +#include + +using namespace nghttp2; + +namespace shrpx { + +namespace mruby { + +void init_response_class(mrb_state *mrb, RClass *module); + +} // namespace mruby + +} // namespace shrpx + +#endif // SHRPX_MRUBY_MODULE_RESPONSE_H diff --git a/src/shrpx_spdy_upstream.cc b/src/shrpx_spdy_upstream.cc index 89fcb678..5056153e 100644 --- a/src/shrpx_spdy_upstream.cc +++ b/src/shrpx_spdy_upstream.cc @@ -36,6 +36,9 @@ #include "shrpx_downstream_connection.h" #include "shrpx_config.h" #include "shrpx_http.h" +#include "shrpx_mruby.h" +#include "shrpx_worker.h" +#include "shrpx_http2_session.h" #include "http2.h" #include "util.h" #include "template.h" @@ -237,6 +240,19 @@ void on_ctrl_recv_callback(spdylay_session *session, spdylay_frame_type type, downstream->inspect_http2_request(); downstream->set_request_state(Downstream::HEADER_COMPLETE); + + auto handler = upstream->get_client_handler(); + auto worker = handler->get_worker(); + auto mruby_ctx = worker->get_mruby_context(); + + if (mruby_ctx->run_on_request_proc(downstream) != 0) { + if (upstream->error_reply(downstream, 500) != 0) { + ULOG(FATAL, upstream) << "error_reply failed"; + return; + } + return; + } + if (frame->syn_stream.hd.flags & SPDYLAY_CTRL_FLAG_FIN) { if (!downstream->validate_request_bodylen()) { upstream->rst_stream(downstream, SPDYLAY_PROTOCOL_ERROR); @@ -247,6 +263,10 @@ void on_ctrl_recv_callback(spdylay_session *session, spdylay_frame_type type, downstream->set_request_state(Downstream::MSG_COMPLETE); } + if (downstream->get_response_state() == Downstream::MSG_COMPLETE) { + return; + } + upstream->start_downstream(downstream); break;