cpp/firecgi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: cpp:a39ef8e25dc2450b9219da67e37cfe158bd4a3ec
Branches Tags
cpp:master
...
compare: cpp:master
Branches Tags
cpp:master

3 Commits
a39ef8e25d ... master

Author SHA1 Message Date
Ian Gulliver
fe61f0dd20 Typos 2019-05-18 23:46:47 -07:00
Ian Gulliver
f9988beb88 Module update 2019-05-18 12:16:58 -07:00
Ian Gulliver
690c9ab8bd Google format 2019-05-18 12:15:11 -07:00
14 changed files with 606 additions and 445 deletions
Expand all files Collapse all files

151
.clang-format Normal file
View File

@@ -0,0 +1,151 @@
---
Language: Cpp
# BasedOnStyle: Google
AccessModifierOffset: -1
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Left
AlignOperands: true
AlignTrailingComments: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: false
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: true
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^<ext/.*\.h>'
Priority: 2
- Regex: '^<.*\.h>'
Priority: 1
- Regex: '^<.*'
Priority: 2
- Regex: '.*'
Priority: 3
IncludeIsMainRegex: '([-_](test|unittest))?$'
IndentCaseLabels: true
IndentPPDirectives: None
IndentWidth: 2
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: false
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Never
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 1
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 200
PointerAlignment: Left
RawStringFormats:
- Language: Cpp
Delimiters:
- cc
- CC
- cpp
- Cpp
- CPP
- 'c++'
- 'C++'
CanonicalDelimiter: ''
BasedOnStyle: google
- Language: TextProto
Delimiters:
- pb
- PB
- proto
- PROTO
EnclosingFunctions:
- EqualsProto
- EquivToProto
- PARSE_PARTIAL_TEXT_PROTO
- PARSE_TEST_PROTO
- PARSE_TEXT_PROTO
- ParseTextOrDie
- ParseTextProtoOrDie
CanonicalDelimiter: ''
BasedOnStyle: google
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 2
SpacesInAngles: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
Standard: Auto
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseTab: Never
...

2
Makefile
View File

@@ -20,7 +20,7 @@ firecgi.o: $(objects) firebuf/firebuf.o fireusage/fireusage.o
gold -z relro -z now -r --output=$@ $+ gold -z relro -z now -r --output=$@ $+
firecgi.so: $(objects) firebuf/firebuf.o fireusage/fireusage.o firecgi.so: $(objects) firebuf/firebuf.o fireusage/fireusage.o
$(FIRE_CXX) $(FIRE_CXXFLAGS) $(FIRE_LDFLAGS) -shared -o $@ $+ $(FIRE_LDFLIBS) $(FIRE_CXX) $(FIRE_CXXFLAGS) $(FIRE_LDFLAGS) -shared -o $@ $+ $(FIRE_LDLIBS)
example_simple: example_simple.o firecgi.o example_simple: example_simple.o firecgi.o
$(FIRE_CXX) $(FIRE_CXXFLAGS) $(FIRE_LDFLAGS) -pie -o $@ $+ $(FIRE_LDLIBS) $(FIRE_CXX) $(FIRE_CXXFLAGS) $(FIRE_LDFLAGS) -pie -o $@ $+ $(FIRE_LDLIBS)

220
connection.cc
View File

