nghttp2/src/shrpx_http2_session.cc

1781 lines
49 KiB
C++
Raw Normal View History

/*
2014-03-30 12:09:21 +02:00
* nghttp2 - HTTP/2 C Library
*
* Copyright (c) 2012 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_http2_session.h"
#include <netinet/tcp.h>
#include <unistd.h>
#include <vector>
#include <openssl/err.h>
#include "shrpx_upstream.h"
#include "shrpx_downstream.h"
#include "shrpx_config.h"
#include "shrpx_error.h"
#include "shrpx_http2_downstream_connection.h"
#include "shrpx_client_handler.h"
#include "shrpx_ssl.h"
#include "shrpx_http.h"
#include "shrpx_worker_config.h"
#include "http2.h"
#include "util.h"
#include "base64.h"
2013-07-12 17:19:03 +02:00
using namespace nghttp2;
namespace shrpx {
namespace {
void connchk_timeout_cb(struct ev_loop *loop, ev_timer *w, int revents) {
auto http2session = static_cast<Http2Session *>(w->data);
SSLOG(INFO, http2session) << "connection check required";
ev_timer_stop(loop, w);
http2session->set_connection_check_state(
Http2Session::CONNECTION_CHECK_REQUIRED);
}
} // namespace
namespace {
void settings_timeout_cb(struct ev_loop *loop, ev_timer *w, int revents) {
auto http2session = static_cast<Http2Session *>(w->data);
http2session->stop_settings_timer();
SSLOG(INFO, http2session) << "SETTINGS timeout";
if (http2session->terminate_session(NGHTTP2_SETTINGS_TIMEOUT) != 0) {
http2session->disconnect();
return;
}
http2session->signal_write();
}
} // namespace
namespace {
void timeoutcb(struct ev_loop *loop, ev_timer *w, int revents) {
auto http2session = static_cast<Http2Session *>(w->data);
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, http2session) << "Timeout";
}
http2session->disconnect(http2session->get_state() ==
Http2Session::CONNECTING);
}
} // namespace
namespace {
void readcb(struct ev_loop *loop, ev_io *w, int revents) {
int rv;
auto http2session = static_cast<Http2Session *>(w->data);
http2session->connection_alive();
rv = http2session->do_read();
if (rv != 0) {
http2session->disconnect(http2session->should_hard_fail());
}
}
} // namespace
namespace {
void writecb(struct ev_loop *loop, ev_io *w, int revents) {
int rv;
auto http2session = static_cast<Http2Session *>(w->data);
http2session->clear_write_request();
http2session->connection_alive();
rv = http2session->do_write();
if (rv != 0) {
http2session->disconnect(http2session->should_hard_fail());
}
}
} // namespace
namespace {
void wrschedcb(struct ev_loop *loop, ev_prepare *w, int revents) {
auto http2session = static_cast<Http2Session *>(w->data);
if (!http2session->write_requested()) {
return;
}
http2session->clear_write_request();
switch (http2session->get_state()) {
case Http2Session::DISCONNECTED:
LOG(INFO) << "wrschedcb start connect";
if (http2session->initiate_connection() != 0) {
SSLOG(FATAL, http2session) << "Could not initiate backend connection";
http2session->disconnect(true);
}
break;
case Http2Session::CONNECTED:
writecb(loop, http2session->get_wev(), revents);
break;
}
}
} // namespace
Http2Session::Http2Session(struct ev_loop *loop, SSL_CTX *ssl_ctx)
: loop_(loop), ssl_ctx_(ssl_ctx), ssl_(nullptr), session_(nullptr),
data_pending_(nullptr), data_pendinglen_(0), fd_(-1),
state_(DISCONNECTED), connection_check_state_(CONNECTION_CHECK_NONE),
flow_control_(false), write_requested_(false) {
// We do not know fd yet, so just set dummy fd 0
ev_io_init(&wev_, writecb, 0, EV_WRITE);
ev_io_init(&rev_, readcb, 0, EV_READ);
wev_.data = this;
rev_.data = this;
read_ = write_ = &Http2Session::noop;
on_read_ = on_write_ = &Http2Session::noop;
ev_timer_init(&wt_, timeoutcb, 0., get_config()->downstream_write_timeout);
ev_timer_init(&rt_, timeoutcb, 0., get_config()->downstream_read_timeout);
wt_.data = this;
rt_.data = this;
// We will resuse this many times, so use repeat timeout value.
ev_timer_init(&connchk_timer_, connchk_timeout_cb, 0., 5.);
connchk_timer_.data = this;
// SETTINGS ACK timeout is 10 seconds for now. We will resuse this
// many times, so use repeat timeout value.
ev_timer_init(&settings_timer_, settings_timeout_cb, 0., 10.);
settings_timer_.data = this;
ev_prepare_init(&wrsched_prep_, &wrschedcb);
wrsched_prep_.data = this;
ev_prepare_start(loop_, &wrsched_prep_);
}
2014-11-27 15:39:04 +01:00
Http2Session::~Http2Session() { disconnect(); }
int Http2Session::disconnect(bool hard) {
2014-11-27 15:39:04 +01:00
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "Disconnecting";
}
2013-07-12 17:19:03 +02:00
nghttp2_session_del(session_);
2013-09-24 14:34:04 +02:00
session_ = nullptr;
rb_.reset();
wb_.reset();
ev_timer_stop(loop_, &settings_timer_);
ev_timer_stop(loop_, &connchk_timer_);
ev_timer_stop(loop_, &rt_);
ev_timer_stop(loop_, &wt_);
read_ = write_ = &Http2Session::noop;
on_read_ = on_write_ = &Http2Session::noop;
ev_io_stop(loop_, &rev_);
ev_io_stop(loop_, &wev_);
2014-11-27 15:39:04 +01:00
if (ssl_) {
SSL_set_shutdown(ssl_, SSL_RECEIVED_SHUTDOWN);
SSL_shutdown(ssl_);
SSL_free(ssl_);
ssl_ = nullptr;
}
2014-11-27 15:39:04 +01:00
if (fd_ != -1) {
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "Closing fd=" << fd_;
}
shutdown(fd_, SHUT_WR);
close(fd_);
fd_ = -1;
}
2014-11-27 15:39:04 +01:00
if (proxy_htp_) {
proxy_htp_.reset();
}
connection_check_state_ = CONNECTION_CHECK_NONE;
state_ = DISCONNECTED;
// Delete all client handler associated to Downstream. When deleting
// Http2DownstreamConnection, it calls this object's
// remove_downstream_connection(). The multiple
// Http2DownstreamConnection objects belong to the same
// ClientHandler object. So first dump ClientHandler objects. We
// want to allow creating new pending Http2DownstreamConnection with
// this object. In order to achieve this, we first swap dconns_ and
// streams_. Upstream::on_downstream_reset() may add
// Http2DownstreamConnection.
std::set<Http2DownstreamConnection *> dconns;
dconns.swap(dconns_);
std::set<StreamData *> streams;
streams.swap(streams_);
2014-11-27 15:39:04 +01:00
std::set<ClientHandler *> handlers;
for (auto dc : dconns) {
if (!dc->get_client_handler()) {
continue;
}
2014-02-22 03:26:32 +01:00
handlers.insert(dc->get_client_handler());
}
for (auto h : handlers) {
if (hard) {
delete h;
continue;
}
if (h->get_upstream()->on_downstream_reset() != 0) {
delete h;
}
}
for (auto &s : streams) {
2013-09-24 14:34:04 +02:00
delete s;
}
return 0;
}
2014-11-27 15:39:04 +01:00
int Http2Session::check_cert() { return ssl::check_cert(ssl_); }
2014-11-27 15:39:04 +01:00
int Http2Session::initiate_connection() {
int rv = 0;
2014-11-27 15:39:04 +01:00
if (get_config()->downstream_http_proxy_host && state_ == DISCONNECTED) {
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "Connecting to the proxy "
2014-11-27 15:39:04 +01:00
<< get_config()->downstream_http_proxy_host.get() << ":"
<< get_config()->downstream_http_proxy_port;
}
2014-08-19 14:22:53 +02:00
fd_ = util::create_nonblock_socket(
get_config()->downstream_http_proxy_addr.storage.ss_family);
2014-08-19 14:22:53 +02:00
if (fd_ == -1) {
return -1;
}
rv = connect(fd_, const_cast<sockaddr *>(
&get_config()->downstream_http_proxy_addr.sa),
get_config()->downstream_http_proxy_addrlen);
if (rv != 0 && errno != EINPROGRESS) {
SSLOG(ERROR, this) << "Failed to connect to the proxy "
<< get_config()->downstream_http_proxy_host.get()
2014-11-27 15:39:04 +01:00
<< ":" << get_config()->downstream_http_proxy_port;
return -1;
}
ev_io_set(&rev_, fd_, EV_READ);
ev_io_set(&wev_, fd_, EV_WRITE);
ev_io_start(loop_, &wev_);
// TODO we should have timeout for connection establishment
ev_timer_again(loop_, &wt_);
write_ = &Http2Session::connected;
on_read_ = &Http2Session::downstream_read_proxy;
on_write_ = &Http2Session::downstream_connect_proxy;
proxy_htp_ = util::make_unique<http_parser>();
http_parser_init(proxy_htp_.get(), HTTP_RESPONSE);
proxy_htp_->data = this;
state_ = PROXY_CONNECTING;
return 0;
}
2014-11-27 15:39:04 +01:00
if (state_ == DISCONNECTED || state_ == PROXY_CONNECTED) {
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "Connecting to downstream server";
}
2014-11-27 15:39:04 +01:00
if (ssl_ctx_) {
// We are establishing TLS connection.
ssl_ = SSL_new(ssl_ctx_);
2014-11-27 15:39:04 +01:00
if (!ssl_) {
SSLOG(ERROR, this) << "SSL_new() failed: "
<< ERR_error_string(ERR_get_error(), NULL);
return -1;
}
2013-09-24 14:34:04 +02:00
const char *sni_name = nullptr;
2014-11-27 15:39:04 +01:00
if (get_config()->backend_tls_sni_name) {
sni_name = get_config()->backend_tls_sni_name.get();
2014-11-27 15:39:04 +01:00
} else {
sni_name = get_config()->downstream_addrs[0].host.get();
}
2014-11-27 15:39:04 +01:00
if (sni_name && !util::numeric_host(sni_name)) {
// TLS extensions: SNI. There is no documentation about the return
// code for this function (actually this is macro wrapping SSL_ctrl
// at the time of this writing).
SSL_set_tlsext_host_name(ssl_, sni_name);
}
// If state_ == PROXY_CONNECTED, we has connected to the proxy
// using fd_ and tunnel has been established.
2014-11-27 15:39:04 +01:00
if (state_ == DISCONNECTED) {
assert(fd_ == -1);
fd_ = util::create_nonblock_socket(
get_config()->downstream_addrs[0].addr.storage.ss_family);
if (fd_ == -1) {
return -1;
}
rv = connect(
fd_,
// TODO maybe not thread-safe?
const_cast<sockaddr *>(&get_config()->downstream_addrs[0].addr.sa),
get_config()->downstream_addrs[0].addrlen);
if (rv != 0 && errno != EINPROGRESS) {
return -1;
}
}
if (SSL_set_fd(ssl_, fd_) == 0) {
return -1;
}
SSL_set_connect_state(ssl_);
} else {
2014-11-27 15:39:04 +01:00
if (state_ == DISCONNECTED) {
// Without TLS and proxy.
assert(fd_ == -1);
fd_ = util::create_nonblock_socket(
get_config()->downstream_addrs[0].addr.storage.ss_family);
2014-08-19 14:22:53 +02:00
2014-11-27 15:39:04 +01:00
if (fd_ == -1) {
return -1;
2014-08-19 14:22:53 +02:00
}
rv = connect(fd_, const_cast<sockaddr *>(
&get_config()->downstream_addrs[0].addr.sa),
get_config()->downstream_addrs[0].addrlen);
if (rv != 0 && errno != EINPROGRESS) {
return -1;
}
} else {
// Without TLS but with proxy. Connection already
// established.
if (on_connect() != -1) {
state_ = CONNECT_FAILING;
return -1;
}
}
}
ev_io_set(&rev_, fd_, EV_READ);
ev_io_set(&wev_, fd_, EV_WRITE);
ev_io_start(loop_, &wev_);
write_ = &Http2Session::connected;
on_write_ = &Http2Session::downstream_write;
on_read_ = &Http2Session::downstream_read;
// We have been already connected when no TLS and proxy is used.
2014-11-27 15:39:04 +01:00
if (state_ != CONNECTED) {
state_ = CONNECTING;
ev_io_start(loop_, &wev_);
// TODO we should have timeout for connection establishment
ev_timer_again(loop_, &wt_);
} else {
ev_timer_again(loop_, &rt_);
}
return 0;
}
// Unreachable
DIE();
return 0;
}
namespace {
2014-11-27 15:39:04 +01:00
int htp_hdrs_completecb(http_parser *htp) {
auto http2session = static_cast<Http2Session *>(htp->data);
// We just check status code here
2014-11-27 15:39:04 +01:00
if (htp->status_code == 200) {
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, http2session) << "Tunneling success";
}
http2session->set_state(Http2Session::PROXY_CONNECTED);
return 0;
}
SSLOG(WARN, http2session) << "Tunneling failed: " << htp->status_code;
http2session->set_state(Http2Session::PROXY_FAILED);
return 0;
}
} // namespace
namespace {
http_parser_settings htp_hooks = {
2014-11-27 15:39:04 +01:00
nullptr, // http_cb on_message_begin;
nullptr, // http_data_cb on_url;
nullptr, // http_data_cb on_status;
nullptr, // http_data_cb on_header_field;
nullptr, // http_data_cb on_header_value;
htp_hdrs_completecb, // http_cb on_headers_complete;
nullptr, // http_data_cb on_body;
nullptr // http_cb on_message_complete;
};
} // namespace
int Http2Session::downstream_read_proxy() {
2014-11-27 15:39:04 +01:00
for (;;) {
const void *data;
size_t datalen;
std::tie(data, datalen) = rb_.get();
if (datalen == 0) {
break;
}
2014-11-27 15:39:04 +01:00
size_t nread =
http_parser_execute(proxy_htp_.get(), &htp_hooks,
reinterpret_cast<const char *>(data), datalen);
rb_.drain(nread);
auto htperr = HTTP_PARSER_ERRNO(proxy_htp_.get());
2014-11-27 15:39:04 +01:00
if (htperr != HPE_OK) {
return -1;
}
switch (state_) {
case Http2Session::PROXY_CONNECTED:
// Initiate SSL/TLS handshake through established tunnel.
if (initiate_connection() != 0) {
return -1;
}
break;
case Http2Session::PROXY_FAILED:
return -1;
}
}
return 0;
}
int Http2Session::downstream_connect_proxy() {
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "Connected to the proxy";
}
std::string req = "CONNECT ";
req += get_config()->downstream_addrs[0].hostport.get();
req += " HTTP/1.1\r\nHost: ";
req += get_config()->downstream_addrs[0].host.get();
req += "\r\n";
if (get_config()->downstream_http_proxy_userinfo) {
req += "Proxy-Authorization: Basic ";
size_t len = strlen(get_config()->downstream_http_proxy_userinfo.get());
req += base64::encode(get_config()->downstream_http_proxy_userinfo.get(),
get_config()->downstream_http_proxy_userinfo.get() +
len);
req += "\r\n";
}
req += "\r\n";
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "HTTP proxy request headers\n" << req;
}
auto nwrite = wb_.write(req.c_str(), req.size());
if (nwrite != req.size()) {
SSLOG(WARN, this) << "HTTP proxy request is too large";
return -1;
}
on_write_ = &Http2Session::noop;
signal_write();
return 0;
}
2014-11-27 15:39:04 +01:00
void Http2Session::add_downstream_connection(Http2DownstreamConnection *dconn) {
dconns_.insert(dconn);
}
2014-11-27 15:39:04 +01:00
void
Http2Session::remove_downstream_connection(Http2DownstreamConnection *dconn) {
dconns_.erase(dconn);
dconn->detach_stream_data();
}
2014-11-27 15:39:04 +01:00
void Http2Session::remove_stream_data(StreamData *sd) {
streams_.erase(sd);
2014-11-27 15:39:04 +01:00
if (sd->dconn) {
sd->dconn->detach_stream_data();
}
delete sd;
}
2014-11-27 15:39:04 +01:00
int Http2Session::submit_request(Http2DownstreamConnection *dconn, int32_t pri,
const nghttp2_nv *nva, size_t nvlen,
2014-11-27 15:39:04 +01:00
const nghttp2_data_provider *data_prd) {
assert(state_ == CONNECTED);
2013-09-24 14:34:04 +02:00
auto sd = util::make_unique<StreamData>();
2014-03-25 18:04:24 +01:00
// TODO Specify nullptr to pri_spec for now
2014-11-27 15:39:04 +01:00
auto stream_id =
nghttp2_submit_request(session_, nullptr, nva, nvlen, data_prd, sd.get());
if (stream_id < 0) {
2013-07-12 17:19:03 +02:00
SSLOG(FATAL, this) << "nghttp2_submit_request() failed: "
<< nghttp2_strerror(stream_id);
return -1;
}
dconn->attach_stream_data(sd.get());
dconn->get_downstream()->set_downstream_stream_id(stream_id);
streams_.insert(sd.release());
return 0;
}
2014-11-27 15:39:04 +01:00
int Http2Session::submit_rst_stream(int32_t stream_id, uint32_t error_code) {
assert(state_ == CONNECTED);
2014-11-27 15:39:04 +01:00
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "RST_STREAM stream_id=" << stream_id
<< " with error_code=" << error_code;
}
int rv = nghttp2_submit_rst_stream(session_, NGHTTP2_FLAG_NONE, stream_id,
error_code);
if (rv != 0) {
2013-07-12 17:19:03 +02:00
SSLOG(FATAL, this) << "nghttp2_submit_rst_stream() failed: "
<< nghttp2_strerror(rv);
return -1;
}
return 0;
}
int Http2Session::submit_priority(Http2DownstreamConnection *dconn,
2014-11-27 15:39:04 +01:00
int32_t pri) {
assert(state_ == CONNECTED);
2014-11-27 15:39:04 +01:00
if (!dconn) {
return 0;
}
int rv;
2014-03-25 18:04:24 +01:00
// TODO Disabled temporarily
// rv = nghttp2_submit_priority(session_, NGHTTP2_FLAG_NONE,
// dconn->get_downstream()->
// get_downstream_stream_id(), pri);
rv = 0;
2014-11-27 15:39:04 +01:00
if (rv < NGHTTP2_ERR_FATAL) {
SSLOG(FATAL, this) << "nghttp2_submit_priority() failed: "
<< nghttp2_strerror(rv);
return -1;
}
return 0;
}
2014-11-27 15:39:04 +01:00
nghttp2_session *Http2Session::get_session() const { return session_; }
2014-11-27 15:39:04 +01:00
bool Http2Session::get_flow_control() const { return flow_control_; }
2014-11-27 15:39:04 +01:00
int Http2Session::resume_data(Http2DownstreamConnection *dconn) {
assert(state_ == CONNECTED);
2013-09-24 14:34:04 +02:00
auto downstream = dconn->get_downstream();
2013-07-12 17:19:03 +02:00
int rv = nghttp2_session_resume_data(session_,
downstream->get_downstream_stream_id());
2014-11-27 15:39:04 +01:00
switch (rv) {
case 0:
2013-07-12 17:19:03 +02:00
case NGHTTP2_ERR_INVALID_ARGUMENT:
return 0;
default:
2013-07-12 17:19:03 +02:00
SSLOG(FATAL, this) << "nghttp2_resume_session() failed: "
<< nghttp2_strerror(rv);
return -1;
}
}
namespace {
2014-11-27 15:39:04 +01:00
void call_downstream_readcb(Http2Session *http2session,
Downstream *downstream) {
2013-09-24 14:34:04 +02:00
auto upstream = downstream->get_upstream();
if (!upstream) {
return;
}
if (upstream->downstream_read(downstream->get_downstream_connection()) != 0) {
delete upstream->get_client_handler();
}
}
} // namespace
namespace {
2014-11-27 15:39:04 +01:00
int on_stream_close_callback(nghttp2_session *session, int32_t stream_id,
uint32_t error_code, void *user_data) {
auto http2session = static_cast<Http2Session *>(user_data);
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, http2session) << "Stream stream_id=" << stream_id
<< " is being closed";
}
2014-11-27 15:39:04 +01:00
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, stream_id));
if (sd == 0) {
// We might get this close callback when pushed streams are
// closed.
return 0;
}
2013-07-26 12:33:25 +02:00
auto dconn = sd->dconn;
2014-11-27 15:39:04 +01:00
if (dconn) {
2013-07-26 12:33:25 +02:00
auto downstream = dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (downstream && downstream->get_downstream_stream_id() == stream_id) {
2014-11-27 15:39:04 +01:00
if (downstream->get_upgraded() &&
downstream->get_response_state() == Downstream::HEADER_COMPLETE) {
// For tunneled connection, we have to submit RST_STREAM to
// upstream *after* whole response body is sent. We just set
// MSG_COMPLETE here. Upstream will take care of that.
downstream->get_upstream()->on_downstream_body_complete(downstream);
downstream->set_response_state(Downstream::MSG_COMPLETE);
2014-11-27 15:39:04 +01:00
} else if (error_code == NGHTTP2_NO_ERROR) {
if (downstream->get_response_state() != Downstream::MSG_COMPLETE) {
downstream->set_response_state(Downstream::MSG_RESET);
}
} else {
downstream->set_response_state(Downstream::MSG_RESET);
}
call_downstream_readcb(http2session, downstream);
// dconn may be deleted
}
}
// The life time of StreamData ends here
http2session->remove_stream_data(sd);
return 0;
}
} // namespace
void Http2Session::start_settings_timer() {
ev_timer_again(loop_, &settings_timer_);
}
2014-11-27 15:39:04 +01:00
void Http2Session::stop_settings_timer() {
ev_timer_stop(loop_, &settings_timer_);
}
namespace {
2014-11-27 15:39:04 +01:00
int on_header_callback(nghttp2_session *session, const nghttp2_frame *frame,
const uint8_t *name, size_t namelen,
2014-11-27 15:39:04 +01:00
const uint8_t *value, size_t valuelen, uint8_t flags,
void *user_data) {
auto http2session = static_cast<Http2Session *>(user_data);
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, frame->hd.stream_id));
if (!sd || !sd->dconn) {
return 0;
}
auto downstream = sd->dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (!downstream) {
return 0;
}
2014-11-27 15:39:04 +01:00
if (frame->hd.type != NGHTTP2_HEADERS ||
(frame->headers.cat != NGHTTP2_HCAT_RESPONSE &&
!downstream->get_expect_final_response())) {
return 0;
}
2014-11-27 15:39:04 +01:00
if (downstream->get_response_headers_sum() > Downstream::MAX_HEADERS_SUM) {
if (LOG_ENABLED(INFO)) {
DLOG(INFO, downstream) << "Too large header block size="
<< downstream->get_response_headers_sum();
}
return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
2014-11-27 15:39:04 +01:00
if (!http2::check_nv(name, namelen, value, valuelen)) {
return 0;
}
auto token = http2::lookup_token(name, namelen);
if (name[0] == ':') {
if (!downstream->response_pseudo_header_allowed(token)) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_PROTOCOL_ERROR);
return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
}
if (!http2::http2_header_allowed(token)) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_PROTOCOL_ERROR);
return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
}
downstream->add_response_header(name, namelen, value, valuelen,
flags & NGHTTP2_NV_FLAG_NO_INDEX, token);
return 0;
}
} // namespace
namespace {
int on_begin_headers_callback(nghttp2_session *session,
2014-11-27 15:39:04 +01:00
const nghttp2_frame *frame, void *user_data) {
auto http2session = static_cast<Http2Session *>(user_data);
if (frame->headers.cat == NGHTTP2_HCAT_REQUEST) {
// server sends request HEADERS
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_REFUSED_STREAM);
return 0;
}
2014-11-27 15:39:04 +01:00
if (frame->headers.cat != NGHTTP2_HCAT_RESPONSE) {
return 0;
}
2014-11-27 15:39:04 +01:00
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, frame->hd.stream_id));
if (!sd || !sd->dconn) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_INTERNAL_ERROR);
return 0;
}
auto downstream = sd->dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (!downstream ||
downstream->get_downstream_stream_id() != frame->hd.stream_id) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_INTERNAL_ERROR);
return 0;
}
return 0;
}
} // namespace
namespace {
2014-11-27 15:39:04 +01:00
int on_response_headers(Http2Session *http2session, Downstream *downstream,
nghttp2_session *session, const nghttp2_frame *frame) {
int rv;
auto upstream = downstream->get_upstream();
2014-11-27 15:39:04 +01:00
auto &nva = downstream->get_response_headers();
downstream->set_expect_final_response(false);
auto status = downstream->get_response_header(http2::HD__STATUS);
int status_code;
if (!http2::non_empty_value(status) ||
2014-11-27 15:39:04 +01:00
(status_code = http2::parse_http_status_code(status->value)) == -1) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_PROTOCOL_ERROR);
downstream->set_response_state(Downstream::MSG_RESET);
call_downstream_readcb(http2session, downstream);
return 0;
}
downstream->set_response_http_status(status_code);
downstream->set_response_major(2);
downstream->set_response_minor(0);
2014-11-27 15:39:04 +01:00
if (LOG_ENABLED(INFO)) {
std::stringstream ss;
2014-11-27 15:39:04 +01:00
for (auto &nv : nva) {
ss << TTY_HTTP_HD << nv.name << TTY_RST << ": " << nv.value << "\n";
}
2014-11-27 15:39:04 +01:00
SSLOG(INFO, http2session)
<< "HTTP response headers. stream_id=" << frame->hd.stream_id << "\n"
<< ss.str();
}
2014-11-27 15:39:04 +01:00
if (downstream->get_non_final_response()) {
2014-11-27 15:39:04 +01:00
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, http2session) << "This is non-final response.";
}
downstream->set_expect_final_response(true);
rv = upstream->on_downstream_header_complete(downstream);
// Now Dowstream's response headers are erased.
2014-11-27 15:39:04 +01:00
if (rv != 0) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_PROTOCOL_ERROR);
downstream->set_response_state(Downstream::MSG_RESET);
}
return 0;
}
auto content_length =
downstream->get_response_header(http2::HD_CONTENT_LENGTH);
2014-11-27 15:39:04 +01:00
if (!content_length && downstream->get_request_method() != "HEAD" &&
downstream->get_request_method() != "CONNECT") {
unsigned int status;
status = downstream->get_response_http_status();
2014-11-27 15:39:04 +01:00
if (!((100 <= status && status <= 199) || status == 204 || status == 304)) {
// Here we have response body but Content-Length is not known
// in advance.
2014-11-27 15:39:04 +01:00
if (downstream->get_request_major() <= 0 ||
downstream->get_request_minor() <= 0) {
// We simply close connection for pre-HTTP/1.1 in this case.
downstream->set_response_connection_close(true);
} else {
// Otherwise, use chunked encoding to keep upstream
// connection open. In HTTP2, we are supporsed not to
// receive transfer-encoding.
downstream->add_response_header("transfer-encoding", "chunked");
downstream->set_chunked_response(true);
}
}
}
downstream->set_response_state(Downstream::HEADER_COMPLETE);
downstream->check_upgrade_fulfilled();
2014-11-27 15:39:04 +01:00
if (downstream->get_upgraded()) {
downstream->set_response_connection_close(true);
// On upgrade sucess, both ends can send data
2014-11-27 15:39:04 +01:00
if (upstream->resume_read(SHRPX_MSG_BLOCK, downstream, 0) != 0) {
// If resume_read fails, just drop connection. Not ideal.
delete upstream->get_client_handler();
return -1;
}
downstream->set_request_state(Downstream::HEADER_COMPLETE);
2014-11-27 15:39:04 +01:00
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, http2session)
<< "HTTP upgrade success. stream_id=" << frame->hd.stream_id;
}
2014-11-27 15:39:04 +01:00
} else if (downstream->get_request_method() == "CONNECT") {
// If request is CONNECT, terminate request body to avoid for
// stream to stall.
downstream->end_upload_data();
}
rv = upstream->on_downstream_header_complete(downstream);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_PROTOCOL_ERROR);
downstream->set_response_state(Downstream::MSG_RESET);
}
return 0;
}
} // namespace
namespace {
2014-11-27 15:39:04 +01:00
int on_frame_recv_callback(nghttp2_session *session, const nghttp2_frame *frame,
void *user_data) {
int rv;
2014-11-27 15:39:04 +01:00
auto http2session = static_cast<Http2Session *>(user_data);
2014-11-27 15:39:04 +01:00
switch (frame->hd.type) {
case NGHTTP2_DATA: {
2014-11-27 15:39:04 +01:00
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, frame->hd.stream_id));
if (!sd || !sd->dconn) {
break;
}
auto downstream = sd->dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (!downstream ||
downstream->get_downstream_stream_id() != frame->hd.stream_id) {
break;
}
auto upstream = downstream->get_upstream();
rv = upstream->on_downstream_body(downstream, nullptr, 0, true);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_INTERNAL_ERROR);
downstream->set_response_state(Downstream::MSG_RESET);
2014-11-27 15:39:04 +01:00
} else if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
downstream->disable_downstream_rtimer();
2014-11-27 15:39:04 +01:00
if (downstream->get_response_state() == Downstream::HEADER_COMPLETE) {
downstream->set_response_state(Downstream::MSG_COMPLETE);
rv = upstream->on_downstream_body_complete(downstream);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
downstream->set_response_state(Downstream::MSG_RESET);
}
}
}
call_downstream_readcb(http2session, downstream);
break;
}
case NGHTTP2_HEADERS: {
2014-11-27 15:39:04 +01:00
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, frame->hd.stream_id));
if (!sd || !sd->dconn) {
break;
}
auto downstream = sd->dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (!downstream) {
return 0;
}
2014-11-27 15:39:04 +01:00
if (frame->headers.cat == NGHTTP2_HCAT_RESPONSE) {
rv = on_response_headers(http2session, downstream, session, frame);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
return 0;
}
2015-01-05 16:51:52 +01:00
} else if (frame->headers.cat == NGHTTP2_HCAT_HEADERS) {
2014-11-27 15:39:04 +01:00
if (downstream->get_expect_final_response()) {
rv = on_response_headers(http2session, downstream, session, frame);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
return 0;
}
2014-11-27 15:39:04 +01:00
} else if ((frame->hd.flags & NGHTTP2_FLAG_END_STREAM) == 0) {
http2session->submit_rst_stream(frame->hd.stream_id,
NGHTTP2_PROTOCOL_ERROR);
return 0;
}
}
2014-11-27 15:39:04 +01:00
if (frame->hd.flags & NGHTTP2_FLAG_END_STREAM) {
downstream->disable_downstream_rtimer();
2014-11-27 15:39:04 +01:00
if (downstream->get_response_state() == Downstream::HEADER_COMPLETE) {
downstream->set_response_state(Downstream::MSG_COMPLETE);
auto upstream = downstream->get_upstream();
rv = upstream->on_downstream_body_complete(downstream);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
downstream->set_response_state(Downstream::MSG_RESET);
}
}
} else {
downstream->reset_downstream_rtimer();
}
// This may delete downstream
call_downstream_readcb(http2session, downstream);
break;
}
2013-07-26 12:33:25 +02:00
case NGHTTP2_RST_STREAM: {
2014-11-27 15:39:04 +01:00
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, frame->hd.stream_id));
if (sd && sd->dconn) {
2013-07-26 12:33:25 +02:00
auto downstream = sd->dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (downstream &&
downstream->get_downstream_stream_id() == frame->hd.stream_id) {
2014-11-27 15:39:04 +01:00
downstream->set_response_rst_stream_error_code(
frame->rst_stream.error_code);
call_downstream_readcb(http2session, downstream);
2013-07-26 12:33:25 +02:00
}
}
break;
}
case NGHTTP2_SETTINGS:
2014-11-27 15:39:04 +01:00
if ((frame->hd.flags & NGHTTP2_FLAG_ACK) == 0) {
break;
}
http2session->stop_settings_timer();
break;
2013-07-26 12:33:25 +02:00
case NGHTTP2_PUSH_PROMISE:
2014-11-27 15:39:04 +01:00
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, http2session)
2014-11-27 15:39:04 +01:00
<< "Received downstream PUSH_PROMISE stream_id="
<< frame->hd.stream_id
<< ", promised_stream_id=" << frame->push_promise.promised_stream_id;
2013-07-26 12:33:25 +02:00
}
// We just respond with RST_STREAM.
http2session->submit_rst_stream(frame->push_promise.promised_stream_id,
NGHTTP2_REFUSED_STREAM);
2013-07-26 12:33:25 +02:00
break;
default:
break;
}
return 0;
}
} // namespace
namespace {
2014-11-27 15:39:04 +01:00
int on_data_chunk_recv_callback(nghttp2_session *session, uint8_t flags,
int32_t stream_id, const uint8_t *data,
size_t len, void *user_data) {
int rv;
2014-11-27 15:39:04 +01:00
auto http2session = static_cast<Http2Session *>(user_data);
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, stream_id));
if (!sd || !sd->dconn) {
http2session->submit_rst_stream(stream_id, NGHTTP2_INTERNAL_ERROR);
2014-11-27 15:39:04 +01:00
if (http2session->consume(stream_id, len) != 0) {
return NGHTTP2_ERR_CALLBACK_FAILURE;
}
return 0;
}
2013-07-26 12:33:25 +02:00
auto downstream = sd->dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (!downstream || downstream->get_downstream_stream_id() != stream_id ||
!downstream->expect_response_body()) {
http2session->submit_rst_stream(stream_id, NGHTTP2_INTERNAL_ERROR);
2014-11-27 15:39:04 +01:00
if (http2session->consume(stream_id, len) != 0) {
return NGHTTP2_ERR_CALLBACK_FAILURE;
}
return 0;
}
// We don't want DATA after non-final response, which is illegal in
// HTTP.
2014-11-27 15:39:04 +01:00
if (downstream->get_non_final_response()) {
http2session->submit_rst_stream(stream_id, NGHTTP2_PROTOCOL_ERROR);
2014-11-27 15:39:04 +01:00
if (http2session->consume(stream_id, len) != 0) {
return NGHTTP2_ERR_CALLBACK_FAILURE;
}
return 0;
}
downstream->reset_downstream_rtimer();
downstream->add_response_bodylen(len);
2013-07-26 12:33:25 +02:00
auto upstream = downstream->get_upstream();
rv = upstream->on_downstream_body(downstream, data, len, false);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
http2session->submit_rst_stream(stream_id, NGHTTP2_INTERNAL_ERROR);
2014-11-27 15:39:04 +01:00
if (http2session->consume(stream_id, len) != 0) {
return NGHTTP2_ERR_CALLBACK_FAILURE;
}
downstream->set_response_state(Downstream::MSG_RESET);
}
downstream->add_response_datalen(len);
call_downstream_readcb(http2session, downstream);
return 0;
}
} // namespace
namespace {
2014-11-27 15:39:04 +01:00
int on_frame_send_callback(nghttp2_session *session, const nghttp2_frame *frame,
void *user_data) {
auto http2session = static_cast<Http2Session *>(user_data);
2014-11-27 15:39:04 +01:00
if (frame->hd.type == NGHTTP2_DATA || frame->hd.type == NGHTTP2_HEADERS) {
if ((frame->hd.flags & NGHTTP2_FLAG_END_STREAM) == 0) {
return 0;
}
2014-11-27 15:39:04 +01:00
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, frame->hd.stream_id));
2014-11-27 15:39:04 +01:00
if (!sd || !sd->dconn) {
return 0;
}
auto downstream = sd->dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (!downstream ||
downstream->get_downstream_stream_id() != frame->hd.stream_id) {
return 0;
}
downstream->reset_downstream_rtimer();
return 0;
}
2014-11-27 15:39:04 +01:00
if (frame->hd.type == NGHTTP2_SETTINGS &&
(frame->hd.flags & NGHTTP2_FLAG_ACK) == 0) {
http2session->start_settings_timer();
}
return 0;
}
} // namespace
namespace {
int on_frame_not_send_callback(nghttp2_session *session,
2014-11-27 15:39:04 +01:00
const nghttp2_frame *frame, int lib_error_code,
void *user_data) {
auto http2session = static_cast<Http2Session *>(user_data);
SSLOG(WARN, http2session) << "Failed to send control frame type="
<< static_cast<uint32_t>(frame->hd.type)
<< "lib_error_code=" << lib_error_code << ":"
<< nghttp2_strerror(lib_error_code);
2014-11-27 15:39:04 +01:00
if (frame->hd.type == NGHTTP2_HEADERS &&
frame->headers.cat == NGHTTP2_HCAT_REQUEST) {
// To avoid stream hanging around, flag Downstream::MSG_RESET and
// terminate the upstream and downstream connections.
2014-11-27 15:39:04 +01:00
auto sd = static_cast<StreamData *>(
nghttp2_session_get_stream_user_data(session, frame->hd.stream_id));
if (!sd) {
return 0;
}
2014-11-27 15:39:04 +01:00
if (sd->dconn) {
2013-07-26 12:33:25 +02:00
auto downstream = sd->dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (!downstream ||
downstream->get_downstream_stream_id() != frame->hd.stream_id) {
return 0;
}
downstream->set_response_state(Downstream::MSG_RESET);
call_downstream_readcb(http2session, downstream);
}
http2session->remove_stream_data(sd);
}
return 0;
}
} // namespace
2014-11-27 15:39:04 +01:00
int Http2Session::on_connect() {
int rv;
state_ = Http2Session::CONNECTED;
2014-11-27 15:39:04 +01:00
if (ssl_ctx_) {
const unsigned char *next_proto = nullptr;
unsigned int next_proto_len;
SSL_get0_next_proto_negotiated(ssl_, &next_proto, &next_proto_len);
2014-11-27 15:39:04 +01:00
for (int i = 0; i < 2; ++i) {
if (next_proto) {
if (LOG_ENABLED(INFO)) {
std::string proto(next_proto, next_proto + next_proto_len);
SSLOG(INFO, this) << "Negotiated next protocol: " << proto;
}
2014-11-27 15:39:04 +01:00
if (!util::check_h2_is_selected(next_proto, next_proto_len)) {
return -1;
}
break;
}
#if OPENSSL_VERSION_NUMBER >= 0x10002000L
SSL_get0_alpn_selected(ssl_, &next_proto, &next_proto_len);
2014-11-27 15:39:04 +01:00
#else // OPENSSL_VERSION_NUMBER < 0x10002000L
break;
#endif // OPENSSL_VERSION_NUMBER < 0x10002000L
}
2014-11-27 15:39:04 +01:00
if (!next_proto) {
return -1;
}
}
nghttp2_session_callbacks *callbacks;
rv = nghttp2_session_callbacks_new(&callbacks);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
return -1;
}
2014-09-16 16:39:38 +02:00
auto callbacks_deleter =
2014-11-27 15:39:04 +01:00
util::defer(callbacks, nghttp2_session_callbacks_del);
2014-11-27 15:39:04 +01:00
nghttp2_session_callbacks_set_on_stream_close_callback(
callbacks, on_stream_close_callback);
2014-11-27 15:39:04 +01:00
nghttp2_session_callbacks_set_on_frame_recv_callback(callbacks,
on_frame_recv_callback);
2014-11-27 15:39:04 +01:00
nghttp2_session_callbacks_set_on_data_chunk_recv_callback(
callbacks, on_data_chunk_recv_callback);
2014-11-27 15:39:04 +01:00
nghttp2_session_callbacks_set_on_frame_send_callback(callbacks,
on_frame_send_callback);
2014-11-27 15:39:04 +01:00
nghttp2_session_callbacks_set_on_frame_not_send_callback(
callbacks, on_frame_not_send_callback);
2014-11-27 15:39:04 +01:00
nghttp2_session_callbacks_set_on_header_callback(callbacks,
on_header_callback);
2014-11-27 15:39:04 +01:00
nghttp2_session_callbacks_set_on_begin_headers_callback(
callbacks, on_begin_headers_callback);
2014-11-27 15:39:04 +01:00
if (get_config()->padding) {
nghttp2_session_callbacks_set_select_padding_callback(
callbacks, http::select_padding_callback);
}
rv = nghttp2_session_client_new2(&session_, callbacks, this,
get_config()->http2_option);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
return -1;
}
2013-07-26 12:33:25 +02:00
flow_control_ = true;
nghttp2_settings_entry entry[3];
entry[0].settings_id = NGHTTP2_SETTINGS_ENABLE_PUSH;
entry[0].value = 0;
entry[1].settings_id = NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS;
entry[1].value = get_config()->http2_max_concurrent_streams;
entry[2].settings_id = NGHTTP2_SETTINGS_INITIAL_WINDOW_SIZE;
entry[2].value = (1 << get_config()->http2_downstream_window_bits) - 1;
rv = nghttp2_submit_settings(session_, NGHTTP2_FLAG_NONE, entry,
2014-08-27 17:45:12 +02:00
util::array_size(entry));
2014-11-27 15:39:04 +01:00
if (rv != 0) {
return -1;
}
2013-07-26 12:33:25 +02:00
2014-11-27 15:39:04 +01:00
if (get_config()->http2_downstream_connection_window_bits > 16) {
int32_t delta =
2014-11-27 15:39:04 +01:00
(1 << get_config()->http2_downstream_connection_window_bits) - 1 -
NGHTTP2_INITIAL_CONNECTION_WINDOW_SIZE;
rv = nghttp2_submit_window_update(session_, NGHTTP2_FLAG_NONE, 0, delta);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
return -1;
}
}
auto nwrite = wb_.write(NGHTTP2_CLIENT_CONNECTION_PREFACE,
NGHTTP2_CLIENT_CONNECTION_PREFACE_LEN);
if (nwrite != NGHTTP2_CLIENT_CONNECTION_PREFACE_LEN) {
SSLOG(FATAL, this) << "buffer is too small to send connection preface";
return -1;
}
auto must_terminate =
!get_config()->downstream_no_tls && !ssl::check_http2_requirement(ssl_);
if (must_terminate) {
rv = terminate_session(NGHTTP2_INADEQUATE_SECURITY);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
return -1;
}
}
if (must_terminate) {
return 0;
}
reset_connection_check_timer();
// submit pending request
2014-11-27 15:39:04 +01:00
for (auto dconn : dconns_) {
if (dconn->push_request_headers() == 0) {
auto downstream = dconn->get_downstream();
auto upstream = downstream->get_upstream();
upstream->resume_read(SHRPX_NO_BUFFER, downstream, 0);
continue;
}
2014-11-27 15:39:04 +01:00
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "backend request failed";
}
auto downstream = dconn->get_downstream();
2014-11-27 15:39:04 +01:00
if (!downstream) {
continue;
}
auto upstream = downstream->get_upstream();
upstream->on_downstream_abort_request(downstream, 400);
}
signal_write();
return 0;
}
int Http2Session::do_read() { return read_(*this); }
int Http2Session::do_write() { return write_(*this); }
int Http2Session::on_read() { return on_read_(*this); }
int Http2Session::on_write() { return on_write_(*this); }
int Http2Session::downstream_read() {
ssize_t rv = 0;
for (;;) {
const void *data;
size_t nread;
std::tie(data, nread) = rb_.get();
if (nread == 0) {
break;
}
rv = nghttp2_session_mem_recv(
session_, reinterpret_cast<const uint8_t *>(data), nread);
2014-11-27 15:39:04 +01:00
if (rv < 0) {
SSLOG(ERROR, this) << "nghttp2_session_recv() returned error: "
<< nghttp2_strerror(rv);
return -1;
}
rb_.drain(nread);
}
if (nghttp2_session_want_read(session_) == 0 &&
nghttp2_session_want_write(session_) == 0 && wb_.rleft() == 0) {
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "No more read/write for this HTTP2 session";
}
return -1;
}
signal_write();
return 0;
}
int Http2Session::downstream_write() {
if (data_pending_) {
auto n = std::min(wb_.wleft(), data_pendinglen_);
wb_.write(data_pending_, n);
if (n < data_pendinglen_) {
2015-01-02 05:42:32 +01:00
data_pending_ += n;
data_pendinglen_ -= n;
return 0;
}
data_pending_ = nullptr;
data_pendinglen_ = 0;
}
for (;;) {
const uint8_t *data;
auto datalen = nghttp2_session_mem_send(session_, &data);
2014-11-27 15:39:04 +01:00
if (datalen < 0) {
SSLOG(ERROR, this) << "nghttp2_session_mem_send() returned error: "
<< nghttp2_strerror(datalen);
return -1;
}
2014-11-27 15:39:04 +01:00
if (datalen == 0) {
break;
}
auto n = wb_.write(data, datalen);
if (n < static_cast<decltype(n)>(datalen)) {
data_pending_ = data + n;
data_pendinglen_ = datalen - n;
return 0;
}
}
2014-11-27 15:39:04 +01:00
if (nghttp2_session_want_read(session_) == 0 &&
nghttp2_session_want_write(session_) == 0 && wb_.rleft() == 0) {
2014-11-27 15:39:04 +01:00
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "No more read/write for this session";
}
return -1;
}
return 0;
}
void Http2Session::signal_write() { write_requested_ = true; }
void Http2Session::clear_write_request() { write_requested_ = false; }
bool Http2Session::write_requested() const { return write_requested_; }
struct ev_loop *Http2Session::get_loop() const {
return loop_;
}
ev_io *Http2Session::get_wev() { return &wev_; }
2014-11-27 15:39:04 +01:00
int Http2Session::get_state() const { return state_; }
2014-11-27 15:39:04 +01:00
void Http2Session::set_state(int state) { state_ = state; }
2014-11-27 15:39:04 +01:00
int Http2Session::terminate_session(uint32_t error_code) {
int rv;
rv = nghttp2_session_terminate_session(session_, error_code);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
return -1;
}
return 0;
}
2014-11-27 15:39:04 +01:00
SSL *Http2Session::get_ssl() const { return ssl_; }
2014-11-27 15:39:04 +01:00
int Http2Session::consume(int32_t stream_id, size_t len) {
int rv;
2014-11-27 15:39:04 +01:00
if (!session_) {
return 0;
}
rv = nghttp2_session_consume(session_, stream_id, len);
2014-11-27 15:39:04 +01:00
if (rv != 0) {
SSLOG(WARN, this) << "nghttp2_session_consume() returned error: "
<< nghttp2_strerror(rv);
return -1;
}
return 0;
}
bool Http2Session::can_push_request() const {
return state_ == CONNECTED &&
connection_check_state_ == CONNECTION_CHECK_NONE;
}
void Http2Session::start_checking_connection() {
if (state_ != CONNECTED ||
connection_check_state_ != CONNECTION_CHECK_REQUIRED) {
return;
}
connection_check_state_ = CONNECTION_CHECK_STARTED;
SSLOG(INFO, this) << "Start checking connection";
// If connection is down, we may get error when writing data. Issue
// ping frame to see whether connection is alive.
nghttp2_submit_ping(session_, NGHTTP2_FLAG_NONE, NULL);
signal_write();
}
void Http2Session::reset_connection_check_timer() {
ev_timer_again(loop_, &connchk_timer_);
}
void Http2Session::connection_alive() {
reset_connection_check_timer();
if (connection_check_state_ == CONNECTION_CHECK_NONE) {
return;
}
SSLOG(INFO, this) << "Connection alive";
connection_check_state_ = CONNECTION_CHECK_NONE;
// submit pending request
for (auto dconn : dconns_) {
auto downstream = dconn->get_downstream();
if (!downstream ||
(downstream->get_request_state() != Downstream::HEADER_COMPLETE &&
downstream->get_request_state() != Downstream::MSG_COMPLETE) ||
downstream->get_response_state() != Downstream::INITIAL) {
continue;
}
auto upstream = downstream->get_upstream();
if (dconn->push_request_headers() == 0) {
upstream->resume_read(SHRPX_NO_BUFFER, downstream, 0);
continue;
}
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "backend request failed";
}
upstream->on_downstream_abort_request(downstream, 400);
}
}
void Http2Session::set_connection_check_state(int state) {
connection_check_state_ = state;
}
int Http2Session::noop() { return 0; }
int Http2Session::connected() {
2015-01-05 08:14:10 +01:00
if (!util::check_socket_connected(fd_)) {
return -1;
}
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "Connection established";
}
ev_io_start(loop_, &rev_);
if (ssl_) {
read_ = &Http2Session::tls_handshake;
write_ = &Http2Session::tls_handshake;
return do_write();
}
read_ = &Http2Session::read_clear;
write_ = &Http2Session::write_clear;
if (state_ == PROXY_CONNECTING) {
return do_write();
}
if (on_connect() != 0) {
state_ = CONNECT_FAILING;
return -1;
}
return 0;
}
int Http2Session::read_clear() {
ev_timer_again(loop_, &rt_);
for (;;) {
// we should process buffered data first before we read EOF.
if (rb_.rleft() && on_read() != 0) {
return -1;
}
if (rb_.rleft()) {
return 0;
}
rb_.reset();
struct iovec iov[2];
auto iovcnt = rb_.wiovec(iov);
if (iovcnt > 0) {
ssize_t nread;
while ((nread = readv(fd_, iov, iovcnt)) == -1 && errno == EINTR)
;
if (nread == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
break;
}
return -1;
}
if (nread == 0) {
return -1;
}
rb_.write(nread);
}
}
return 0;
}
int Http2Session::write_clear() {
ev_timer_again(loop_, &rt_);
for (;;) {
if (wb_.rleft() > 0) {
struct iovec iov[2];
auto iovcnt = wb_.riovec(iov);
ssize_t nwrite;
while ((nwrite = writev(fd_, iov, iovcnt)) == -1 && errno == EINTR)
;
if (nwrite == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
ev_io_start(loop_, &wev_);
ev_timer_again(loop_, &wt_);
return 0;
}
return -1;
}
wb_.drain(nwrite);
continue;
}
2015-01-02 05:54:41 +01:00
wb_.reset();
if (on_write() != 0) {
return -1;
}
if (wb_.rleft() == 0) {
break;
}
}
ev_io_stop(loop_, &wev_);
ev_timer_stop(loop_, &wt_);
return 0;
}
int Http2Session::tls_handshake() {
ev_timer_again(loop_, &rt_);
ERR_clear_error();
auto rv = SSL_do_handshake(ssl_);
if (rv == 0) {
return -1;
}
if (rv < 0) {
auto err = SSL_get_error(ssl_, rv);
switch (err) {
case SSL_ERROR_WANT_READ:
ev_io_stop(loop_, &wev_);
ev_timer_stop(loop_, &wt_);
return 0;
case SSL_ERROR_WANT_WRITE:
ev_io_start(loop_, &wev_);
ev_timer_again(loop_, &wt_);
return 0;
default:
return -1;
}
}
ev_io_stop(loop_, &wev_);
ev_timer_stop(loop_, &wt_);
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "SSL/TLS handshake completed";
}
if (LOG_ENABLED(INFO)) {
if (SSL_session_reused(ssl_)) {
CLOG(INFO, this) << "SSL/TLS session reused";
}
}
if (!get_config()->downstream_no_tls && !get_config()->insecure &&
check_cert() != 0) {
return -1;
}
read_ = &Http2Session::read_tls;
write_ = &Http2Session::write_tls;
if (on_connect() != 0) {
state_ = CONNECT_FAILING;
return -1;
}
return 0;
}
int Http2Session::read_tls() {
ev_timer_again(loop_, &rt_);
ERR_clear_error();
for (;;) {
// we should process buffered data first before we read EOF.
if (rb_.rleft() && on_read() != 0) {
return -1;
}
if (rb_.rleft()) {
return 0;
}
2015-01-02 05:54:41 +01:00
rb_.reset();
struct iovec iov[2];
auto iovcnt = rb_.wiovec(iov);
if (iovcnt == 0) {
return 0;
}
auto rv = SSL_read(ssl_, iov[0].iov_base, iov[0].iov_len);
if (rv == 0) {
return -1;
}
if (rv < 0) {
auto err = SSL_get_error(ssl_, rv);
switch (err) {
case SSL_ERROR_WANT_READ:
return 0;
case SSL_ERROR_WANT_WRITE:
ev_io_start(loop_, &wev_);
ev_timer_again(loop_, &wt_);
return 0;
default:
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "SSL_read: SSL_get_error returned " << err;
}
return -1;
}
}
rb_.write(rv);
}
}
int Http2Session::write_tls() {
ev_timer_again(loop_, &rt_);
ERR_clear_error();
for (;;) {
if (wb_.rleft() > 0) {
const void *p;
size_t len;
std::tie(p, len) = wb_.get();
auto rv = SSL_write(ssl_, p, len);
if (rv == 0) {
return -1;
}
if (rv < 0) {
auto err = SSL_get_error(ssl_, rv);
switch (err) {
case SSL_ERROR_WANT_READ:
ev_io_stop(loop_, &wev_);
ev_timer_stop(loop_, &wt_);
return 0;
case SSL_ERROR_WANT_WRITE:
ev_io_start(loop_, &wev_);
ev_timer_again(loop_, &wt_);
return 0;
default:
if (LOG_ENABLED(INFO)) {
SSLOG(INFO, this) << "SSL_write: SSL_get_error returned " << err;
}
return -1;
}
}
wb_.drain(rv);
continue;
}
2015-01-02 05:54:41 +01:00
wb_.reset();
if (on_write() != 0) {
return -1;
}
if (wb_.rleft() == 0) {
break;
}
}
ev_io_stop(loop_, &wev_);
ev_timer_stop(loop_, &wt_);
return 0;
}
bool Http2Session::should_hard_fail() const {
switch (state_) {
case PROXY_CONNECTING:
case PROXY_FAILED:
case CONNECTING:
case CONNECT_FAILING:
return true;
default:
return false;
}
}
} // namespace shrpx