1017 lines
26 KiB
C++
1017 lines
26 KiB
C++
/*
|
|
* Spdylay - SPDY 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 "SpdyServer.h"
|
|
|
|
#include <sys/stat.h>
|
|
#include <sys/socket.h>
|
|
#include <netdb.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <netinet/in.h>
|
|
#include <netinet/tcp.h>
|
|
|
|
#include <cassert>
|
|
#include <set>
|
|
#include <iostream>
|
|
|
|
#include <openssl/err.h>
|
|
#include <zlib.h>
|
|
|
|
#include "spdylay_ssl.h"
|
|
#include "uri.h"
|
|
#include "util.h"
|
|
#include "EventPoll.h"
|
|
|
|
namespace spdylay {
|
|
|
|
namespace {
|
|
Config config;
|
|
const std::string STATUS_200 = "200 OK";
|
|
const std::string STATUS_304 = "304 Not Modified";
|
|
const std::string STATUS_400 = "400 Bad Request";
|
|
const std::string STATUS_404 = "404 Not Found";
|
|
const std::string DEFAULT_HTML = "index.html";
|
|
const std::string SPDYD_SERVER = "spdyd spdylay/" SPDYLAY_VERSION;
|
|
} // namespace
|
|
|
|
Config::Config(): verbose(false), daemon(false), port(0), data_ptr(0),
|
|
spdy3_only(false), verify_client(false)
|
|
{}
|
|
|
|
Request::Request(int32_t stream_id)
|
|
: stream_id(stream_id),
|
|
file(-1)
|
|
{}
|
|
|
|
Request::~Request()
|
|
{
|
|
if(file != -1) {
|
|
close(file);
|
|
}
|
|
}
|
|
|
|
EventHandler::EventHandler(const Config *config)
|
|
: config_(config),
|
|
mark_del_(false)
|
|
{}
|
|
|
|
namespace {
|
|
void on_close(Sessions &sessions, EventHandler *hd);
|
|
} // namespace
|
|
|
|
class Sessions {
|
|
public:
|
|
Sessions(int max_events, SSL_CTX *ssl_ctx)
|
|
: eventPoll_(max_events),
|
|
ssl_ctx_(ssl_ctx)
|
|
{}
|
|
~Sessions()
|
|
{
|
|
for(std::set<EventHandler*>::iterator i = handlers_.begin(),
|
|
eoi = handlers_.end(); i != eoi; ++i) {
|
|
on_close(*this, *i);
|
|
delete *i;
|
|
}
|
|
SSL_CTX_free(ssl_ctx_);
|
|
}
|
|
void add_handler(EventHandler *handler)
|
|
{
|
|
handlers_.insert(handler);
|
|
}
|
|
void remove_handler(EventHandler *handler)
|
|
{
|
|
handlers_.erase(handler);
|
|
}
|
|
SSL* ssl_session_new(int fd)
|
|
{
|
|
SSL *ssl = SSL_new(ssl_ctx_);
|
|
if(SSL_set_fd(ssl, fd) == 0) {
|
|
SSL_free(ssl);
|
|
return 0;
|
|
}
|
|
return ssl;
|
|
}
|
|
int add_poll(EventHandler *handler)
|
|
{
|
|
return update_poll_internal(handler, EP_ADD);
|
|
}
|
|
int mod_poll(EventHandler *handler)
|
|
{
|
|
return update_poll_internal(handler, EP_MOD);
|
|
}
|
|
int poll(int timeout)
|
|
{
|
|
return eventPoll_.poll(timeout);
|
|
}
|
|
void* get_user_data(int p)
|
|
{
|
|
return eventPoll_.get_user_data(p);
|
|
}
|
|
int get_events(int p)
|
|
{
|
|
return eventPoll_.get_events(p);
|
|
}
|
|
private:
|
|
int update_poll_internal(EventHandler *handler, int op)
|
|
{
|
|
int events = 0;
|
|
if(handler->want_read()) {
|
|
events |= EP_POLLIN;
|
|
}
|
|
if(handler->want_write()) {
|
|
events |= EP_POLLOUT;
|
|
}
|
|
return eventPoll_.ctl_event(op, handler->fd(), events, handler);
|
|
}
|
|
|
|
std::set<EventHandler*> handlers_;
|
|
EventPoll eventPoll_;
|
|
SSL_CTX *ssl_ctx_;
|
|
};
|
|
|
|
namespace {
|
|
void print_session_id(int64_t id)
|
|
{
|
|
std::cout << "[id=" << id << "] ";
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void on_session_closed(EventHandler *hd, int64_t session_id)
|
|
{
|
|
if(hd->config()->verbose) {
|
|
print_session_id(session_id);
|
|
print_timer();
|
|
std::cout << " closed" << std::endl;
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
SpdyEventHandler::SpdyEventHandler(const Config* config,
|
|
int fd, SSL *ssl,
|
|
uint16_t version,
|
|
const spdylay_session_callbacks *callbacks,
|
|
int64_t session_id)
|
|
: EventHandler(config),
|
|
fd_(fd), ssl_(ssl), version_(version), session_id_(session_id),
|
|
want_write_(false)
|
|
{
|
|
int r;
|
|
r = spdylay_session_server_new(&session_, version, callbacks, this);
|
|
assert(r == 0);
|
|
spdylay_settings_entry entry;
|
|
entry.settings_id = SPDYLAY_SETTINGS_MAX_CONCURRENT_STREAMS;
|
|
entry.value = SPDYLAY_INITIAL_MAX_CONCURRENT_STREAMS;
|
|
entry.flags = SPDYLAY_ID_FLAG_SETTINGS_NONE;
|
|
r = spdylay_submit_settings(session_, SPDYLAY_FLAG_SETTINGS_NONE,
|
|
&entry, 1);
|
|
assert(r == 0);
|
|
}
|
|
|
|
SpdyEventHandler::~SpdyEventHandler()
|
|
{
|
|
on_session_closed(this, session_id_);
|
|
spdylay_session_del(session_);
|
|
for(std::map<int32_t, Request*>::iterator i = id2req_.begin(),
|
|
eoi = id2req_.end(); i != eoi; ++i) {
|
|
delete (*i).second;
|
|
}
|
|
SSL_shutdown(ssl_);
|
|
SSL_free(ssl_);
|
|
shutdown(fd_, SHUT_WR);
|
|
close(fd_);
|
|
}
|
|
|
|
uint16_t SpdyEventHandler::version() const
|
|
{
|
|
return version_;
|
|
}
|
|
|
|
int SpdyEventHandler::execute(Sessions *sessions)
|
|
{
|
|
int r;
|
|
r = spdylay_session_recv(session_);
|
|
if(r == 0) {
|
|
r = spdylay_session_send(session_);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
bool SpdyEventHandler::want_read()
|
|
{
|
|
return spdylay_session_want_read(session_);
|
|
}
|
|
|
|
bool SpdyEventHandler::want_write()
|
|
{
|
|
return spdylay_session_want_write(session_) || want_write_;
|
|
}
|
|
|
|
int SpdyEventHandler::fd() const
|
|
{
|
|
return fd_;
|
|
}
|
|
|
|
bool SpdyEventHandler::finish()
|
|
{
|
|
return !spdylay_session_want_read(session_) &&
|
|
!spdylay_session_want_write(session_);
|
|
}
|
|
|
|
ssize_t SpdyEventHandler::send_data(const uint8_t *data, size_t len, int flags)
|
|
{
|
|
ssize_t r;
|
|
ERR_clear_error();
|
|
r = SSL_write(ssl_, data, len);
|
|
return r;
|
|
}
|
|
|
|
ssize_t SpdyEventHandler::recv_data(uint8_t *data, size_t len, int flags)
|
|
{
|
|
ssize_t r;
|
|
want_write_ = false;
|
|
ERR_clear_error();
|
|
r = SSL_read(ssl_, data, len);
|
|
if(r < 0) {
|
|
if(SSL_get_error(ssl_, r) == SSL_ERROR_WANT_WRITE) {
|
|
want_write_ = true;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
bool SpdyEventHandler::would_block(int r)
|
|
{
|
|
int e = SSL_get_error(ssl_, r);
|
|
return e == SSL_ERROR_WANT_WRITE || e == SSL_ERROR_WANT_READ;
|
|
}
|
|
|
|
int SpdyEventHandler::submit_file_response(const std::string& status,
|
|
int32_t stream_id,
|
|
time_t last_modified,
|
|
off_t file_length,
|
|
spdylay_data_provider *data_prd)
|
|
{
|
|
std::string date_str = util::http_date(time(0));
|
|
std::string content_length = util::to_str(file_length);
|
|
std::string last_modified_str;
|
|
const char *nv[] = {
|
|
":status", status.c_str(),
|
|
":version", "HTTP/1.1",
|
|
"server", SPDYD_SERVER.c_str(),
|
|
"content-length", content_length.c_str(),
|
|
"cache-control", "max-age=3600",
|
|
"date", date_str.c_str(),
|
|
0, 0,
|
|
0
|
|
};
|
|
if(last_modified != 0) {
|
|
last_modified_str = util::http_date(last_modified);
|
|
nv[12] = "last-modified";
|
|
nv[13] = last_modified_str.c_str();
|
|
}
|
|
return spdylay_submit_response(session_, stream_id, nv, data_prd);
|
|
}
|
|
|
|
int SpdyEventHandler::submit_response
|
|
(const std::string& status,
|
|
int32_t stream_id,
|
|
const std::vector<std::pair<std::string, std::string> >& headers,
|
|
spdylay_data_provider *data_prd)
|
|
{
|
|
std::string date_str = util::http_date(time(0));
|
|
const char **nv = new const char*[8+headers.size()*2+1];
|
|
nv[0] = ":status";
|
|
nv[1] = status.c_str();
|
|
nv[2] = ":version";
|
|
nv[3] = "HTTP/1.1";
|
|
nv[4] = "server";
|
|
nv[5] = SPDYD_SERVER.c_str();
|
|
nv[6] = "date";
|
|
nv[7] = date_str.c_str();
|
|
for(int i = 0; i < (int)headers.size(); ++i) {
|
|
nv[8+i*2] = headers[i].first.c_str();
|
|
nv[8+i*2+1] = headers[i].second.c_str();
|
|
}
|
|
nv[8+headers.size()*2] = 0;
|
|
int r = spdylay_submit_response(session_, stream_id, nv, data_prd);
|
|
delete [] nv;
|
|
return r;
|
|
}
|
|
|
|
int SpdyEventHandler::submit_response(const std::string& status,
|
|
int32_t stream_id,
|
|
spdylay_data_provider *data_prd)
|
|
{
|
|
const char *nv[] = {
|
|
":status", status.c_str(),
|
|
":version", "HTTP/1.1",
|
|
"server", SPDYD_SERVER.c_str(),
|
|
0
|
|
};
|
|
return spdylay_submit_response(session_, stream_id, nv, data_prd);
|
|
}
|
|
|
|
void SpdyEventHandler::add_stream(int32_t stream_id, Request *req)
|
|
{
|
|
id2req_[stream_id] = req;
|
|
}
|
|
|
|
void SpdyEventHandler::remove_stream(int32_t stream_id)
|
|
{
|
|
Request *req = id2req_[stream_id];
|
|
id2req_.erase(stream_id);
|
|
delete req;
|
|
}
|
|
|
|
Request* SpdyEventHandler::get_stream(int32_t stream_id)
|
|
{
|
|
return id2req_[stream_id];
|
|
}
|
|
|
|
int64_t SpdyEventHandler::session_id() const
|
|
{
|
|
return session_id_;
|
|
}
|
|
|
|
namespace {
|
|
ssize_t hd_send_callback(spdylay_session *session,
|
|
const uint8_t *data, size_t len, int flags,
|
|
void *user_data)
|
|
{
|
|
SpdyEventHandler *hd = (SpdyEventHandler*)user_data;
|
|
ssize_t r = hd->send_data(data, len, flags);
|
|
if(r < 0) {
|
|
if(hd->would_block(r)) {
|
|
r = SPDYLAY_ERR_WOULDBLOCK;
|
|
} else {
|
|
r = SPDYLAY_ERR_CALLBACK_FAILURE;
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
ssize_t hd_recv_callback(spdylay_session *session,
|
|
uint8_t *data, size_t len, int flags, void *user_data)
|
|
{
|
|
SpdyEventHandler *hd = (SpdyEventHandler*)user_data;
|
|
ssize_t r = hd->recv_data(data, len, flags);
|
|
if(r < 0) {
|
|
if(hd->would_block(r)) {
|
|
r = SPDYLAY_ERR_WOULDBLOCK;
|
|
} else {
|
|
r = SPDYLAY_ERR_CALLBACK_FAILURE;
|
|
}
|
|
} else if(r == 0) {
|
|
r = SPDYLAY_ERR_EOF;
|
|
}
|
|
return r;
|
|
}
|
|
} // namespace
|
|
|
|
ssize_t file_read_callback
|
|
(spdylay_session *session, int32_t stream_id,
|
|
uint8_t *buf, size_t length, int *eof,
|
|
spdylay_data_source *source, void *user_data)
|
|
{
|
|
int fd = source->fd;
|
|
ssize_t r;
|
|
while((r = read(fd, buf, length)) == -1 && errno == EINTR);
|
|
if(r == -1) {
|
|
return SPDYLAY_ERR_TEMPORAL_CALLBACK_FAILURE;
|
|
} else {
|
|
if(r == 0) {
|
|
*eof = 1;
|
|
}
|
|
return r;
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
bool check_url(const std::string& url)
|
|
{
|
|
// We don't like '\' in url.
|
|
return !url.empty() && url[0] == '/' &&
|
|
url.find('\\') == std::string::npos &&
|
|
url.find("/../") == std::string::npos &&
|
|
url.find("/./") == std::string::npos &&
|
|
!util::endsWith(url, "/..") && !util::endsWith(url, "/.");
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void prepare_status_response(Request *req, SpdyEventHandler *hd,
|
|
const std::string& status)
|
|
{
|
|
int pipefd[2];
|
|
if(pipe(pipefd) == -1) {
|
|
hd->submit_response(status, req->stream_id, 0);
|
|
} else {
|
|
std::stringstream ss;
|
|
ss << "<html><head><title>" << status << "</title></head><body>"
|
|
<< "<h1>" << status << "</h1>"
|
|
<< "<hr>"
|
|
<< "<address>" << SPDYD_SERVER << " at port " << hd->config()->port
|
|
<< "</address>"
|
|
<< "</body></html>";
|
|
std::string body = ss.str();
|
|
gzFile write_fd = gzdopen(pipefd[1], "w");
|
|
gzwrite(write_fd, body.c_str(), body.size());
|
|
gzclose(write_fd);
|
|
close(pipefd[1]);
|
|
|
|
req->file = pipefd[0];
|
|
spdylay_data_provider data_prd;
|
|
data_prd.source.fd = pipefd[0];
|
|
data_prd.read_callback = file_read_callback;
|
|
std::vector<std::pair<std::string, std::string> > headers;
|
|
headers.push_back(std::make_pair("content-encoding", "gzip"));
|
|
headers.push_back(std::make_pair("content-type",
|
|
"text/html; charset=UTF-8"));
|
|
hd->submit_response(status, req->stream_id, headers, &data_prd);
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void prepare_response(Request *req, SpdyEventHandler *hd)
|
|
{
|
|
std::string url;
|
|
bool url_found = false;
|
|
bool method_found = false;
|
|
bool scheme_found = false;
|
|
bool version_found = false;
|
|
bool host_found = false;
|
|
time_t last_mod = 0;
|
|
bool last_mod_found = false;
|
|
for(int i = 0; i < (int)req->headers.size(); ++i) {
|
|
const std::string &field = req->headers[i].first;
|
|
const std::string &value = req->headers[i].second;
|
|
if(!url_found && field == ":path") {
|
|
url_found = true;
|
|
url = value;
|
|
} else if(field == ":method") {
|
|
method_found = true;
|
|
} else if(field == ":scheme") {
|
|
scheme_found = true;
|
|
} else if(field == ":version") {
|
|
version_found = true;
|
|
} else if(field == ":host") {
|
|
host_found = true;
|
|
} else if(!last_mod_found && field == "if-modified-since") {
|
|
last_mod_found = true;
|
|
last_mod = util::parse_http_date(value);
|
|
}
|
|
}
|
|
if(!url_found || !method_found || !scheme_found || !version_found ||
|
|
!host_found) {
|
|
prepare_status_response(req, hd, STATUS_400);
|
|
return;
|
|
}
|
|
std::string::size_type query_pos = url.find("?");
|
|
if(query_pos != std::string::npos) {
|
|
// Do not response to this request to allow clients to test timeouts.
|
|
if (url.find("spdyd_do_not_respond_to_req=yes",
|
|
query_pos) != std::string::npos) {
|
|
return;
|
|
}
|
|
url = url.substr(0, query_pos);
|
|
}
|
|
url = util::percentDecode(url.begin(), url.end());
|
|
if(!check_url(url)) {
|
|
prepare_status_response(req, hd, STATUS_404);
|
|
return;
|
|
}
|
|
std::string path = hd->config()->htdocs+url;
|
|
if(path[path.size()-1] == '/') {
|
|
path += DEFAULT_HTML;
|
|
}
|
|
int file = open(path.c_str(), O_RDONLY);
|
|
if(file == -1) {
|
|
prepare_status_response(req, hd, STATUS_404);
|
|
} else {
|
|
struct stat buf;
|
|
if(fstat(file, &buf) == -1) {
|
|
close(file);
|
|
prepare_status_response(req, hd, STATUS_404);
|
|
} else {
|
|
req->file = file;
|
|
spdylay_data_provider data_prd;
|
|
data_prd.source.fd = file;
|
|
data_prd.read_callback = file_read_callback;
|
|
if(last_mod_found && buf.st_mtime <= last_mod) {
|
|
prepare_status_response(req, hd, STATUS_304);
|
|
} else {
|
|
hd->submit_file_response(STATUS_200, req->stream_id, buf.st_mtime,
|
|
buf.st_size, &data_prd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void append_nv(Request *req, char **nv)
|
|
{
|
|
for(int i = 0; nv[i]; i += 2) {
|
|
req->headers.push_back(std::make_pair(nv[i], nv[i+1]));
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void hd_on_ctrl_recv_callback
|
|
(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
|
|
void *user_data)
|
|
{
|
|
SpdyEventHandler *hd = (SpdyEventHandler*)user_data;
|
|
if(hd->config()->verbose) {
|
|
print_session_id(hd->session_id());
|
|
on_ctrl_recv_callback(session, type, frame, user_data);
|
|
}
|
|
switch(type) {
|
|
case SPDYLAY_SYN_STREAM: {
|
|
int32_t stream_id = frame->syn_stream.stream_id;
|
|
Request *req = new Request(stream_id);
|
|
append_nv(req, frame->syn_stream.nv);
|
|
hd->add_stream(stream_id, req);
|
|
break;
|
|
}
|
|
case SPDYLAY_HEADERS: {
|
|
int32_t stream_id = frame->headers.stream_id;
|
|
Request *req = hd->get_stream(stream_id);
|
|
append_nv(req, frame->headers.nv);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
void htdocs_on_request_recv_callback
|
|
(spdylay_session *session, int32_t stream_id, void *user_data)
|
|
{
|
|
SpdyEventHandler *hd = (SpdyEventHandler*)user_data;
|
|
prepare_response(hd->get_stream(stream_id), hd);
|
|
}
|
|
|
|
namespace {
|
|
void hd_on_ctrl_send_callback
|
|
(spdylay_session *session, spdylay_frame_type type, spdylay_frame *frame,
|
|
void *user_data)
|
|
{
|
|
SpdyEventHandler *hd = (SpdyEventHandler*)user_data;
|
|
if(hd->config()->verbose) {
|
|
print_session_id(hd->session_id());
|
|
on_ctrl_send_callback(session, type, frame, user_data);
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void on_data_chunk_recv_callback
|
|
(spdylay_session *session, uint8_t flags, int32_t stream_id,
|
|
const uint8_t *data, size_t len, void *user_data)
|
|
{
|
|
// TODO Handle POST
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void hd_on_data_recv_callback
|
|
(spdylay_session *session, uint8_t flags, int32_t stream_id, int32_t length,
|
|
void *user_data)
|
|
{
|
|
// TODO Handle POST
|
|
SpdyEventHandler *hd = (SpdyEventHandler*)user_data;
|
|
if(hd->config()->verbose) {
|
|
print_session_id(hd->session_id());
|
|
on_data_recv_callback(session, flags, stream_id, length, user_data);
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void hd_on_data_send_callback
|
|
(spdylay_session *session, uint8_t flags, int32_t stream_id, int32_t length,
|
|
void *user_data)
|
|
{
|
|
SpdyEventHandler *hd = (SpdyEventHandler*)user_data;
|
|
if(hd->config()->verbose) {
|
|
print_session_id(hd->session_id());
|
|
on_data_send_callback(session, flags, stream_id, length, user_data);
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
void on_stream_close_callback
|
|
(spdylay_session *session, int32_t stream_id, spdylay_status_code status_code,
|
|
void *user_data)
|
|
{
|
|
SpdyEventHandler *hd = (SpdyEventHandler*)user_data;
|
|
hd->remove_stream(stream_id);
|
|
if(hd->config()->verbose) {
|
|
print_session_id(hd->session_id());
|
|
print_timer();
|
|
printf(" stream_id=%d closed\n", stream_id);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
} // namespace
|
|
|
|
class SSLAcceptEventHandler : public EventHandler {
|
|
public:
|
|
SSLAcceptEventHandler(const Config *config,
|
|
int fd, SSL *ssl, int64_t session_id)
|
|
: EventHandler(config),
|
|
fd_(fd), ssl_(ssl), version_(0), fail_(false), finish_(false),
|
|
want_read_(true), want_write_(true),
|
|
session_id_(session_id)
|
|
{}
|
|
virtual ~SSLAcceptEventHandler()
|
|
{
|
|
if(fail_) {
|
|
on_session_closed(this, session_id_);
|
|
SSL_shutdown(ssl_);
|
|
SSL_free(ssl_);
|
|
shutdown(fd_, SHUT_WR);
|
|
close(fd_);
|
|
}
|
|
}
|
|
virtual int execute(Sessions *sessions)
|
|
{
|
|
want_read_ = want_write_ = false;
|
|
ERR_clear_error();
|
|
int r = SSL_accept(ssl_);
|
|
if(r == 1) {
|
|
finish_ = true;
|
|
const unsigned char *next_proto = 0;
|
|
unsigned int next_proto_len;
|
|
SSL_get0_next_proto_negotiated(ssl_, &next_proto, &next_proto_len);
|
|
if(next_proto) {
|
|
std::string proto(next_proto, next_proto+next_proto_len);
|
|
if(config()->verbose) {
|
|
std::cout << "The negotiated next protocol: " << proto << std::endl;
|
|
}
|
|
version_ = spdylay_npn_get_version(next_proto, next_proto_len);
|
|
if(version_) {
|
|
add_next_handler(sessions);
|
|
} else {
|
|
fail_ = true;
|
|
}
|
|
} else {
|
|
fail_ = true;
|
|
}
|
|
} else if(r == 0) {
|
|
int e = SSL_get_error(ssl_, r);
|
|
if(e == SSL_ERROR_SSL) {
|
|
if(config()->verbose) {
|
|
std::cerr << ERR_error_string(ERR_get_error(), 0) << std::endl;
|
|
}
|
|
}
|
|
finish_ = true;
|
|
fail_ = true;
|
|
} else {
|
|
int d = SSL_get_error(ssl_, r);
|
|
if(d == SSL_ERROR_WANT_READ) {
|
|
want_read_ = true;
|
|
} else if(d == SSL_ERROR_WANT_WRITE) {
|
|
want_write_ = true;
|
|
} else {
|
|
finish_ = true;
|
|
fail_ = true;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
virtual bool want_read()
|
|
{
|
|
return want_read_;
|
|
}
|
|
virtual bool want_write()
|
|
{
|
|
return want_write_;
|
|
}
|
|
virtual int fd() const
|
|
{
|
|
return fd_;
|
|
}
|
|
virtual bool finish()
|
|
{
|
|
return finish_;
|
|
}
|
|
private:
|
|
void add_next_handler(Sessions *sessions)
|
|
{
|
|
spdylay_session_callbacks callbacks;
|
|
memset(&callbacks, 0, sizeof(spdylay_session_callbacks));
|
|
callbacks.send_callback = hd_send_callback;
|
|
callbacks.recv_callback = hd_recv_callback;
|
|
callbacks.on_stream_close_callback = on_stream_close_callback;
|
|
callbacks.on_ctrl_recv_callback = hd_on_ctrl_recv_callback;
|
|
callbacks.on_ctrl_send_callback = hd_on_ctrl_send_callback;
|
|
callbacks.on_data_recv_callback = hd_on_data_recv_callback;
|
|
callbacks.on_data_send_callback = hd_on_data_send_callback;
|
|
if(config()->verbose) {
|
|
callbacks.on_invalid_ctrl_recv_callback = on_invalid_ctrl_recv_callback;
|
|
callbacks.on_ctrl_recv_parse_error_callback =
|
|
on_ctrl_recv_parse_error_callback;
|
|
callbacks.on_unknown_ctrl_recv_callback = on_unknown_ctrl_recv_callback;
|
|
}
|
|
callbacks.on_data_chunk_recv_callback = on_data_chunk_recv_callback;
|
|
callbacks.on_request_recv_callback = config()->on_request_recv_callback;
|
|
SpdyEventHandler *hd = new SpdyEventHandler(config(),
|
|
fd_, ssl_, version_, &callbacks,
|
|
session_id_);
|
|
if(sessions->mod_poll(hd) == -1) {
|
|
// fd_, ssl_ are freed by ~SpdyEventHandler()
|
|
delete hd;
|
|
} else {
|
|
sessions->add_handler(hd);
|
|
}
|
|
}
|
|
|
|
int fd_;
|
|
SSL *ssl_;
|
|
uint16_t version_;
|
|
bool fail_, finish_;
|
|
bool want_read_, want_write_;
|
|
int64_t session_id_;
|
|
};
|
|
|
|
class ListenEventHandler : public EventHandler {
|
|
public:
|
|
ListenEventHandler(const Config* config,
|
|
int fd, int64_t *session_id_seed_ptr)
|
|
: EventHandler(config),
|
|
fd_(fd), session_id_seed_ptr_(session_id_seed_ptr) {}
|
|
virtual ~ListenEventHandler()
|
|
{}
|
|
virtual int execute(Sessions *sessions)
|
|
{
|
|
int cfd;
|
|
while((cfd = accept(fd_, 0, 0)) == -1 && errno == EINTR);
|
|
if(cfd != -1) {
|
|
if(make_non_block(cfd) == -1 ||
|
|
set_tcp_nodelay(cfd) == -1) {
|
|
close(cfd);
|
|
} else {
|
|
add_next_handler(sessions, cfd);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
virtual bool want_read()
|
|
{
|
|
return true;
|
|
}
|
|
virtual bool want_write()
|
|
{
|
|
return false;
|
|
}
|
|
virtual int fd() const
|
|
{
|
|
return fd_;
|
|
}
|
|
virtual bool finish()
|
|
{
|
|
return false;
|
|
}
|
|
private:
|
|
void add_next_handler(Sessions *sessions, int cfd)
|
|
{
|
|
SSL *ssl = sessions->ssl_session_new(cfd);
|
|
if(ssl == 0) {
|
|
close(cfd);
|
|
return;
|
|
}
|
|
SSLAcceptEventHandler *hd = new SSLAcceptEventHandler
|
|
(config(), cfd, ssl, ++(*session_id_seed_ptr_));
|
|
if(sessions->add_poll(hd) == -1) {
|
|
delete hd;
|
|
SSL_free(ssl);
|
|
close(cfd);
|
|
} else {
|
|
sessions->add_handler(hd);
|
|
}
|
|
}
|
|
|
|
int fd_;
|
|
int64_t *session_id_seed_ptr_;
|
|
};
|
|
|
|
namespace {
|
|
void on_close(Sessions &sessions, EventHandler *hd)
|
|
{
|
|
sessions.remove_handler(hd);
|
|
delete hd;
|
|
}
|
|
} // namespace
|
|
|
|
SpdyServer::SpdyServer(const Config *config)
|
|
: config_(config)
|
|
{
|
|
memset(sfd_, -1, sizeof(sfd_));
|
|
}
|
|
|
|
SpdyServer::~SpdyServer()
|
|
{
|
|
for(int i = 0; i < 2; ++i) {
|
|
if(sfd_[i] != -1) {
|
|
close(sfd_[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
int SpdyServer::listen()
|
|
{
|
|
int families[] = { AF_INET, AF_INET6 };
|
|
bool bind_ok = false;
|
|
for(int i = 0; i < 2; ++i) {
|
|
const char* ipv = (families[i] == AF_INET ? "IPv4" : "IPv6");
|
|
int sfd = make_listen_socket(config_->host, config_->port, families[i]);
|
|
if(sfd == -1) {
|
|
std::cerr << ipv << ": Could not listen on port " << config_->port
|
|
<< std::endl;
|
|
continue;
|
|
}
|
|
make_non_block(sfd);
|
|
sfd_[i] = sfd;
|
|
if(config_->verbose) {
|
|
std::cout << ipv << ": listen on port " << config_->port << std::endl;
|
|
}
|
|
bind_ok = true;
|
|
}
|
|
if(!bind_ok) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
namespace {
|
|
int next_proto_cb(SSL *s, const unsigned char **data, unsigned int *len,
|
|
void *arg)
|
|
{
|
|
std::pair<unsigned char*, size_t> *next_proto =
|
|
reinterpret_cast<std::pair<unsigned char*, size_t>* >(arg);
|
|
*data = next_proto->first;
|
|
*len = next_proto->second;
|
|
return SSL_TLSEXT_ERR_OK;
|
|
}
|
|
} // namespace
|
|
|
|
namespace {
|
|
int verify_callback(int preverify_ok, X509_STORE_CTX *ctx)
|
|
{
|
|
// We don't verify the client certificate. Just request it for the
|
|
// testing purpose.
|
|
return 1;
|
|
}
|
|
} // namespace
|
|
|
|
int SpdyServer::run()
|
|
{
|
|
SSL_CTX *ssl_ctx;
|
|
ssl_ctx = SSL_CTX_new(SSLv23_server_method());
|
|
if(!ssl_ctx) {
|
|
std::cerr << ERR_error_string(ERR_get_error(), 0) << std::endl;
|
|
return -1;
|
|
}
|
|
SSL_CTX_set_options(ssl_ctx, SSL_OP_ALL|SSL_OP_NO_SSLv2);
|
|
SSL_CTX_set_mode(ssl_ctx, SSL_MODE_AUTO_RETRY);
|
|
SSL_CTX_set_mode(ssl_ctx, SSL_MODE_RELEASE_BUFFERS);
|
|
if(SSL_CTX_use_PrivateKey_file(ssl_ctx,
|
|
config_->private_key_file.c_str(),
|
|
SSL_FILETYPE_PEM) != 1) {
|
|
std::cerr << "SSL_CTX_use_PrivateKey_file failed." << std::endl;
|
|
return -1;
|
|
}
|
|
if(SSL_CTX_use_certificate_chain_file(ssl_ctx,
|
|
config_->cert_file.c_str()) != 1) {
|
|
std::cerr << "SSL_CTX_use_certificate_file failed." << std::endl;
|
|
return -1;
|
|
}
|
|
if(SSL_CTX_check_private_key(ssl_ctx) != 1) {
|
|
std::cerr << "SSL_CTX_check_private_key failed." << std::endl;
|
|
return -1;
|
|
}
|
|
if(config_->verify_client) {
|
|
SSL_CTX_set_verify(ssl_ctx,
|
|
SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE |
|
|
SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
|
|
verify_callback);
|
|
}
|
|
// We speaks "spdy/2" and "spdy/3".
|
|
std::pair<unsigned char*, size_t> next_proto;
|
|
unsigned char proto_list[14];
|
|
|
|
if(config_->spdy3_only) {
|
|
proto_list[0] = 6;
|
|
memcpy(&proto_list[1], "spdy/3", 6);
|
|
next_proto.first = proto_list;
|
|
next_proto.second = 7;
|
|
} else {
|
|
proto_list[0] = 6;
|
|
memcpy(&proto_list[1], "spdy/3", 6);
|
|
proto_list[7] = 6;
|
|
memcpy(&proto_list[8], "spdy/2", 6);
|
|
next_proto.first = proto_list;
|
|
next_proto.second = sizeof(proto_list);
|
|
}
|
|
|
|
SSL_CTX_set_next_protos_advertised_cb(ssl_ctx, next_proto_cb, &next_proto);
|
|
|
|
const size_t MAX_EVENTS = 256;
|
|
Sessions sessions(MAX_EVENTS, ssl_ctx);
|
|
|
|
int64_t session_id_seed = 0;
|
|
int families[] = { AF_INET, AF_INET6 };
|
|
bool bind_ok = false;
|
|
for(int i = 0; i < 2; ++i) {
|
|
const char* ipv = (families[i] == AF_INET ? "IPv4" : "IPv6");
|
|
ListenEventHandler *listen_hd = new ListenEventHandler(config_,
|
|
sfd_[i],
|
|
&session_id_seed);
|
|
if(sessions.add_poll(listen_hd) == -1) {
|
|
std::cerr << ipv << ": Adding listening socket to poll failed."
|
|
<< std::endl;
|
|
delete listen_hd;
|
|
}
|
|
sessions.add_handler(listen_hd);
|
|
bind_ok = true;
|
|
}
|
|
if(!bind_ok) {
|
|
return -1;
|
|
}
|
|
|
|
std::vector<EventHandler*> del_list;
|
|
while(1) {
|
|
int n = sessions.poll(-1);
|
|
if(n == -1) {
|
|
perror("EventPoll");
|
|
} else {
|
|
for(int i = 0; i < n; ++i) {
|
|
EventHandler *hd = reinterpret_cast<EventHandler*>
|
|
(sessions.get_user_data(i));
|
|
int events = sessions.get_events(i);
|
|
int r = 0;
|
|
if(hd->mark_del()) {
|
|
continue;
|
|
}
|
|
if((events & EP_POLLIN) || (events & EP_POLLOUT)) {
|
|
r = hd->execute(&sessions);
|
|
} else if(events & (EP_POLLERR | EP_POLLHUP)) {
|
|
hd->mark_del(true);
|
|
}
|
|
if(r != 0) {
|
|
hd->mark_del(true);
|
|
} else {
|
|
if(hd->finish()) {
|
|
hd->mark_del(true);
|
|
} else {
|
|
sessions.mod_poll(hd);
|
|
}
|
|
}
|
|
if(hd->mark_del()) {
|
|
del_list.push_back(hd);
|
|
}
|
|
}
|
|
for(std::vector<EventHandler*>::iterator i = del_list.begin(),
|
|
eoi = del_list.end(); i != eoi; ++i) {
|
|
on_close(sessions, *i);
|
|
sessions.remove_handler(*i);
|
|
}
|
|
del_list.clear();
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
} // namespace spdylay
|