@@ -9,143 +9,145 @@
namespace firecgi { namespace firecgi {
Connection::Connection(int sock, const sockaddr_in6& client_addr, const std::function<void(Request*)>& callback, int max_request_len) Connection::Connection(int sock, const sockaddr_in6 &client_addr,
: sock_(sock), const std::function<void(Request *)> &callback,
callback_(callback), int max_request_len)
buf_(sock, max_request_len), : sock_(sock),
request_(this) { callback_(callback),
char client_addr_str[INET6_ADDRSTRLEN]; buf_(sock, max_request_len),
PCHECK(inet_ntop(AF_INET6, &client_addr.sin6_addr, client_addr_str, sizeof(client_addr_str))); request_(this) {
char client_addr_str[INET6_ADDRSTRLEN];
PCHECK(inet_ntop(AF_INET6, &client_addr.sin6_addr, client_addr_str,
sizeof(client_addr_str)));
LOG(INFO) << "new connection: [" << client_addr_str << "]:" << ntohs(client_addr.sin6_port); LOG(INFO) << "new connection: [" << client_addr_str
<< "]:" << ntohs(client_addr.sin6_port);
} }
Connection::~Connection() { Connection::~Connection() {
PCHECK(close(sock_) == 0); PCHECK(close(sock_) == 0);
LOG(INFO) << "connection closed (handled " << requests_ << " requests)"; LOG(INFO) << "connection closed (handled " << requests_ << " requests)";
} }
bool Connection::Write(const std::vector<iovec>& vecs) { bool Connection::Write(const std::vector<iovec> &vecs) {
ssize_t total_size = 0; ssize_t total_size = 0;
for (const auto& vec : vecs) { for (const auto &vec : vecs) {
total_size += vec.iov_len; total_size += vec.iov_len;
} }
return writev(sock_, vecs.data(), vecs.size()) == total_size; return writev(sock_, vecs.data(), vecs.size()) == total_size;
} }
int Connection::Read() { int Connection::Read() {
if (!buf_.Refill()) { if (!buf_.Refill()) {
return sock_; return sock_;
} }
while (true) { while (true) {
buf_.ResetRead(); buf_.ResetRead();
const auto *header = buf_.ReadObj<Header>(); const auto *header = buf_.ReadObj<Header>();
if (!header) { if (!header) {
break; break;
} }
if (header->version != 1) { if (header->version != 1) {
LOG(ERROR) << "invalid FastCGI protocol version: " << header->version; LOG(ERROR) << "invalid FastCGI protocol version: " << header->version;
return sock_; return sock_;
} }
if (buf_.ReadMaxLen() < header->ContentLength()) { if (buf_.ReadMaxLen() < header->ContentLength()) {
break; break;
} }
switch (header->type) { switch (header->type) {
case 1: case 1: {
{ if (header->ContentLength() != sizeof(BeginRequest)) {
if (header->ContentLength() != sizeof(BeginRequest)) { LOG(ERROR) << "FCGI_BeginRequestBody is the wrong length: "
LOG(ERROR) << "FCGI_BeginRequestBody is the wrong length: " << header->ContentLength(); << header->ContentLength();
return sock_; return sock_;
} }
const auto *begin_request = CHECK_NOTNULL(buf_.ReadObj<BeginRequest>()); const auto *begin_request = CHECK_NOTNULL(buf_.ReadObj<BeginRequest>());
if (begin_request->Role() != 1) { if (begin_request->Role() != 1) {
LOG(ERROR) << "unsupported FastCGI role: " << begin_request->Role(); LOG(ERROR) << "unsupported FastCGI role: " << begin_request->Role();
return sock_; return sock_;
} }
request_.NewRequest(header->RequestId()); request_.NewRequest(header->RequestId());
} } break;
break;
case 4: case 4: {
{ if (header->RequestId() != request_.RequestId()) {
if (header->RequestId() != request_.RequestId()) { LOG(ERROR) << "out of order FCGI_PARAMS record, or client is "
LOG(ERROR) << "out of order FCGI_PARAMS record, or client is multiplexing requests (which we don't support)"; "multiplexing requests (which we don't support)";
return sock_; return sock_;
} }
firebuf::ConstBuffer param_buf(buf_.Read(header->ContentLength()), header->ContentLength()); firebuf::ConstBuffer param_buf(buf_.Read(header->ContentLength()),
while (param_buf.ReadMaxLen() > 0) { header->ContentLength());
const auto *param_header = param_buf.ReadObj<ParamHeader>(); while (param_buf.ReadMaxLen() > 0) {
if (!param_header) { const auto *param_header = param_buf.ReadObj<ParamHeader>();
LOG(ERROR) << "FCGI_PARAMS missing header"; if (!param_header) {
return sock_; LOG(ERROR) << "FCGI_PARAMS missing header";
} return sock_;
}
const auto *key_buf = param_buf.Read(param_header->key_length); const auto *key_buf = param_buf.Read(param_header->key_length);
if (!key_buf) { if (!key_buf) {
LOG(ERROR) << "FCGI_PARAMS missing key"; LOG(ERROR) << "FCGI_PARAMS missing key";
return sock_; return sock_;
} }
std::string_view key(key_buf, param_header->key_length); std::string_view key(key_buf, param_header->key_length);
const auto *value_buf = param_buf.Read(param_header->value_length); const auto *value_buf = param_buf.Read(param_header->value_length);
if (!value_buf) { if (!value_buf) {
LOG(ERROR) << "FCGI_PARAMS missing value"; LOG(ERROR) << "FCGI_PARAMS missing value";
return sock_; return sock_;
} }
std::string_view value(value_buf, param_header->value_length); std::string_view value(value_buf, param_header->value_length);
request_.AddParam(key, value); request_.AddParam(key, value);
} }
} } break;
break;
case 5: case 5: {
{ if (header->RequestId() != request_.RequestId()) {
if (header->RequestId() != request_.RequestId()) { LOG(ERROR) << "out of order FCGI_STDIN record, or client is "
LOG(ERROR) << "out of order FCGI_STDIN record, or client is multiplexing requests (which we don't support)"; "multiplexing requests (which we don't support)";
return sock_; return sock_;
} }
if (header->ContentLength() == 0) { if (header->ContentLength() == 0) {
// Magic signal for completed request (mirrors the HTTP/1.1 protocol) // Magic signal for completed request (mirrors the HTTP/1.1 protocol)
requests_++; requests_++;
callback_(&request_); callback_(&request_);
buf_.Consume(); // discard data and invalidate pointers buf_.Consume(); // discard data and invalidate pointers
} else { } else {
if (!request_.GetBody().empty()) { if (!request_.GetBody().empty()) {
LOG(ERROR) << "received multiple stdin records. have you set \"fastcgi_request_buffering on\"?"; LOG(ERROR) << "received multiple stdin records. have you set "
} "\"fastcgi_request_buffering on\"?";
request_.SetBody({buf_.Read(header->ContentLength()), header->ContentLength()}); }
} request_.SetBody(
} {buf_.Read(header->ContentLength()), header->ContentLength()});
break; }
} break;
default: default:
LOG(ERROR) << "unknown record type: " << header->type; LOG(ERROR) << "unknown record type: " << header->type;
return sock_; return sock_;
} }
if (!buf_.Discard(header->padding_length)) { if (!buf_.Discard(header->padding_length)) {
break; break;
} }
buf_.Commit(); // we've acted on the bytes read so far buf_.Commit(); // we've acted on the bytes read so far
} }
return -1; return -1;
} }
uint64_t Connection::Requests() const { uint64_t Connection::Requests() const { return requests_; }
return requests_;
}
} // namespace firecgi } // namespace firecgi

31
connection.h
View File

@@ -1,7 +1,7 @@
#pragma once #pragma once
#include <functional>
#include <sys/uio.h> #include <sys/uio.h>
#include <functional>
#include <unordered_map> #include <unordered_map>
#include <unordered_set> #include <unordered_set>
@@ -12,23 +12,24 @@
namespace firecgi { namespace firecgi {
class Connection { class Connection {
public: public:
Connection(int sock, const sockaddr_in6& client_addr, const std::function<void(Request*)>& callback, int max_request_len); Connection(int sock, const sockaddr_in6& client_addr,
~Connection(); const std::function<void(Request*)>& callback,
int max_request_len);
~Connection();
[[nodiscard]] int Read(); [[nodiscard]] int Read();
[[nodiscard]] bool Write(const std::vector<iovec>& vecs); [[nodiscard]] bool Write(const std::vector<iovec>& vecs);
[[nodiscard]] uint64_t Requests() const; [[nodiscard]] uint64_t Requests() const;
private: private:
const int sock_; const int sock_;
const std::function<void(Request*)>& callback_; const std::function<void(Request*)>& callback_;
firebuf::StreamBuffer buf_; firebuf::StreamBuffer buf_;
Request request_; Request request_;
uint64_t requests_ = 0;
uint64_t requests_ = 0;
}; };
} // namespace firecgi } // namespace firecgi

24
connection_afl.cc
View File

@@ -1,18 +1,20 @@
#include "connection.h" #include "connection.h"
int main(int argc, char* argv[]) { int main(int argc, char* argv[]) {
FLAGS_logtostderr = 1; FLAGS_logtostderr = 1;
FLAGS_minloglevel = 3; FLAGS_minloglevel = 3;
google::InitGoogleLogging(argv[0]); google::InitGoogleLogging(argv[0]);
gflags::ParseCommandLineFlags(&argc, &argv, true); gflags::ParseCommandLineFlags(&argc, &argv, true);
{ {
firecgi::Connection conn(STDIN_FILENO, {}, [](firecgi::Request* req) { req->End(); }, {}, 16*1024); firecgi::Connection conn(
static_cast<void>(conn.Read()); STDIN_FILENO, {}, [](firecgi::Request* req) { req->End(); }, {},
} 16 * 1024);
static_cast<void>(conn.Read());
}
gflags::ShutDownCommandLineFlags(); gflags::ShutDownCommandLineFlags();
google::ShutdownGoogleLogging(); google::ShutdownGoogleLogging();
return 0; return 0;
} }

27
example_simple.cc
View File

@@ -6,18 +6,21 @@
DEFINE_int32(port, 9000, "TCP port to bind"); DEFINE_int32(port, 9000, "TCP port to bind");
DEFINE_int32(threads, 1, "Number of server threads"); DEFINE_int32(threads, 1, "Number of server threads");
int main(int argc, char *argv[]) { int main(int argc, char* argv[]) {
google::InitGoogleLogging(argv[0]); google::InitGoogleLogging(argv[0]);
gflags::ParseCommandLineFlags(&argc, &argv, true); gflags::ParseCommandLineFlags(&argc, &argv, true);
firecgi::Server server(FLAGS_port, [](firecgi::Request* request) { firecgi::Server server(
request->WriteHeader("Content-Type", "text/plain"); FLAGS_port,
request->WriteBody("Hello world"); [](firecgi::Request* request) {
request->End(); request->WriteHeader("Content-Type", "text/plain");
}, FLAGS_threads); request->WriteBody("Hello world");
server.RegisterSignalHandlers(); request->End();
server.Serve(); },
FLAGS_threads);
server.RegisterSignalHandlers();
server.Serve();
gflags::ShutDownCommandLineFlags(); gflags::ShutDownCommandLineFlags();
google::ShutdownGoogleLogging(); google::ShutdownGoogleLogging();
} }

2
firebuf

Submodule firebuf updated: 2102147a2f...109a9be193

2
fireusage

Submodule fireusage updated: a70d79e869...37be853a8b

8
parse.cc
View File

@@ -3,9 +3,9 @@
namespace firecgi { namespace firecgi {
Header::Header(uint8_t type_in, uint16_t request_id, uint16_t content_length) Header::Header(uint8_t type_in, uint16_t request_id, uint16_t content_length)
: type(type_in) { : type(type_in) {
SetRequestId(request_id); SetRequestId(request_id);
SetContentLength(content_length); SetContentLength(content_length);
} }
} // namespace firecgi } // namespace firecgi

53
parse.h
View File

@@ -5,43 +5,46 @@
namespace firecgi { namespace firecgi {
struct Header { struct Header {
Header(uint8_t type_in, uint16_t request_id, uint16_t content_length); Header(uint8_t type_in, uint16_t request_id, uint16_t content_length);
uint8_t version = 1; uint8_t version = 1;
uint8_t type; uint8_t type;
private:
uint16_t request_id_; // network byte order
uint16_t content_length_; // network byte order
public:
uint8_t padding_length = 0;
uint8_t reserved = 0;
uint16_t RequestId() const { return ntohs(request_id_); } private:
uint16_t ContentLength() const { return ntohs(content_length_); } uint16_t request_id_; // network byte order
uint16_t content_length_; // network byte order
public:
uint8_t padding_length = 0;
uint8_t reserved = 0;
void SetRequestId(uint16_t request_id) { request_id_ = htons(request_id); } uint16_t RequestId() const { return ntohs(request_id_); }
void SetContentLength(uint16_t content_length) { content_length_ = htons(content_length); } uint16_t ContentLength() const { return ntohs(content_length_); }
void SetRequestId(uint16_t request_id) { request_id_ = htons(request_id); }
void SetContentLength(uint16_t content_length) {
content_length_ = htons(content_length);
}
}; };
struct BeginRequest { struct BeginRequest {
private: private:
uint16_t role_; // network byte order uint16_t role_; // network byte order
public: public:
uint8_t flags; uint8_t flags;
uint8_t reserved[5]; uint8_t reserved[5];
uint16_t Role() const { return ntohs(role_); } uint16_t Role() const { return ntohs(role_); }
}; };
struct EndRequest { struct EndRequest {
uint32_t app_status = htonl(0); // network byte order uint32_t app_status = htonl(0); // network byte order
uint8_t protocol_status; uint8_t protocol_status;
uint8_t reserved[3] = {}; uint8_t reserved[3] = {};
}; };
struct ParamHeader { struct ParamHeader {
uint8_t key_length; uint8_t key_length;
uint8_t value_length; uint8_t value_length;
}; };
} // namespace firecgi } // namespace firecgi

167
request.cc
View File

@@ -7,137 +7,132 @@
namespace firecgi { namespace firecgi {
namespace { namespace {
template<class T> void AppendVec(const T& obj, std::vector<iovec>* vec) { template <class T>
vec->push_back(iovec{ void AppendVec(const T& obj, std::vector<iovec>* vec) {
.iov_base = (void*)(&obj), vec->push_back(iovec{
.iov_len = sizeof(obj), .iov_base = (void*)(&obj),
}); .iov_len = sizeof(obj),
});
} }
} // namespace } // namespace
Request::Request(Connection* conn) Request::Request(Connection* conn) : conn_(conn), out_buf_(64 * 1024) {}
: conn_(conn),
out_buf_(64*1024) {}
Request::~Request() { Request::~Request() {
if (on_close_) { if (on_close_) {
on_close_(); on_close_();
} }
} }
void Request::NewRequest(uint16_t request_id) { void Request::NewRequest(uint16_t request_id) {
if (on_close_) { if (on_close_) {
on_close_(); on_close_();
} }
request_id_ = request_id; request_id_ = request_id;
params_.clear(); params_.clear();
body_ = {}; body_ = {};
on_close_ = nullptr; on_close_ = nullptr;
out_buf_.Reset(); out_buf_.Reset();
body_written_ = false; body_written_ = false;
} }
uint16_t Request::RequestId() const { uint16_t Request::RequestId() const { return request_id_; }
return request_id_;
void Request::AddParam(const std::string_view& key,
const std::string_view& value) {
params_.try_emplace(key, value);
} }
void Request::AddParam(const std::string_view& key, const std::string_view& value) { void Request::SetBody(const std::string_view& body) { body_ = body; }
params_.try_emplace(key, value);
}
void Request::SetBody(const std::string_view& body) {
body_ = body;
}
const std::string_view& Request::GetParam(const std::string_view& key) const { const std::string_view& Request::GetParam(const std::string_view& key) const {
auto iter = params_.find(key); auto iter = params_.find(key);
if (iter == params_.end()) { if (iter == params_.end()) {
static const std::string_view none; static const std::string_view none;
return none; return none;
} }
return iter->second; return iter->second;
} }
const std::string_view& Request::GetBody() const { const std::string_view& Request::GetBody() const { return body_; }
return body_;
}
void Request::OnClose(const std::function<void()>& on_close) { void Request::OnClose(const std::function<void()>& on_close) {
on_close_ = on_close; on_close_ = on_close;
} }
void Request::WriteHeader(const std::string_view& name, const std::string_view& value) { void Request::WriteHeader(const std::string_view& name,
std::lock_guard<std::recursive_mutex> l(output_mu_); const std::string_view& value) {
std::lock_guard<std::recursive_mutex> l(output_mu_);
CHECK(!body_written_); CHECK(!body_written_);
CHECK(out_buf_.Write(name)); CHECK(out_buf_.Write(name));
CHECK(out_buf_.Write(": ")); CHECK(out_buf_.Write(": "));
CHECK(out_buf_.Write(value)); CHECK(out_buf_.Write(value));
CHECK(out_buf_.Write("\n")); CHECK(out_buf_.Write("\n"));
} }
void Request::WriteBody(const std::string_view& body) { void Request::WriteBody(const std::string_view& body) {
std::lock_guard<std::recursive_mutex> l(output_mu_); std::lock_guard<std::recursive_mutex> l(output_mu_);
if (!body_written_) { if (!body_written_) {
CHECK(out_buf_.Write("\n")); CHECK(out_buf_.Write("\n"));
body_written_ = true; body_written_ = true;
} }
// TODO: make this able to span multiple packets // TODO: make this able to span multiple packets
CHECK(out_buf_.Write(body)); CHECK(out_buf_.Write(body));
} }
bool Request::Flush() { bool Request::Flush() {
std::lock_guard<std::recursive_mutex> l(output_mu_); std::lock_guard<std::recursive_mutex> l(output_mu_);
std::vector<iovec> vecs; std::vector<iovec> vecs;
auto header = OutputHeader(); auto header = OutputHeader();
AppendVec(header, &vecs); AppendVec(header, &vecs);
vecs.push_back(OutputVec()); vecs.push_back(OutputVec());
if (!conn_->Write(vecs)) { if (!conn_->Write(vecs)) {
return false; return false;
} }
out_buf_.Commit(); out_buf_.Commit();
out_buf_.Consume(); out_buf_.Consume();
return true; return true;
} }
bool Request::End() { bool Request::End() {
std::lock_guard<std::recursive_mutex> l(output_mu_); std::lock_guard<std::recursive_mutex> l(output_mu_);
WriteBody(""); WriteBody("");
std::vector<iovec> vecs; std::vector<iovec> vecs;
// Must be outside if block, so it lives through Write() below // Must be outside if block, so it lives through Write() below
auto output_header = OutputHeader(); auto output_header = OutputHeader();
if (output_header.ContentLength()) { if (output_header.ContentLength()) {
AppendVec(output_header, &vecs); AppendVec(output_header, &vecs);
vecs.push_back(OutputVec()); vecs.push_back(OutputVec());
} }
EndRequest end; EndRequest end;
Header end_header(3, request_id_, sizeof(end)); Header end_header(3, request_id_, sizeof(end));
AppendVec(end_header, &vecs); AppendVec(end_header, &vecs);
AppendVec(end, &vecs); AppendVec(end, &vecs);
return conn_->Write(vecs); return conn_->Write(vecs);
} }
iovec Request::OutputVec() { iovec Request::OutputVec() {
const auto output_len = out_buf_.ReadMaxLen(); const auto output_len = out_buf_.ReadMaxLen();
return iovec{ return iovec{
.iov_base = (void *)(CHECK_NOTNULL(out_buf_.Read(output_len))), .iov_base = (void*)(CHECK_NOTNULL(out_buf_.Read(output_len))),
.iov_len = output_len, .iov_len = output_len,
}; };
} }
Header Request::OutputHeader() { Header Request::OutputHeader() {
return Header(6, request_id_, out_buf_.ReadMaxLen()); return Header(6, request_id_, out_buf_.ReadMaxLen());
} }
} // namespace firecgi } // namespace firecgi

74
request.h
View File

@@ -13,61 +13,61 @@ namespace firecgi {
class Connection; class Connection;
class Request { class Request {
public: public:
Request(Connection *conn); Request(Connection* conn);
~Request(); ~Request();
void NewRequest(uint16_t request_id); void NewRequest(uint16_t request_id);
uint16_t RequestId() const; uint16_t RequestId() const;
void AddParam(const std::string_view& key, const std::string_view& value); void AddParam(const std::string_view& key, const std::string_view& value);
void SetBody(const std::string_view& in); void SetBody(const std::string_view& in);
const std::string_view& GetParam(const std::string_view& key) const; const std::string_view& GetParam(const std::string_view& key) const;
const std::string_view& GetBody() const; const std::string_view& GetBody() const;
void OnClose(const std::function<void()>& callback); void OnClose(const std::function<void()>& callback);
void WriteHeader(const std::string_view& name, const std::string_view& value); void WriteHeader(const std::string_view& name, const std::string_view& value);
void WriteBody(const std::string_view& body); void WriteBody(const std::string_view& body);
[[nodiscard]] bool Flush(); [[nodiscard]] bool Flush();
bool End(); bool End();
template<typename...Args> template <typename... Args>
void WriteBody(const std::string_view& first, Args... more); void WriteBody(const std::string_view& first, Args... more);
template<typename T> template <typename T>
T InTransaction(const std::function<T()>& callback); T InTransaction(const std::function<T()>& callback);
private: private:
Header OutputHeader(); Header OutputHeader();
iovec OutputVec(); iovec OutputVec();
Connection *conn_; Connection* conn_;
uint16_t request_id_ = 0; uint16_t request_id_ = 0;
std::unordered_map<std::string_view, std::string_view> params_; std::unordered_map<std::string_view, std::string_view> params_;
std::string_view body_; std::string_view body_;
std::function<void()> on_close_; std::function<void()> on_close_;
firebuf::Buffer out_buf_; firebuf::Buffer out_buf_;
bool body_written_; bool body_written_;
std::recursive_mutex output_mu_; std::recursive_mutex output_mu_;
}; };
template<typename...Args> template <typename... Args>
void Request::WriteBody(const std::string_view& first, Args... more) { void Request::WriteBody(const std::string_view& first, Args... more) {
std::lock_guard<std::recursive_mutex> l(output_mu_); std::lock_guard<std::recursive_mutex> l(output_mu_);
WriteBody(first); WriteBody(first);
WriteBody(more...); WriteBody(more...);
} }
template<typename T> template <typename T>
T Request::InTransaction(const std::function<T()>& callback) { T Request::InTransaction(const std::function<T()>& callback) {
std::lock_guard<std::recursive_mutex> l(output_mu_); std::lock_guard<std::recursive_mutex> l(output_mu_);
return callback(); return callback();
} }
} // namespace firecgi } // namespace firecgi

257
server.cc
View File

@@ -1,5 +1,4 @@
#include <arpa/inet.h> #include <arpa/inet.h>
#include <iomanip>
#include <netinet/in.h> #include <netinet/in.h>
#include <netinet/tcp.h> #include <netinet/tcp.h>
#include <signal.h> #include <signal.h>
@@ -7,176 +6,180 @@
#include <sys/eventfd.h> #include <sys/eventfd.h>
#include <sys/resource.h> #include <sys/resource.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <iomanip>
#include <thread> #include <thread>
#include "fireusage/usage.h" #include "fireusage/usage.h"
#include "server.h"
#include "connection.h" #include "connection.h"
#include "server.h"
namespace firecgi { namespace firecgi {
Server::Server(int port, const std::function<void(Request*)>& callback, int threads, int max_request_len) Server::Server(int port, const std::function<void(Request*)>& callback,
: port_(port), int threads, int max_request_len)
callback_(callback), : port_(port),
threads_(threads), callback_(callback),
max_request_len_(max_request_len), threads_(threads),
close_fd_(eventfd(0, 0)) { max_request_len_(max_request_len),
CHECK_GE(close_fd_, 0); close_fd_(eventfd(0, 0)) {
CHECK_GE(close_fd_, 0);
LOG(INFO) << "listening on [::1]:" << port_; LOG(INFO) << "listening on [::1]:" << port_;
signal(SIGPIPE, SIG_IGN); signal(SIGPIPE, SIG_IGN);
} }
Server::~Server() { Server::~Server() { PCHECK(close(close_fd_) == 0); }
PCHECK(close(close_fd_) == 0);
}
void Server::Serve() { void Server::Serve() {
std::vector<std::thread> threads; std::vector<std::thread> threads;
for (int i = 0; i < threads_ - 1; ++i) { for (int i = 0; i < threads_ - 1; ++i) {
threads.emplace_back([this]() { ServeInt(); }); threads.emplace_back([this]() { ServeInt(); });
} }
ServeInt(); ServeInt();
for (auto& thread : threads) { for (auto& thread : threads) {
thread.join(); thread.join();
} }
LOG(INFO) << "all threads shut down"; LOG(INFO) << "all threads shut down";
} }
void Server::Shutdown() { void Server::Shutdown() {
uint64_t shutdown = 1; uint64_t shutdown = 1;
PCHECK(write(close_fd_, &shutdown, sizeof(shutdown)) == sizeof(shutdown)); PCHECK(write(close_fd_, &shutdown, sizeof(shutdown)) == sizeof(shutdown));
} }
namespace { namespace {
Server* shutdown_server = nullptr; Server* shutdown_server = nullptr;
} // namespace } // namespace
void Server::RegisterSignalHandlers() { void Server::RegisterSignalHandlers() {
shutdown_server = this; shutdown_server = this;
for (auto sig : {SIGINT, SIGTERM}) { for (auto sig : {SIGINT, SIGTERM}) {
signal(sig, [](int signum) { signal(sig, [](int signum) {
LOG(INFO) << "received " << strsignal(signum); LOG(INFO) << "received " << strsignal(signum);
shutdown_server->Shutdown(); shutdown_server->Shutdown();
}); });
} }
} }
void Server::ServeInt() { void Server::ServeInt() {
auto epoll_fd = epoll_create1(0); auto epoll_fd = epoll_create1(0);
PCHECK(epoll_fd >= 0) << "epoll_create()"; PCHECK(epoll_fd >= 0) << "epoll_create()";
auto listen_sock = NewListenSock(); auto listen_sock = NewListenSock();
char new_conn; char new_conn;
{ {
struct epoll_event ev{ struct epoll_event ev {
.events = EPOLLIN, .events = EPOLLIN,
.data = { .data = {
.ptr = &new_conn, .ptr = &new_conn,
}, },
}; };
PCHECK(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_sock, &ev) == 0); PCHECK(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listen_sock, &ev) == 0);
} }
char shutdown; char shutdown;
{ {
struct epoll_event ev{ struct epoll_event ev {
.events = EPOLLIN, .events = EPOLLIN,
.data = { .data = {
.ptr = &shutdown, .ptr = &shutdown,
}, },
}; };
PCHECK(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, close_fd_, &ev) == 0); PCHECK(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, close_fd_, &ev) == 0);
} }
std::unordered_set<Connection*> connections; std::unordered_set<Connection*> connections;
fireusage::UsageTracker usage_tracker; fireusage::UsageTracker usage_tracker;
usage_tracker.Start(); usage_tracker.Start();
while (true) { while (true) {
constexpr auto max_events = 256; constexpr auto max_events = 256;
struct epoll_event events[max_events]; struct epoll_event events[max_events];
auto num_fd = epoll_wait(epoll_fd, events, max_events, -1); auto num_fd = epoll_wait(epoll_fd, events, max_events, -1);
if (num_fd == -1 && errno == EINTR) { if (num_fd == -1 && errno == EINTR) {
continue; continue;
} }
PCHECK(num_fd > 0) << "epoll_wait()"; PCHECK(num_fd > 0) << "epoll_wait()";
for (auto i = 0; i < num_fd; ++i) { for (auto i = 0; i < num_fd; ++i) {
if (events[i].data.ptr == &new_conn) { if (events[i].data.ptr == &new_conn) {
connections.insert(CHECK_NOTNULL(NewConn(listen_sock, epoll_fd))); connections.insert(CHECK_NOTNULL(NewConn(listen_sock, epoll_fd)));
} else if (events[i].data.ptr == &shutdown) { } else if (events[i].data.ptr == &shutdown) {
for (auto& conn : connections) { for (auto& conn : connections) {
usage_tracker.AddEvents(conn->Requests()); usage_tracker.AddEvents(conn->Requests());
delete conn; delete conn;
} }
usage_tracker.Stop(); usage_tracker.Stop();
PCHECK(close(listen_sock) == 0); PCHECK(close(listen_sock) == 0);
PCHECK(close(epoll_fd) == 0); PCHECK(close(epoll_fd) == 0);
usage_tracker.Log("requests"); usage_tracker.Log("requests");
return; return;
} else { } else {
auto conn = static_cast<Connection*>(events[i].data.ptr); auto conn = static_cast<Connection*>(events[i].data.ptr);
auto fd = conn->Read(); auto fd = conn->Read();
if (fd != -1) { if (fd != -1) {
PCHECK(epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, nullptr) == 0); PCHECK(epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, nullptr) == 0);
usage_tracker.AddEvents(conn->Requests()); usage_tracker.AddEvents(conn->Requests());
connections.erase(conn); connections.erase(conn);
delete conn; delete conn;
} }
} }
} }
} }
} }
Connection* Server::NewConn(int listen_sock, int epoll_fd) { Connection* Server::NewConn(int listen_sock, int epoll_fd) {
sockaddr_in6 client_addr; sockaddr_in6 client_addr;
socklen_t client_addr_len = sizeof(client_addr); socklen_t client_addr_len = sizeof(client_addr);
auto client_sock = accept(listen_sock, (sockaddr*) &client_addr, &client_addr_len); auto client_sock =
PCHECK(client_sock >= 0) << "accept()"; accept(listen_sock, (sockaddr*)&client_addr, &client_addr_len);
CHECK_EQ(client_addr.sin6_family, AF_INET6); PCHECK(client_sock >= 0) << "accept()";
CHECK_EQ(client_addr.sin6_family, AF_INET6);
int flags = 1; int flags = 1;
PCHECK(setsockopt(client_sock, SOL_TCP, TCP_NODELAY, &flags, sizeof(flags)) == 0); PCHECK(setsockopt(client_sock, SOL_TCP, TCP_NODELAY, &flags, sizeof(flags)) ==
0);
auto *conn = new Connection(client_sock, client_addr, callback_, max_request_len_); auto* conn =
{ new Connection(client_sock, client_addr, callback_, max_request_len_);
struct epoll_event ev{ {
.events = EPOLLIN, struct epoll_event ev {
.data = { .events = EPOLLIN,
.ptr = conn, .data = {
}, .ptr = conn,
}; },
PCHECK(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_sock, &ev) == 0); };
} PCHECK(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_sock, &ev) == 0);
}
return conn; return conn;
} }
int Server::NewListenSock() { int Server::NewListenSock() {
auto sock = socket(AF_INET6, SOCK_STREAM, 0); auto sock = socket(AF_INET6, SOCK_STREAM, 0);
PCHECK(sock >= 0) << "socket()"; PCHECK(sock >= 0) << "socket()";
{ {
int optval = 1; int optval = 1;
PCHECK(setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof(optval)) == 0); PCHECK(setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &optval,
} sizeof(optval)) == 0);
}
{ {
sockaddr_in6 bind_addr = { sockaddr_in6 bind_addr = {
.sin6_family = AF_INET6, .sin6_family = AF_INET6,
.sin6_port = htons(port_), .sin6_port = htons(port_),
.sin6_addr = IN6ADDR_LOOPBACK_INIT, .sin6_addr = IN6ADDR_LOOPBACK_INIT,
}; };
PCHECK(bind(sock, (sockaddr*) &bind_addr, sizeof(bind_addr)) == 0); PCHECK(bind(sock, (sockaddr*)&bind_addr, sizeof(bind_addr)) == 0);
} }
PCHECK(listen(sock, 128) == 0); PCHECK(listen(sock, 128) == 0);
return sock; return sock;
} }
} // namespace firecgi } // namespace firecgi

33
server.h
View File

@@ -9,25 +9,26 @@
namespace firecgi { namespace firecgi {
class Server { class Server {
public: public:
Server(int port, const std::function<void(Request*)>& callback, int threads=1, int max_request_len=(16*1024)); Server(int port, const std::function<void(Request*)>& callback,
~Server(); int threads = 1, int max_request_len = (16 * 1024));
~Server();
void Serve(); void Serve();
void Shutdown(); void Shutdown();
void RegisterSignalHandlers(); void RegisterSignalHandlers();
private: private:
Connection *NewConn(int listen_sock, int epoll_fd); Connection* NewConn(int listen_sock, int epoll_fd);
int NewListenSock(); int NewListenSock();
void ServeInt(); void ServeInt();
const int port_; const int port_;
const std::function<void(Request*)> callback_; const std::function<void(Request*)> callback_;
const int threads_; const int threads_;
const int max_request_len_; const int max_request_len_;
int close_fd_; int close_fd_;
}; };
} // firecgi } // namespace firecgi