moparisthebest/spdylay
1
0
Fork 0
mirror of https://github.com/moparisthebest/spdylay synced 2024-11-17 23:15:07 -05:00
Code Issues Releases Wiki Activity
83b3827b51
spdylay/examples/SpdyServer.cc
Tatsuhiro Tsujikawa 1199db690e gcc-4.7 fix
2012-06-08 21:40:03 +09:00

1017 lines
26 KiB
C++
Raw Blame History

/*
* 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_file(ssl_ctx, config_->cert_file.c_str(),
SSL_FILETYPE_PEM) != 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
Reference in New Issue View Git Blame Copy Permalink