clang format
This commit is contained in:
parent
85248787fc
commit
841c5c6afe
14
contrib/backends/nntpchan-daemon/.clang-format
Normal file
14
contrib/backends/nntpchan-daemon/.clang-format
Normal file
@ -0,0 +1,14 @@
|
||||
TabWidth: 2
|
||||
UseTab: Never
|
||||
ColumnLimit: 120
|
||||
IndentWidth: 2
|
||||
Language: Cpp
|
||||
BreakBeforeBraces: Custom
|
||||
BraceWrapping:
|
||||
AfterClass: true
|
||||
AfterControlStatement: true
|
||||
AfterEnum: true
|
||||
AfterFunction: true
|
||||
AfterNamespace: true
|
||||
AfterStruct: true
|
||||
BeforeElse: true
|
@ -31,14 +31,16 @@ PKGS := libuv libsodium
|
||||
|
||||
LD_FLAGS := $(shell pkg-config --libs $(PKGS)) -lstdc++fs
|
||||
INC_FLAGS := $(shell pkg-config --cflags $(PKGS)) -I$(HEADERS_PATH)
|
||||
CXXFLAGS := -std=c++17 -Wall -Wextra -Werror -pedantic $(INC_FLAGS)
|
||||
REQUIRED_CXXFLAGS = -std=c++17 -Wall -Wextra -Werror -pedantic $(INC_FLAGS)
|
||||
|
||||
DEBUG = 1
|
||||
|
||||
ifeq ($(DEBUG),1)
|
||||
CXXFLAGS += -g
|
||||
REQUIRED_CXXFLAGS += -g
|
||||
endif
|
||||
|
||||
CXXFLAGS += $(REQUIRED_CXXFLAGS)
|
||||
|
||||
NNTPCHAN_LIB = $(REPO)/libnntpchan.a
|
||||
MUSTACHE_LIB = $(REPO)/libmustache.a
|
||||
|
||||
|
@ -26,20 +26,21 @@
|
||||
#define INI_HPP
|
||||
|
||||
#include <cassert>
|
||||
#include <map>
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
|
||||
namespace INI {
|
||||
namespace INI
|
||||
{
|
||||
|
||||
struct Level
|
||||
{
|
||||
Level() : parent(NULL), depth(0) {}
|
||||
Level(Level* p) : parent(p), depth(0) {}
|
||||
Level(Level *p) : parent(p), depth(0) {}
|
||||
|
||||
typedef std::map<std::string, std::string> value_map_t;
|
||||
typedef std::map<std::string, Level> section_map_t;
|
||||
@ -49,57 +50,57 @@ struct Level
|
||||
section_map_t sections;
|
||||
values_t ordered_values; // original order in the ini file
|
||||
sections_t ordered_sections;
|
||||
Level* parent;
|
||||
Level *parent;
|
||||
size_t depth;
|
||||
|
||||
const std::string& operator[](const std::string& name) { return values[name]; }
|
||||
Level& operator()(const std::string& name) { return sections[name]; }
|
||||
const std::string &operator[](const std::string &name) { return values[name]; }
|
||||
Level &operator()(const std::string &name) { return sections[name]; }
|
||||
};
|
||||
|
||||
class Parser
|
||||
{
|
||||
public:
|
||||
Parser(const char* fn);
|
||||
Parser(std::istream& f) : f_(&f), ln_(0) { parse(top_); }
|
||||
Level& top() { return top_; }
|
||||
void dump(std::ostream& s) { dump(s, top(), ""); }
|
||||
Parser(const char *fn);
|
||||
Parser(std::istream &f) : f_(&f), ln_(0) { parse(top_); }
|
||||
Level &top() { return top_; }
|
||||
void dump(std::ostream &s) { dump(s, top(), ""); }
|
||||
|
||||
private:
|
||||
void dump(std::ostream& s, const Level& l, const std::string& sname);
|
||||
void parse(Level& l);
|
||||
void parseSLine(std::string& sname, size_t& depth);
|
||||
void err(const char* s);
|
||||
void dump(std::ostream &s, const Level &l, const std::string &sname);
|
||||
void parse(Level &l);
|
||||
void parseSLine(std::string &sname, size_t &depth);
|
||||
void err(const char *s);
|
||||
|
||||
private:
|
||||
Level top_;
|
||||
std::ifstream f0_;
|
||||
std::istream* f_;
|
||||
std::istream *f_;
|
||||
std::string line_;
|
||||
size_t ln_;
|
||||
};
|
||||
|
||||
inline void
|
||||
Parser::err(const char* s)
|
||||
inline void Parser::err(const char *s)
|
||||
{
|
||||
char buf[256];
|
||||
sprintf(buf, "%s on line #%ld", s, ln_);
|
||||
throw std::runtime_error(buf);
|
||||
}
|
||||
|
||||
inline std::string trim(const std::string& s)
|
||||
inline std::string trim(const std::string &s)
|
||||
{
|
||||
char p[] = " \t\r\n";
|
||||
long sp = 0;
|
||||
long ep = s.length() - 1;
|
||||
for (; sp <= ep; ++sp)
|
||||
if (!strchr(p, s[sp])) break;
|
||||
if (!strchr(p, s[sp]))
|
||||
break;
|
||||
for (; ep >= 0; --ep)
|
||||
if (!strchr(p, s[ep])) break;
|
||||
return s.substr(sp, ep-sp+1);
|
||||
if (!strchr(p, s[ep]))
|
||||
break;
|
||||
return s.substr(sp, ep - sp + 1);
|
||||
}
|
||||
|
||||
inline
|
||||
Parser::Parser(const char* fn) : f0_(fn), f_(&f0_), ln_(0)
|
||||
inline Parser::Parser(const char *fn) : f0_(fn), f_(&f0_), ln_(0)
|
||||
{
|
||||
if (!f0_)
|
||||
throw std::runtime_error(std::string("failed to open file: ") + fn);
|
||||
@ -107,56 +108,63 @@ Parser::Parser(const char* fn) : f0_(fn), f_(&f0_), ln_(0)
|
||||
parse(top_);
|
||||
}
|
||||
|
||||
inline void
|
||||
Parser::parseSLine(std::string& sname, size_t& depth)
|
||||
inline void Parser::parseSLine(std::string &sname, size_t &depth)
|
||||
{
|
||||
depth = 0;
|
||||
for (; depth < line_.length(); ++depth)
|
||||
if (line_[depth] != '[') break;
|
||||
if (line_[depth] != '[')
|
||||
break;
|
||||
|
||||
sname = line_.substr(depth, line_.length() - 2*depth);
|
||||
sname = line_.substr(depth, line_.length() - 2 * depth);
|
||||
}
|
||||
|
||||
inline void
|
||||
Parser::parse(Level& l)
|
||||
inline void Parser::parse(Level &l)
|
||||
{
|
||||
while (std::getline(*f_, line_)) {
|
||||
while (std::getline(*f_, line_))
|
||||
{
|
||||
++ln_;
|
||||
if (line_[0] == '#' || line_[0] == ';') continue;
|
||||
if (line_[0] == '#' || line_[0] == ';')
|
||||
continue;
|
||||
line_ = trim(line_);
|
||||
if (line_.empty()) continue;
|
||||
if (line_[0] == '[') {
|
||||
if (line_.empty())
|
||||
continue;
|
||||
if (line_[0] == '[')
|
||||
{
|
||||
size_t depth;
|
||||
std::string sname;
|
||||
parseSLine(sname, depth);
|
||||
Level* lp = NULL;
|
||||
Level* parent = &l;
|
||||
Level *lp = NULL;
|
||||
Level *parent = &l;
|
||||
if (depth > l.depth + 1)
|
||||
err("section with wrong depth");
|
||||
if (l.depth == depth-1)
|
||||
if (l.depth == depth - 1)
|
||||
lp = &l.sections[sname];
|
||||
else {
|
||||
else
|
||||
{
|
||||
lp = l.parent;
|
||||
size_t n = l.depth - depth;
|
||||
for (size_t i = 0; i < n; ++i) lp = lp->parent;
|
||||
for (size_t i = 0; i < n; ++i)
|
||||
lp = lp->parent;
|
||||
parent = lp;
|
||||
lp = &lp->sections[sname];
|
||||
}
|
||||
if (lp->depth != 0)
|
||||
err("duplicate section name on the same level");
|
||||
if (!lp->parent) {
|
||||
if (!lp->parent)
|
||||
{
|
||||
lp->depth = depth;
|
||||
lp->parent = parent;
|
||||
}
|
||||
parent->ordered_sections.push_back(parent->sections.find(sname));
|
||||
parse(*lp);
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t n = line_.find('=');
|
||||
if (n == std::string::npos)
|
||||
err("no '=' found");
|
||||
std::pair<Level::value_map_t::const_iterator, bool> res =
|
||||
l.values.insert(std::make_pair(trim(line_.substr(0, n)),
|
||||
trim(line_.substr(n+1, line_.length()-n-1))));
|
||||
l.values.insert(std::make_pair(trim(line_.substr(0, n)), trim(line_.substr(n + 1, line_.length() - n - 1))));
|
||||
if (!res.second)
|
||||
err("duplicated key found");
|
||||
l.ordered_values.push_back(res.first);
|
||||
@ -164,23 +172,26 @@ Parser::parse(Level& l)
|
||||
}
|
||||
}
|
||||
|
||||
inline void
|
||||
Parser::dump(std::ostream& s, const Level& l, const std::string& sname)
|
||||
inline void Parser::dump(std::ostream &s, const Level &l, const std::string &sname)
|
||||
{
|
||||
if (!sname.empty()) s << '\n';
|
||||
for (size_t i = 0; i < l.depth; ++i) s << '[';
|
||||
if (!sname.empty()) s << sname;
|
||||
for (size_t i = 0; i < l.depth; ++i) s << ']';
|
||||
if (!sname.empty()) s << std::endl;
|
||||
if (!sname.empty())
|
||||
s << '\n';
|
||||
for (size_t i = 0; i < l.depth; ++i)
|
||||
s << '[';
|
||||
if (!sname.empty())
|
||||
s << sname;
|
||||
for (size_t i = 0; i < l.depth; ++i)
|
||||
s << ']';
|
||||
if (!sname.empty())
|
||||
s << std::endl;
|
||||
for (Level::values_t::const_iterator it = l.ordered_values.begin(); it != l.ordered_values.end(); ++it)
|
||||
s << (*it)->first << '=' << (*it)->second << std::endl;
|
||||
for (Level::sections_t::const_iterator it = l.ordered_sections.begin(); it != l.ordered_sections.end(); ++it) {
|
||||
assert((*it)->second.depth == l.depth+1);
|
||||
for (Level::sections_t::const_iterator it = l.ordered_sections.begin(); it != l.ordered_sections.end(); ++it)
|
||||
{
|
||||
assert((*it)->second.depth == l.depth + 1);
|
||||
dump(s, (*it)->second, (*it)->first);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif // INI_HPP
|
||||
|
||||
|
@ -1,18 +1,19 @@
|
||||
#include "ini.hpp"
|
||||
|
||||
#include <nntpchan/crypto.hpp>
|
||||
#include <nntpchan/storage.hpp>
|
||||
#include <nntpchan/nntp_server.hpp>
|
||||
#include <nntpchan/event.hpp>
|
||||
#include <nntpchan/exec_frontend.hpp>
|
||||
#include <nntpchan/nntp_server.hpp>
|
||||
#include <nntpchan/staticfile_frontend.hpp>
|
||||
#include <nntpchan/storage.hpp>
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
|
||||
int main(int argc, char * argv[]) {
|
||||
if (argc != 2) {
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
if (argc != 2)
|
||||
{
|
||||
std::cerr << "usage: " << argv[0] << " config.ini" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
@ -23,57 +24,63 @@ int main(int argc, char * argv[]) {
|
||||
|
||||
nntpchan::NNTPServer nntp(loop);
|
||||
|
||||
|
||||
std::string fname(argv[1]);
|
||||
|
||||
std::ifstream i(fname);
|
||||
|
||||
if(i.is_open()) {
|
||||
if (i.is_open())
|
||||
{
|
||||
INI::Parser conf(i);
|
||||
|
||||
std::vector<std::string> requiredSections = {"nntp", "articles"};
|
||||
|
||||
auto & level = conf.top();
|
||||
auto &level = conf.top();
|
||||
|
||||
for ( const auto & section : requiredSections ) {
|
||||
if(level.sections.find(section) == level.sections.end()) {
|
||||
for (const auto §ion : requiredSections)
|
||||
{
|
||||
if (level.sections.find(section) == level.sections.end())
|
||||
{
|
||||
std::cerr << "config file " << fname << " does not have required section: ";
|
||||
std::cerr << section << std::endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
auto & storeconf = level.sections["articles"].values;
|
||||
auto &storeconf = level.sections["articles"].values;
|
||||
|
||||
if (storeconf.find("store_path") == storeconf.end()) {
|
||||
if (storeconf.find("store_path") == storeconf.end())
|
||||
{
|
||||
std::cerr << "storage section does not have 'store_path' value" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
nntp.SetStoragePath(storeconf["store_path"]);
|
||||
|
||||
auto & nntpconf = level.sections["nntp"].values;
|
||||
auto &nntpconf = level.sections["nntp"].values;
|
||||
|
||||
if (nntpconf.find("bind") == nntpconf.end()) {
|
||||
if (nntpconf.find("bind") == nntpconf.end())
|
||||
{
|
||||
std::cerr << "nntp section does not have 'bind' value" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if(nntpconf.find("instance_name") == nntpconf.end()) {
|
||||
if (nntpconf.find("instance_name") == nntpconf.end())
|
||||
{
|
||||
std::cerr << "nntp section lacks 'instance_name' value" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
nntp.SetInstanceName(nntpconf["instance_name"]);
|
||||
|
||||
if (nntpconf.find("authdb") != nntpconf.end()) {
|
||||
if (nntpconf.find("authdb") != nntpconf.end())
|
||||
{
|
||||
nntp.SetLoginDB(nntpconf["authdb"]);
|
||||
}
|
||||
|
||||
if ( level.sections.find("frontend") != level.sections.end())
|
||||
if (level.sections.find("frontend") != level.sections.end())
|
||||
{
|
||||
// frontend enabled
|
||||
auto & frontconf = level.sections["frontend"].values;
|
||||
auto &frontconf = level.sections["frontend"].values;
|
||||
if (frontconf.find("type") == frontconf.end())
|
||||
{
|
||||
std::cerr << "frontend section provided but 'type' value not provided" << std::endl;
|
||||
@ -91,38 +98,38 @@ int main(int argc, char * argv[]) {
|
||||
}
|
||||
else if (ftype == "staticfile")
|
||||
{
|
||||
auto required = {
|
||||
"template_dir", "out_dir", "template_dialect", "max_pages"
|
||||
};
|
||||
for (const auto & opt : required)
|
||||
auto required = {"template_dir", "out_dir", "template_dialect", "max_pages"};
|
||||
for (const auto &opt : required)
|
||||
{
|
||||
if(frontconf.find(opt) == frontconf.end())
|
||||
if (frontconf.find(opt) == frontconf.end())
|
||||
{
|
||||
std::cerr << "staticfile frontend specified but no '" << opt << "' value provided" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
auto maxPages = std::stoi(frontconf["max_pages"]);
|
||||
if(maxPages <= 0)
|
||||
if (maxPages <= 0)
|
||||
{
|
||||
std::cerr << "max_pages invalid value '" << frontconf["max_pages"] << "'" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
nntp.SetFrontend(new nntpchan::StaticFileFrontend(nntpchan::CreateTemplateEngine(frontconf["template_dialect"]), frontconf["template_dir"], frontconf["out_dir"], maxPages));
|
||||
nntp.SetFrontend(new nntpchan::StaticFileFrontend(nntpchan::CreateTemplateEngine(frontconf["template_dialect"]),
|
||||
frontconf["template_dir"], frontconf["out_dir"], maxPages));
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr << "unknown frontend type '" << ftype << "'" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
auto & a = nntpconf["bind"];
|
||||
auto &a = nntpconf["bind"];
|
||||
|
||||
try {
|
||||
try
|
||||
{
|
||||
nntp.Bind(a);
|
||||
} catch ( std::exception & ex ) {
|
||||
} catch (std::exception &ex)
|
||||
{
|
||||
std::cerr << "failed to bind: " << ex.what() << std::endl;
|
||||
return 1;
|
||||
}
|
||||
@ -130,11 +137,10 @@ int main(int argc, char * argv[]) {
|
||||
std::cerr << "nntpd for " << nntp.InstanceName() << " bound to " << a << std::endl;
|
||||
|
||||
loop.Run();
|
||||
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cerr << "failed to open " << fname << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
@ -5,13 +5,11 @@
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
/** returns base64 encoded string */
|
||||
std::string B64Encode(const uint8_t * data, const std::size_t l);
|
||||
|
||||
/** @brief returns true if decode was successful */
|
||||
bool B64Decode(const std::string & data, std::vector<uint8_t> & out);
|
||||
/** returns base64 encoded string */
|
||||
std::string B64Encode(const uint8_t *data, const std::size_t l);
|
||||
|
||||
/** @brief returns true if decode was successful */
|
||||
bool B64Decode(const std::string &data, std::vector<uint8_t> &out);
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -1,19 +1,19 @@
|
||||
#ifndef NNTPCHAN_BUFFER_HPP
|
||||
#define NNTPCHAN_BUFFER_HPP
|
||||
#include <uv.h>
|
||||
#include <string>
|
||||
#include <uv.h>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
struct WriteBuffer
|
||||
{
|
||||
struct WriteBuffer
|
||||
{
|
||||
uv_write_t w;
|
||||
uv_buf_t b;
|
||||
|
||||
WriteBuffer(const std::string & s);
|
||||
WriteBuffer(const char * b, const size_t s);
|
||||
WriteBuffer(const std::string &s);
|
||||
WriteBuffer(const char *b, const size_t s);
|
||||
~WriteBuffer();
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,22 +1,21 @@
|
||||
#ifndef NNTPCHAN_CRYPTO_HPP
|
||||
#define NNTPCHAN_CRYPTO_HPP
|
||||
|
||||
#include <sodium/crypto_hash.h>
|
||||
#include <array>
|
||||
#include <sodium/crypto_hash.h>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
typedef std::array<uint8_t, crypto_hash_BYTES> SHA512Digest;
|
||||
typedef std::array<uint8_t, crypto_hash_BYTES> SHA512Digest;
|
||||
|
||||
void SHA512(const uint8_t * d, std::size_t l, SHA512Digest & h);
|
||||
void SHA512(const uint8_t *d, std::size_t l, SHA512Digest &h);
|
||||
|
||||
/** global crypto initializer */
|
||||
struct Crypto
|
||||
{
|
||||
/** global crypto initializer */
|
||||
struct Crypto
|
||||
{
|
||||
Crypto();
|
||||
~Crypto();
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -4,23 +4,20 @@
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
class Mainloop
|
||||
{
|
||||
public:
|
||||
|
||||
class Mainloop
|
||||
{
|
||||
public:
|
||||
Mainloop();
|
||||
~Mainloop();
|
||||
|
||||
operator uv_loop_t * () const { return m_loop; }
|
||||
operator uv_loop_t *() const { return m_loop; }
|
||||
|
||||
void Run(uv_run_mode mode = UV_RUN_DEFAULT);
|
||||
void Stop();
|
||||
|
||||
private:
|
||||
|
||||
uv_loop_t * m_loop;
|
||||
|
||||
};
|
||||
private:
|
||||
uv_loop_t *m_loop;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -5,26 +5,23 @@
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
class ExecFrontend : public Frontend
|
||||
{
|
||||
public:
|
||||
|
||||
ExecFrontend(const std::string & exe);
|
||||
class ExecFrontend : public Frontend
|
||||
{
|
||||
public:
|
||||
ExecFrontend(const std::string &exe);
|
||||
|
||||
~ExecFrontend();
|
||||
|
||||
void ProcessNewMessage(const fs::path & fpath);
|
||||
bool AcceptsNewsgroup(const std::string & newsgroup);
|
||||
bool AcceptsMessage(const std::string & msgid);
|
||||
|
||||
private:
|
||||
void ProcessNewMessage(const fs::path &fpath);
|
||||
bool AcceptsNewsgroup(const std::string &newsgroup);
|
||||
bool AcceptsMessage(const std::string &msgid);
|
||||
|
||||
private:
|
||||
int Exec(std::deque<std::string> args);
|
||||
|
||||
private:
|
||||
private:
|
||||
std::string m_exec;
|
||||
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,23 +1,23 @@
|
||||
#ifndef NNTPCHAN_FILE_HANDLE_HPP
|
||||
#define NNTPCHAN_FILE_HANDLE_HPP
|
||||
|
||||
#include <memory>
|
||||
#include <fstream>
|
||||
#include <experimental/filesystem>
|
||||
#include <fstream>
|
||||
#include <memory>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
typedef std::unique_ptr<std::fstream> FileHandle_ptr;
|
||||
typedef std::unique_ptr<std::fstream> FileHandle_ptr;
|
||||
|
||||
enum FileMode
|
||||
{
|
||||
enum FileMode
|
||||
{
|
||||
eRead,
|
||||
eWrite
|
||||
};
|
||||
};
|
||||
|
||||
namespace fs = std::experimental::filesystem;
|
||||
namespace fs = std::experimental::filesystem;
|
||||
|
||||
FileHandle_ptr OpenFile(const fs::path & fname, FileMode mode);
|
||||
FileHandle_ptr OpenFile(const fs::path &fname, FileMode mode);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,29 +1,27 @@
|
||||
#ifndef NNTPCHAN_FRONTEND_HPP
|
||||
#define NNTPCHAN_FRONTEND_HPP
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <experimental/filesystem>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
namespace fs = std::experimental::filesystem;
|
||||
/** @brief nntpchan frontend ui interface */
|
||||
class Frontend
|
||||
{
|
||||
public:
|
||||
|
||||
namespace fs = std::experimental::filesystem;
|
||||
/** @brief nntpchan frontend ui interface */
|
||||
class Frontend
|
||||
{
|
||||
public:
|
||||
/** @brief process an inbound message stored at fpath that we have accepted. */
|
||||
virtual void ProcessNewMessage(const fs::path & fpath) = 0;
|
||||
virtual void ProcessNewMessage(const fs::path &fpath) = 0;
|
||||
|
||||
/** @brief return true if we take posts in a newsgroup */
|
||||
virtual bool AcceptsNewsgroup(const std::string & newsgroup) = 0;
|
||||
virtual bool AcceptsNewsgroup(const std::string &newsgroup) = 0;
|
||||
|
||||
/** @brief return true if we will accept a message given its message-id */
|
||||
virtual bool AcceptsMessage(const std::string & msgid) = 0;
|
||||
virtual bool AcceptsMessage(const std::string &msgid) = 0;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
typedef std::unique_ptr<Frontend> Frontend_ptr;
|
||||
typedef std::unique_ptr<Frontend> Frontend_ptr;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,6 +1,4 @@
|
||||
#ifndef NNTPCHAN_HTTP_HPP
|
||||
#define NNTPCHAN_HTTP_HPP
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -1,5 +1,4 @@
|
||||
#ifndef NNTPCHAN_HTTP_CLIENT_HPP
|
||||
#define NNTPCHAN_HTTP_CLIENT_HPP
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -1,6 +1,4 @@
|
||||
#ifndef NNTPCHAN_HTTP_SERVER_HPP
|
||||
#define NNTPCHAN_HTTP_SERVER_HPP
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -1,12 +1,11 @@
|
||||
#ifndef NNTPCHAN_IO_HANDLE_HPP
|
||||
#define NNTPCHAN_IO_HANDLE_HPP
|
||||
#include <memory>
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
typedef std::unique_ptr<std::iostream> IOHandle_ptr;
|
||||
|
||||
typedef std::unique_ptr<std::iostream> IOHandle_ptr;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -5,30 +5,28 @@
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
/** @brief a buffered line reader */
|
||||
class LineReader
|
||||
{
|
||||
public:
|
||||
|
||||
/** @brief a buffered line reader */
|
||||
class LineReader
|
||||
{
|
||||
public:
|
||||
LineReader(size_t lineLimit);
|
||||
|
||||
/** @brief queue inbound data from connection */
|
||||
void Data(const char * data, ssize_t s);
|
||||
void Data(const char *data, ssize_t s);
|
||||
|
||||
/** implements IConnHandler */
|
||||
virtual bool ShouldClose();
|
||||
|
||||
protected:
|
||||
protected:
|
||||
/** @brief handle a line from the client */
|
||||
virtual void HandleLine(const std::string & line) = 0;
|
||||
virtual void HandleLine(const std::string &line) = 0;
|
||||
|
||||
|
||||
private:
|
||||
void OnLine(const char * d, const size_t l);
|
||||
private:
|
||||
void OnLine(const char *d, const size_t l);
|
||||
std::string m_leftovers;
|
||||
bool m_close;
|
||||
const size_t lineLimit;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -6,16 +6,16 @@
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
struct MessageDB
|
||||
{
|
||||
struct MessageDB
|
||||
{
|
||||
using BoardPage = nntpchan::model::BoardPage;
|
||||
using Thread = nntpchan::model::Thread;
|
||||
virtual bool LoadBoardPage(BoardPage & board, const std::string & newsgroup, uint32_t perpage, uint32_t page) const = 0;
|
||||
virtual bool FindThreadByHash(const std::string & hashhex, std::string & msgid) const = 0;
|
||||
virtual bool LoadThread(Thread & thread, const std::string & rootmsgid) const = 0;
|
||||
};
|
||||
virtual bool LoadBoardPage(BoardPage &board, const std::string &newsgroup, uint32_t perpage, uint32_t page) const = 0;
|
||||
virtual bool FindThreadByHash(const std::string &hashhex, std::string &msgid) const = 0;
|
||||
virtual bool LoadThread(Thread &thread, const std::string &rootmsgid) const = 0;
|
||||
};
|
||||
|
||||
typedef std::unique_ptr<MessageDB> MessageDB_ptr;
|
||||
typedef std::unique_ptr<MessageDB> MessageDB_ptr;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -9,22 +9,21 @@
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
typedef std::map<std::string, std::string> RawHeader;
|
||||
typedef std::map<std::string, std::string> RawHeader;
|
||||
|
||||
bool ReadHeader(const FileHandle_ptr & f, RawHeader & h);
|
||||
bool ReadHeader(const FileHandle_ptr &f, RawHeader &h);
|
||||
|
||||
|
||||
struct MimePart
|
||||
{
|
||||
virtual RawHeader & Header() = 0;
|
||||
struct MimePart
|
||||
{
|
||||
virtual RawHeader &Header() = 0;
|
||||
virtual IOHandle_ptr OpenPart() = 0;
|
||||
};
|
||||
};
|
||||
|
||||
typedef std::unique_ptr<MimePart> MimePart_ptr;
|
||||
typedef std::unique_ptr<MimePart> MimePart_ptr;
|
||||
|
||||
typedef std::function<bool(MimePart_ptr)> PartReader;
|
||||
typedef std::function<bool(MimePart_ptr)> PartReader;
|
||||
|
||||
bool ReadParts(const FileHandle_ptr & f, PartReader r);
|
||||
bool ReadParts(const FileHandle_ptr &f, PartReader r);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -2,74 +2,58 @@
|
||||
#define NNTPCHAN_MODEL_HPP
|
||||
#include <algorithm>
|
||||
#include <map>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
#include <variant>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <vector>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
namespace model
|
||||
{
|
||||
// MIME Header
|
||||
typedef std::map<std::string, std::vector<std::string> > PostHeader;
|
||||
// text post contents
|
||||
typedef std::string PostBody;
|
||||
// single file attachment, (orig_filename, hexdigest, thumb_filename)
|
||||
typedef std::tuple<std::string, std::string, std::string> PostAttachment;
|
||||
// all attachments on a post
|
||||
typedef std::vector<PostAttachment> Attachments;
|
||||
// a post (header, Post Text, Attachments)
|
||||
typedef std::tuple<PostHeader, PostBody, Attachments> Post;
|
||||
// a thread (many posts in post order)
|
||||
typedef std::vector<Post> Thread;
|
||||
// a board page is many threads in bump order
|
||||
typedef std::vector<Thread> BoardPage;
|
||||
namespace model
|
||||
{
|
||||
// MIME Header
|
||||
typedef std::map<std::string, std::vector<std::string>> PostHeader;
|
||||
// text post contents
|
||||
typedef std::string PostBody;
|
||||
// single file attachment, (orig_filename, hexdigest, thumb_filename)
|
||||
typedef std::tuple<std::string, std::string, std::string> PostAttachment;
|
||||
// all attachments on a post
|
||||
typedef std::vector<PostAttachment> Attachments;
|
||||
// a post (header, Post Text, Attachments)
|
||||
typedef std::tuple<PostHeader, PostBody, Attachments> Post;
|
||||
// a thread (many posts in post order)
|
||||
typedef std::vector<Post> Thread;
|
||||
// a board page is many threads in bump order
|
||||
typedef std::vector<Thread> BoardPage;
|
||||
|
||||
static inline const std::string & GetFilename(const PostAttachment & att)
|
||||
{
|
||||
return std::get<0>(att);
|
||||
}
|
||||
static inline const std::string &GetFilename(const PostAttachment &att) { return std::get<0>(att); }
|
||||
|
||||
static inline const std::string & GetHexDigest(const PostAttachment & att)
|
||||
{
|
||||
return std::get<1>(att);
|
||||
}
|
||||
static inline const std::string &GetHexDigest(const PostAttachment &att) { return std::get<1>(att); }
|
||||
|
||||
static inline const std::string & GetThumbnail(const PostAttachment & att)
|
||||
{
|
||||
return std::get<2>(att);
|
||||
}
|
||||
static inline const std::string &GetThumbnail(const PostAttachment &att) { return std::get<2>(att); }
|
||||
|
||||
static inline const PostHeader & GetHeader(const Post & post)
|
||||
{
|
||||
return std::get<0>(post);
|
||||
}
|
||||
static inline const PostHeader &GetHeader(const Post &post) { return std::get<0>(post); }
|
||||
|
||||
static inline const PostBody & GetBody(const Post & post)
|
||||
{
|
||||
return std::get<1>(post);
|
||||
}
|
||||
static inline const PostBody &GetBody(const Post &post) { return std::get<1>(post); }
|
||||
|
||||
static inline const Attachments & GetAttachments(const Post & post)
|
||||
{
|
||||
return std::get<2>(post);
|
||||
}
|
||||
static inline const Attachments &GetAttachments(const Post &post) { return std::get<2>(post); }
|
||||
|
||||
static inline const std::string & HeaderIFind(const PostHeader & header, const std::string & val, const std::string & fallback)
|
||||
{
|
||||
static inline const std::string &HeaderIFind(const PostHeader &header, const std::string &val,
|
||||
const std::string &fallback)
|
||||
{
|
||||
std::string ival = ToLower(val);
|
||||
auto itr = std::find_if(header.begin(), header.end(), [ival](const auto & item) -> bool { return ToLower(item.first) == ival; });
|
||||
auto itr = std::find_if(header.begin(), header.end(),
|
||||
[ival](const auto &item) -> bool { return ToLower(item.first) == ival; });
|
||||
if (itr == std::end(header))
|
||||
return fallback;
|
||||
else
|
||||
return itr->second[0];
|
||||
}
|
||||
}
|
||||
|
||||
using Model = std::variant<Thread, BoardPage>;
|
||||
}
|
||||
using Model = std::variant<Thread, BoardPage>;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,23 +1,23 @@
|
||||
#ifndef NNTPCHAN_NET_HPP
|
||||
#define NNTPCHAN_NET_HPP
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <netinet/in.h>
|
||||
#include <string>
|
||||
#include <sys/types.h>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
struct NetAddr
|
||||
{
|
||||
struct NetAddr
|
||||
{
|
||||
NetAddr();
|
||||
|
||||
sockaddr_in6 addr;
|
||||
operator sockaddr * () { return (sockaddr *) &addr; }
|
||||
operator const sockaddr * () const { return (sockaddr *) &addr; }
|
||||
operator sockaddr *() { return (sockaddr *)&addr; }
|
||||
operator const sockaddr *() const { return (sockaddr *)&addr; }
|
||||
std::string to_string();
|
||||
};
|
||||
};
|
||||
|
||||
NetAddr ParseAddr(const std::string & addr);
|
||||
NetAddr ParseAddr(const std::string &addr);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,61 +1,64 @@
|
||||
#ifndef NNTPCHAN_NNTP_AUTH_HPP
|
||||
#define NNTPCHAN_NNTP_AUTH_HPP
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <mutex>
|
||||
#include <memory>
|
||||
#include "line.hpp"
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
/** @brief nntp credential db interface */
|
||||
class NNTPCredentialDB
|
||||
{
|
||||
public:
|
||||
/** @brief nntp credential db interface */
|
||||
class NNTPCredentialDB
|
||||
{
|
||||
public:
|
||||
/** @brief open connection to database, return false on error otherwise return true */
|
||||
virtual bool Open() = 0;
|
||||
/** @brief close connection to database */
|
||||
virtual void Close() = 0;
|
||||
/** @brief return true if username password combo is correct */
|
||||
virtual bool CheckLogin(const std::string & user, const std::string & passwd) = 0;
|
||||
virtual bool CheckLogin(const std::string &user, const std::string &passwd) = 0;
|
||||
virtual ~NNTPCredentialDB() {}
|
||||
};
|
||||
};
|
||||
|
||||
typedef std::shared_ptr<NNTPCredentialDB> CredDB_ptr;
|
||||
typedef std::shared_ptr<NNTPCredentialDB> CredDB_ptr;
|
||||
|
||||
/** @brief nntp credential db using hashed+salted passwords */
|
||||
class HashedCredDB : public NNTPCredentialDB, public LineReader
|
||||
{
|
||||
public:
|
||||
/** @brief nntp credential db using hashed+salted passwords */
|
||||
class HashedCredDB : public NNTPCredentialDB, public LineReader
|
||||
{
|
||||
public:
|
||||
HashedCredDB();
|
||||
bool CheckLogin(const std::string & user, const std::string & passwd);
|
||||
protected:
|
||||
void SetStream(std::istream * i);
|
||||
bool CheckLogin(const std::string &user, const std::string &passwd);
|
||||
|
||||
std::string Hash(const std::string & data, const std::string & salt);
|
||||
void HandleLine(const std::string & line);
|
||||
private:
|
||||
bool ProcessLine(const std::string & line);
|
||||
protected:
|
||||
void SetStream(std::istream *i);
|
||||
|
||||
std::string Hash(const std::string &data, const std::string &salt);
|
||||
void HandleLine(const std::string &line);
|
||||
|
||||
private:
|
||||
bool ProcessLine(const std::string &line);
|
||||
|
||||
std::mutex m_access;
|
||||
std::string m_user, m_passwd;
|
||||
bool m_found;
|
||||
/** return true if we have a line that matches this username / password combo */
|
||||
std::istream * m_instream;
|
||||
};
|
||||
std::istream *m_instream;
|
||||
};
|
||||
|
||||
class HashedFileDB : public HashedCredDB
|
||||
{
|
||||
public:
|
||||
HashedFileDB(const std::string & fname);
|
||||
class HashedFileDB : public HashedCredDB
|
||||
{
|
||||
public:
|
||||
HashedFileDB(const std::string &fname);
|
||||
~HashedFileDB();
|
||||
bool Open();
|
||||
void Close();
|
||||
private:
|
||||
|
||||
private:
|
||||
std::string m_fname;
|
||||
std::ifstream f;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,17 +1,17 @@
|
||||
#ifndef NNTPCHAN_NNTP_HANDLER_HPP
|
||||
#define NNTPCHAN_NNTP_HANDLER_HPP
|
||||
#include <deque>
|
||||
#include <string>
|
||||
#include "line.hpp"
|
||||
#include "nntp_auth.hpp"
|
||||
#include "storage.hpp"
|
||||
#include <deque>
|
||||
#include <string>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
class NNTPServerHandler : public LineReader, public IConnHandler
|
||||
{
|
||||
public:
|
||||
NNTPServerHandler(const fs::path & storage);
|
||||
class NNTPServerHandler : public LineReader, public IConnHandler
|
||||
{
|
||||
public:
|
||||
NNTPServerHandler(const fs::path &storage);
|
||||
~NNTPServerHandler();
|
||||
|
||||
virtual bool ShouldClose();
|
||||
@ -22,19 +22,19 @@ namespace nntpchan
|
||||
|
||||
void Greet();
|
||||
|
||||
protected:
|
||||
void HandleLine(const std::string & line);
|
||||
void HandleCommand(const std::deque<std::string> & command);
|
||||
private:
|
||||
protected:
|
||||
void HandleLine(const std::string &line);
|
||||
void HandleCommand(const std::deque<std::string> &command);
|
||||
|
||||
enum State {
|
||||
private:
|
||||
enum State
|
||||
{
|
||||
eStateReadCommand,
|
||||
eStateStoreArticle,
|
||||
eStateQuit
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
private:
|
||||
void EnterState(State st);
|
||||
|
||||
void ArticleObtained();
|
||||
@ -43,11 +43,11 @@ namespace nntpchan
|
||||
void Quit();
|
||||
|
||||
// switch nntp modes, this queues a reply
|
||||
void SwitchMode(const std::string & mode);
|
||||
void SwitchMode(const std::string &mode);
|
||||
|
||||
bool PostingAllowed();
|
||||
|
||||
private:
|
||||
private:
|
||||
std::string m_articleName;
|
||||
FileHandle_ptr m_article;
|
||||
CredDB_ptr m_auth;
|
||||
@ -55,8 +55,7 @@ namespace nntpchan
|
||||
std::string m_mode;
|
||||
bool m_authed;
|
||||
State m_state;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -1,53 +1,49 @@
|
||||
#ifndef NNTPCHAN_NNTP_SERVER_HPP
|
||||
#define NNTPCHAN_NNTP_SERVER_HPP
|
||||
#include <uv.h>
|
||||
#include <string>
|
||||
#include <deque>
|
||||
#include "frontend.hpp"
|
||||
#include "server.hpp"
|
||||
#include <deque>
|
||||
#include <string>
|
||||
#include <uv.h>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
class NNTPServer : public Server
|
||||
{
|
||||
public:
|
||||
|
||||
NNTPServer(uv_loop_t * loop);
|
||||
class NNTPServer : public Server
|
||||
{
|
||||
public:
|
||||
NNTPServer(uv_loop_t *loop);
|
||||
|
||||
virtual ~NNTPServer();
|
||||
|
||||
void SetStoragePath(const std::string & path);
|
||||
void SetStoragePath(const std::string &path);
|
||||
|
||||
void SetLoginDB(const std::string path);
|
||||
|
||||
void SetInstanceName(const std::string & name);
|
||||
void SetInstanceName(const std::string &name);
|
||||
|
||||
std::string InstanceName() const;
|
||||
|
||||
void Close();
|
||||
|
||||
virtual IServerConn * CreateConn(uv_stream_t * s);
|
||||
virtual IServerConn *CreateConn(uv_stream_t *s);
|
||||
|
||||
virtual void OnAcceptError(int status);
|
||||
|
||||
void SetFrontend(Frontend * f);
|
||||
|
||||
private:
|
||||
void SetFrontend(Frontend *f);
|
||||
|
||||
private:
|
||||
std::string m_logindbpath;
|
||||
std::string m_storagePath;
|
||||
std::string m_servername;
|
||||
|
||||
Frontend_ptr m_frontend;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
class NNTPServerConn : public IServerConn
|
||||
{
|
||||
public:
|
||||
|
||||
NNTPServerConn(uv_loop_t * l, uv_stream_t * s, Server * parent, IConnHandler * h) : IServerConn(l, s, parent, h) {}
|
||||
class NNTPServerConn : public IServerConn
|
||||
{
|
||||
public:
|
||||
NNTPServerConn(uv_loop_t *l, uv_stream_t *s, Server *parent, IConnHandler *h) : IServerConn(l, s, parent, h) {}
|
||||
|
||||
virtual bool IsTimedOut() { return false; };
|
||||
|
||||
@ -55,8 +51,7 @@ namespace nntpchan
|
||||
virtual void SendNextReply();
|
||||
|
||||
virtual void Greet();
|
||||
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -4,11 +4,11 @@
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
std::string NNTPSanitizeLine(const std::string & str);
|
||||
std::string ToLower(const std::string & str);
|
||||
std::string StripWhitespaces(const std::string & str);
|
||||
bool IsValidMessageID(const std::string & msgid);
|
||||
bool IsValidNewsgroup(const std::string & group);
|
||||
std::string NNTPSanitizeLine(const std::string &str);
|
||||
std::string ToLower(const std::string &str);
|
||||
std::string StripWhitespaces(const std::string &str);
|
||||
bool IsValidMessageID(const std::string &msgid);
|
||||
bool IsValidNewsgroup(const std::string &group);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,23 +1,22 @@
|
||||
#ifndef NNTPCHAN_SERVER_HPP
|
||||
#define NNTPCHAN_SERVER_HPP
|
||||
#include <uv.h>
|
||||
#include <deque>
|
||||
#include <functional>
|
||||
#include <string>
|
||||
#include <uv.h>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
class Server;
|
||||
class Server;
|
||||
|
||||
struct IConnHandler
|
||||
{
|
||||
|
||||
struct IConnHandler
|
||||
{
|
||||
|
||||
virtual ~IConnHandler() {};
|
||||
virtual ~IConnHandler(){};
|
||||
|
||||
/** got inbound data */
|
||||
virtual void OnData(const char * data, ssize_t s) = 0;
|
||||
virtual void OnData(const char *data, ssize_t s) = 0;
|
||||
|
||||
/** get next line of data to send */
|
||||
std::string GetNextLine();
|
||||
@ -29,47 +28,47 @@ namespace nntpchan
|
||||
virtual bool ShouldClose() = 0;
|
||||
|
||||
/** queue a data send */
|
||||
void QueueLine(const std::string & line);
|
||||
void QueueLine(const std::string &line);
|
||||
|
||||
virtual void Greet() = 0;
|
||||
|
||||
|
||||
private:
|
||||
private:
|
||||
std::deque<std::string> m_sendlines;
|
||||
};
|
||||
};
|
||||
|
||||
/** server connection handler interface */
|
||||
struct IServerConn
|
||||
{
|
||||
IServerConn(uv_loop_t * l, uv_stream_t * s, Server * parent, IConnHandler * h);
|
||||
/** server connection handler interface */
|
||||
struct IServerConn
|
||||
{
|
||||
IServerConn(uv_loop_t *l, uv_stream_t *s, Server *parent, IConnHandler *h);
|
||||
virtual ~IServerConn();
|
||||
virtual void Close();
|
||||
virtual void Greet() = 0;
|
||||
virtual void SendNextReply() = 0;
|
||||
virtual bool IsTimedOut() = 0;
|
||||
void SendString(const std::string & str);
|
||||
Server * Parent() { return m_parent; };
|
||||
IConnHandler * GetHandler() { return m_handler; };
|
||||
uv_loop_t * GetLoop() { return m_loop; };
|
||||
private:
|
||||
uv_tcp_t m_conn;
|
||||
uv_loop_t * m_loop;
|
||||
Server * m_parent;
|
||||
IConnHandler * m_handler;
|
||||
};
|
||||
void SendString(const std::string &str);
|
||||
Server *Parent() { return m_parent; };
|
||||
IConnHandler *GetHandler() { return m_handler; };
|
||||
uv_loop_t *GetLoop() { return m_loop; };
|
||||
|
||||
class Server
|
||||
{
|
||||
public:
|
||||
Server(uv_loop_t * loop);
|
||||
private:
|
||||
uv_tcp_t m_conn;
|
||||
uv_loop_t *m_loop;
|
||||
Server *m_parent;
|
||||
IConnHandler *m_handler;
|
||||
};
|
||||
|
||||
class Server
|
||||
{
|
||||
public:
|
||||
Server(uv_loop_t *loop);
|
||||
/** called after socket close, NEVER call directly */
|
||||
virtual ~Server() {}
|
||||
/** create connection handler from open stream */
|
||||
virtual IServerConn * CreateConn(uv_stream_t * s) = 0;
|
||||
virtual IServerConn *CreateConn(uv_stream_t *s) = 0;
|
||||
/** close all sockets and stop */
|
||||
void Close();
|
||||
/** bind to address */
|
||||
void Bind(const std::string & addr);
|
||||
void Bind(const std::string &addr);
|
||||
|
||||
typedef std::function<void(IServerConn *)> ConnVisitor;
|
||||
|
||||
@ -77,22 +76,22 @@ namespace nntpchan
|
||||
void VisitConns(ConnVisitor v);
|
||||
|
||||
/** remove connection from server, called after proper close */
|
||||
void RemoveConn(IServerConn * conn);
|
||||
void RemoveConn(IServerConn *conn);
|
||||
|
||||
protected:
|
||||
uv_loop_t * GetLoop() { return m_loop; }
|
||||
protected:
|
||||
uv_loop_t *GetLoop() { return m_loop; }
|
||||
virtual void OnAcceptError(int status) = 0;
|
||||
private:
|
||||
operator uv_handle_t * () { return (uv_handle_t*) &m_server; }
|
||||
operator uv_tcp_t * () { return &m_server; }
|
||||
operator uv_stream_t * () { return (uv_stream_t *) &m_server; }
|
||||
|
||||
void OnAccept(uv_stream_t * s, int status);
|
||||
private:
|
||||
operator uv_handle_t *() { return (uv_handle_t *)&m_server; }
|
||||
operator uv_tcp_t *() { return &m_server; }
|
||||
operator uv_stream_t *() { return (uv_stream_t *)&m_server; }
|
||||
|
||||
void OnAccept(uv_stream_t *s, int status);
|
||||
std::deque<IServerConn *> m_conns;
|
||||
uv_tcp_t m_server;
|
||||
uv_loop_t * m_loop;
|
||||
};
|
||||
uv_loop_t *m_loop;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -5,7 +5,7 @@
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
std::string sha1_hex(const std::string & data);
|
||||
std::string sha1_hex(const std::string &data);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -2,34 +2,33 @@
|
||||
#define NNTPCHAN_STATICFILE_FRONTEND_HPP
|
||||
#include "frontend.hpp"
|
||||
#include "message.hpp"
|
||||
#include "template_engine.hpp"
|
||||
#include "model.hpp"
|
||||
#include "template_engine.hpp"
|
||||
#include <experimental/filesystem>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
namespace fs = std::experimental::filesystem;
|
||||
namespace fs = std::experimental::filesystem;
|
||||
|
||||
class StaticFileFrontend : public Frontend
|
||||
{
|
||||
public:
|
||||
|
||||
StaticFileFrontend(TemplateEngine * tmpl, const std::string & templateDir, const std::string & outDir, uint32_t pages);
|
||||
class StaticFileFrontend : public Frontend
|
||||
{
|
||||
public:
|
||||
StaticFileFrontend(TemplateEngine *tmpl, const std::string &templateDir, const std::string &outDir, uint32_t pages);
|
||||
|
||||
~StaticFileFrontend();
|
||||
|
||||
void ProcessNewMessage(const fs::path & fpath);
|
||||
bool AcceptsNewsgroup(const std::string & newsgroup);
|
||||
bool AcceptsMessage(const std::string & msgid);
|
||||
void ProcessNewMessage(const fs::path &fpath);
|
||||
bool AcceptsNewsgroup(const std::string &newsgroup);
|
||||
bool AcceptsMessage(const std::string &msgid);
|
||||
|
||||
private:
|
||||
private:
|
||||
MessageDB_ptr m_MessageDB;
|
||||
TemplateEngine_ptr m_TemplateEngine;
|
||||
fs::path m_TemplateDir;
|
||||
fs::path m_OutDir;
|
||||
uint32_t m_Pages;
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,53 +1,50 @@
|
||||
#ifndef NNTPCHAN_STORAGE_HPP
|
||||
#define NNTPCHAN_STORAGE_HPP
|
||||
|
||||
#include <experimental/filesystem>
|
||||
#include <string>
|
||||
#include "file_handle.hpp"
|
||||
#include "message.hpp"
|
||||
#include <experimental/filesystem>
|
||||
#include <string>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
namespace fs = std::experimental::filesystem;
|
||||
namespace fs = std::experimental::filesystem;
|
||||
|
||||
class ArticleStorage : public MessageDB
|
||||
{
|
||||
public:
|
||||
ArticleStorage();
|
||||
ArticleStorage(const fs::path & fpath);
|
||||
class ArticleStorage : public MessageDB
|
||||
{
|
||||
public:
|
||||
ArticleStorage(const fs::path &fpath);
|
||||
~ArticleStorage();
|
||||
|
||||
FileHandle_ptr OpenWrite(const std::string & msgid) const;
|
||||
FileHandle_ptr OpenRead(const std::string & msgid) const;
|
||||
FileHandle_ptr OpenWrite(const std::string &msgid) const;
|
||||
FileHandle_ptr OpenRead(const std::string &msgid) const;
|
||||
|
||||
/**
|
||||
return true if we should accept a new message give its message id
|
||||
*/
|
||||
bool Accept(const std::string & msgid) const;
|
||||
bool Accept(const std::string &msgid) const;
|
||||
|
||||
bool LoadBoardPage(BoardPage & board, const std::string & newsgroup, uint32_t perpage, uint32_t page) const;
|
||||
bool FindThreadByHash(const std::string & hashhex, std::string & msgid) const;
|
||||
bool LoadThread(Thread & thread, const std::string & rootmsgid) const;
|
||||
bool LoadBoardPage(BoardPage &board, const std::string &newsgroup, uint32_t perpage, uint32_t page) const;
|
||||
bool FindThreadByHash(const std::string &hashhex, std::string &msgid) const;
|
||||
bool LoadThread(Thread &thread, const std::string &rootmsgid) const;
|
||||
|
||||
/** ensure symlinks are formed for this article by message id */
|
||||
void EnsureSymlinks(const std::string & msgid) const;
|
||||
void EnsureSymlinks(const std::string &msgid) const;
|
||||
|
||||
private:
|
||||
void SetPath(const fs::path & fpath);
|
||||
private:
|
||||
void SetPath(const fs::path &fpath);
|
||||
|
||||
fs::path MessagePath(const std::string & msgid) const;
|
||||
fs::path MessagePath(const std::string &msgid) const;
|
||||
|
||||
bool init_skiplist(const std::string & subdir) const;
|
||||
bool init_skiplist(const std::string &subdir) const;
|
||||
|
||||
fs::path skiplist_root(const std::string & name) const;
|
||||
fs::path skiplist_root(const std::string &name) const;
|
||||
|
||||
fs::path basedir;
|
||||
};
|
||||
|
||||
};
|
||||
|
||||
typedef std::unique_ptr<ArticleStorage> ArticleStorage_ptr;
|
||||
typedef std::unique_ptr<ArticleStorage> ArticleStorage_ptr;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
@ -10,15 +10,15 @@
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
struct TemplateEngine
|
||||
{
|
||||
struct TemplateEngine
|
||||
{
|
||||
typedef std::map<std::string, std::variant<nntpchan::model::Model, std::string>> Args_t;
|
||||
virtual bool WriteTemplate(const fs::path & template_fpath, const Args_t & args, const FileHandle_ptr & out) = 0;
|
||||
};
|
||||
virtual bool WriteTemplate(const fs::path &template_fpath, const Args_t &args, const FileHandle_ptr &out) = 0;
|
||||
};
|
||||
|
||||
TemplateEngine * CreateTemplateEngine(const std::string & dialect);
|
||||
TemplateEngine *CreateTemplateEngine(const std::string &dialect);
|
||||
|
||||
typedef std::unique_ptr<TemplateEngine> TemplateEngine_ptr;
|
||||
typedef std::unique_ptr<TemplateEngine> TemplateEngine_ptr;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -6,56 +6,48 @@ using namespace mstch;
|
||||
|
||||
const mstch::node render_context::null_node;
|
||||
|
||||
render_context::push::push(render_context& context, const mstch::node& node):
|
||||
m_context(context)
|
||||
render_context::push::push(render_context &context, const mstch::node &node) : m_context(context)
|
||||
{
|
||||
context.m_nodes.emplace_front(node);
|
||||
context.m_node_ptrs.emplace_front(&node);
|
||||
context.m_state.push(std::unique_ptr<render_state>(new outside_section));
|
||||
}
|
||||
|
||||
render_context::push::~push() {
|
||||
render_context::push::~push()
|
||||
{
|
||||
m_context.m_nodes.pop_front();
|
||||
m_context.m_node_ptrs.pop_front();
|
||||
m_context.m_state.pop();
|
||||
}
|
||||
|
||||
std::string render_context::push::render(const template_type& templt) {
|
||||
return m_context.render(templt);
|
||||
}
|
||||
std::string render_context::push::render(const template_type &templt) { return m_context.render(templt); }
|
||||
|
||||
render_context::render_context(
|
||||
const mstch::node& node,
|
||||
const std::map<std::string, template_type>& partials):
|
||||
m_partials(partials), m_nodes(1, node), m_node_ptrs(1, &node)
|
||||
render_context::render_context(const mstch::node &node, const std::map<std::string, template_type> &partials)
|
||||
: m_partials(partials), m_nodes(1, node), m_node_ptrs(1, &node)
|
||||
{
|
||||
m_state.push(std::unique_ptr<render_state>(new outside_section));
|
||||
}
|
||||
|
||||
const mstch::node& render_context::find_node(
|
||||
const std::string& token,
|
||||
std::list<node const*> current_nodes)
|
||||
const mstch::node &render_context::find_node(const std::string &token, std::list<node const *> current_nodes)
|
||||
{
|
||||
if (token != "." && token.find('.') != std::string::npos)
|
||||
return find_node(token.substr(token.rfind('.') + 1),
|
||||
{&find_node(token.substr(0, token.rfind('.')), current_nodes)});
|
||||
else
|
||||
for (auto& node: current_nodes)
|
||||
for (auto &node : current_nodes)
|
||||
if (visit(has_token(token), *node))
|
||||
return visit(get_token(token, *node), *node);
|
||||
return null_node;
|
||||
}
|
||||
|
||||
const mstch::node& render_context::get_node(const std::string& token) {
|
||||
return find_node(token, m_node_ptrs);
|
||||
}
|
||||
const mstch::node &render_context::get_node(const std::string &token) { return find_node(token, m_node_ptrs); }
|
||||
|
||||
std::string render_context::render(
|
||||
const template_type& templt, const std::string& prefix)
|
||||
std::string render_context::render(const template_type &templt, const std::string &prefix)
|
||||
{
|
||||
std::string output;
|
||||
bool prev_eol = true;
|
||||
for (auto& token: templt) {
|
||||
for (auto &token : templt)
|
||||
{
|
||||
if (prev_eol && prefix.length() != 0)
|
||||
output += m_state.top()->render(*this, {prefix});
|
||||
output += m_state.top()->render(*this, token);
|
||||
@ -64,9 +56,7 @@ std::string render_context::render(
|
||||
return output;
|
||||
}
|
||||
|
||||
std::string render_context::render_partial(
|
||||
const std::string& partial_name, const std::string& prefix)
|
||||
std::string render_context::render_partial(const std::string &partial_name, const std::string &prefix)
|
||||
{
|
||||
return m_partials.count(partial_name) ?
|
||||
render(m_partials.at(partial_name), prefix) : "";
|
||||
return m_partials.count(partial_name) ? render(m_partials.at(partial_name), prefix) : "";
|
||||
}
|
||||
|
@ -3,49 +3,45 @@
|
||||
#include <deque>
|
||||
#include <list>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <stack>
|
||||
#include <string>
|
||||
|
||||
#include <mstch/mstch.hpp>
|
||||
#include "state/render_state.hpp"
|
||||
#include "template_type.hpp"
|
||||
#include <mstch/mstch.hpp>
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class render_context {
|
||||
class render_context
|
||||
{
|
||||
public:
|
||||
class push
|
||||
{
|
||||
public:
|
||||
class push {
|
||||
public:
|
||||
push(render_context& context, const mstch::node& node = {});
|
||||
push(render_context &context, const mstch::node &node = {});
|
||||
~push();
|
||||
std::string render(const template_type& templt);
|
||||
std::string render(const template_type &templt);
|
||||
|
||||
private:
|
||||
render_context& m_context;
|
||||
render_context &m_context;
|
||||
};
|
||||
|
||||
render_context(
|
||||
const mstch::node& node,
|
||||
const std::map<std::string, template_type>& partials);
|
||||
const mstch::node& get_node(const std::string& token);
|
||||
std::string render(
|
||||
const template_type& templt, const std::string& prefix = "");
|
||||
std::string render_partial(
|
||||
const std::string& partial_name, const std::string& prefix);
|
||||
template<class T, class... Args>
|
||||
void set_state(Args&& ... args) {
|
||||
m_state.top() = std::unique_ptr<render_state>(
|
||||
new T(std::forward<Args>(args)...));
|
||||
render_context(const mstch::node &node, const std::map<std::string, template_type> &partials);
|
||||
const mstch::node &get_node(const std::string &token);
|
||||
std::string render(const template_type &templt, const std::string &prefix = "");
|
||||
std::string render_partial(const std::string &partial_name, const std::string &prefix);
|
||||
template <class T, class... Args> void set_state(Args &&... args)
|
||||
{
|
||||
m_state.top() = std::unique_ptr<render_state>(new T(std::forward<Args>(args)...));
|
||||
}
|
||||
|
||||
private:
|
||||
private:
|
||||
static const mstch::node null_node;
|
||||
const mstch::node& find_node(
|
||||
const std::string& token,
|
||||
std::list<node const*> current_nodes);
|
||||
const mstch::node &find_node(const std::string &token, std::list<node const *> current_nodes);
|
||||
std::map<std::string, template_type> m_partials;
|
||||
std::deque<mstch::node> m_nodes;
|
||||
std::list<const mstch::node*> m_node_ptrs;
|
||||
std::list<const mstch::node *> m_node_ptrs;
|
||||
std::stack<std::unique_ptr<render_state>> m_state;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -1,19 +1,21 @@
|
||||
#include "in_section.hpp"
|
||||
#include "outside_section.hpp"
|
||||
#include "../visitor/is_node_empty.hpp"
|
||||
#include "../visitor/render_section.hpp"
|
||||
#include "outside_section.hpp"
|
||||
|
||||
using namespace mstch;
|
||||
|
||||
in_section::in_section(type type, const token& start_token):
|
||||
m_type(type), m_start_token(start_token), m_skipped_openings(0)
|
||||
in_section::in_section(type type, const token &start_token)
|
||||
: m_type(type), m_start_token(start_token), m_skipped_openings(0)
|
||||
{
|
||||
}
|
||||
|
||||
std::string in_section::render(render_context& ctx, const token& token) {
|
||||
std::string in_section::render(render_context &ctx, const token &token)
|
||||
{
|
||||
if (token.token_type() == token::type::section_close)
|
||||
if (token.name() == m_start_token.name() && m_skipped_openings == 0) {
|
||||
auto& node = ctx.get_node(m_start_token.name());
|
||||
if (token.name() == m_start_token.name() && m_skipped_openings == 0)
|
||||
{
|
||||
auto &node = ctx.get_node(m_start_token.name());
|
||||
std::string out;
|
||||
|
||||
if (m_type == type::normal && !visit(is_node_empty(), node))
|
||||
@ -23,10 +25,10 @@ std::string in_section::render(render_context& ctx, const token& token) {
|
||||
|
||||
ctx.set_state<outside_section>();
|
||||
return out;
|
||||
} else
|
||||
}
|
||||
else
|
||||
m_skipped_openings--;
|
||||
else if (token.token_type() == token::type::inverted_section_open ||
|
||||
token.token_type() == token::type::section_open)
|
||||
else if (token.token_type() == token::type::inverted_section_open || token.token_type() == token::type::section_open)
|
||||
m_skipped_openings++;
|
||||
|
||||
m_section << token;
|
||||
|
@ -3,22 +3,27 @@
|
||||
#include <sstream>
|
||||
#include <vector>
|
||||
|
||||
#include "render_state.hpp"
|
||||
#include "../template_type.hpp"
|
||||
#include "render_state.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class in_section: public render_state {
|
||||
public:
|
||||
enum class type { inverted, normal };
|
||||
in_section(type type, const token& start_token);
|
||||
std::string render(render_context& context, const token& token) override;
|
||||
class in_section : public render_state
|
||||
{
|
||||
public:
|
||||
enum class type
|
||||
{
|
||||
inverted,
|
||||
normal
|
||||
};
|
||||
in_section(type type, const token &start_token);
|
||||
std::string render(render_context &context, const token &token) override;
|
||||
|
||||
private:
|
||||
private:
|
||||
const type m_type;
|
||||
const token& m_start_token;
|
||||
const token &m_start_token;
|
||||
template_type m_section;
|
||||
int m_skipped_openings;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -1,16 +1,16 @@
|
||||
#include "outside_section.hpp"
|
||||
|
||||
#include "../render_context.hpp"
|
||||
#include "../visitor/render_node.hpp"
|
||||
#include "in_section.hpp"
|
||||
#include "../render_context.hpp"
|
||||
|
||||
using namespace mstch;
|
||||
|
||||
std::string outside_section::render(
|
||||
render_context& ctx, const token& token)
|
||||
std::string outside_section::render(render_context &ctx, const token &token)
|
||||
{
|
||||
using flag = render_node::flag;
|
||||
switch (token.token_type()) {
|
||||
switch (token.token_type())
|
||||
{
|
||||
case token::type::section_open:
|
||||
ctx.set_state<in_section>(in_section::type::normal, token);
|
||||
break;
|
||||
|
@ -2,11 +2,12 @@
|
||||
|
||||
#include "render_state.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class outside_section: public render_state {
|
||||
public:
|
||||
std::string render(render_context& context, const token& token) override;
|
||||
class outside_section : public render_state
|
||||
{
|
||||
public:
|
||||
std::string render(render_context &context, const token &token) override;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -4,14 +4,15 @@
|
||||
|
||||
#include "../token.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class render_context;
|
||||
|
||||
class render_state {
|
||||
public:
|
||||
class render_state
|
||||
{
|
||||
public:
|
||||
virtual ~render_state() {}
|
||||
virtual std::string render(render_context& context, const token& token) = 0;
|
||||
virtual std::string render(render_context &context, const token &token) = 0;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -2,57 +2,58 @@
|
||||
|
||||
using namespace mstch;
|
||||
|
||||
template_type::template_type(const std::string& str, const delim_type& delims):
|
||||
m_open(delims.first), m_close(delims.second)
|
||||
template_type::template_type(const std::string &str, const delim_type &delims)
|
||||
: m_open(delims.first), m_close(delims.second)
|
||||
{
|
||||
tokenize(str);
|
||||
strip_whitespace();
|
||||
}
|
||||
|
||||
template_type::template_type(const std::string& str):
|
||||
m_open("{{"), m_close("}}")
|
||||
template_type::template_type(const std::string &str) : m_open("{{"), m_close("}}")
|
||||
{
|
||||
tokenize(str);
|
||||
strip_whitespace();
|
||||
}
|
||||
|
||||
void template_type::process_text(citer begin, citer end) {
|
||||
void template_type::process_text(citer begin, citer end)
|
||||
{
|
||||
if (begin == end)
|
||||
return;
|
||||
auto start = begin;
|
||||
for (auto it = begin; it != end; ++it)
|
||||
if (*it == '\n' || it == end - 1) {
|
||||
if (*it == '\n' || it == end - 1)
|
||||
{
|
||||
m_tokens.push_back({{start, it + 1}});
|
||||
start = it + 1;
|
||||
}
|
||||
}
|
||||
|
||||
void template_type::tokenize(const std::string& tmp) {
|
||||
void template_type::tokenize(const std::string &tmp)
|
||||
{
|
||||
citer beg = tmp.begin();
|
||||
auto npos = std::string::npos;
|
||||
|
||||
for (std::size_t cur_pos = 0; cur_pos < tmp.size();) {
|
||||
for (std::size_t cur_pos = 0; cur_pos < tmp.size();)
|
||||
{
|
||||
auto open_pos = tmp.find(m_open, cur_pos);
|
||||
auto close_pos = tmp.find(
|
||||
m_close, open_pos == npos ? open_pos : open_pos + 1);
|
||||
auto close_pos = tmp.find(m_close, open_pos == npos ? open_pos : open_pos + 1);
|
||||
|
||||
if (close_pos != npos && open_pos != npos) {
|
||||
if (*(beg + open_pos + m_open.size()) == '{' &&
|
||||
*(beg + close_pos + m_close.size()) == '}')
|
||||
if (close_pos != npos && open_pos != npos)
|
||||
{
|
||||
if (*(beg + open_pos + m_open.size()) == '{' && *(beg + close_pos + m_close.size()) == '}')
|
||||
++close_pos;
|
||||
|
||||
process_text(beg + cur_pos, beg + open_pos);
|
||||
cur_pos = close_pos + m_close.size();
|
||||
m_tokens.push_back({{beg + open_pos, beg + close_pos + m_close.size()},
|
||||
m_open.size(), m_close.size()});
|
||||
m_tokens.push_back({{beg + open_pos, beg + close_pos + m_close.size()}, m_open.size(), m_close.size()});
|
||||
|
||||
if (cur_pos == tmp.size()) {
|
||||
if (cur_pos == tmp.size())
|
||||
{
|
||||
m_tokens.push_back({{""}});
|
||||
m_tokens.back().eol(true);
|
||||
}
|
||||
|
||||
if (*(beg + open_pos + m_open.size()) == '=' &&
|
||||
*(beg + close_pos - 1) == '=')
|
||||
if (*(beg + open_pos + m_open.size()) == '=' && *(beg + close_pos - 1) == '=')
|
||||
{
|
||||
auto tok_beg = beg + open_pos + m_open.size() + 1;
|
||||
auto tok_end = beg + close_pos - 1;
|
||||
@ -61,27 +62,32 @@ void template_type::tokenize(const std::string& tmp) {
|
||||
m_open = {front_skip, beg + tmp.find(' ', front_skip - beg)};
|
||||
m_close = {beg + tmp.rfind(' ', back_skip - beg) + 1, back_skip + 1};
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
process_text(beg + cur_pos, tmp.end());
|
||||
cur_pos = close_pos;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void template_type::strip_whitespace() {
|
||||
void template_type::strip_whitespace()
|
||||
{
|
||||
auto line_begin = m_tokens.begin();
|
||||
bool has_tag = false, non_space = false;
|
||||
|
||||
for (auto it = m_tokens.begin(); it != m_tokens.end(); ++it) {
|
||||
for (auto it = m_tokens.begin(); it != m_tokens.end(); ++it)
|
||||
{
|
||||
auto type = (*it).token_type();
|
||||
if (type != token::type::text && type != token::type::variable &&
|
||||
type != token::type::unescaped_variable)
|
||||
if (type != token::type::text && type != token::type::variable && type != token::type::unescaped_variable)
|
||||
has_tag = true;
|
||||
else if (!(*it).ws_only())
|
||||
non_space = true;
|
||||
|
||||
if ((*it).eol()) {
|
||||
if (has_tag && !non_space) {
|
||||
if ((*it).eol())
|
||||
{
|
||||
if (has_tag && !non_space)
|
||||
{
|
||||
store_prefixes(line_begin);
|
||||
|
||||
auto c = line_begin;
|
||||
@ -96,9 +102,9 @@ void template_type::strip_whitespace() {
|
||||
}
|
||||
}
|
||||
|
||||
void template_type::store_prefixes(std::vector<token>::iterator beg) {
|
||||
void template_type::store_prefixes(std::vector<token>::iterator beg)
|
||||
{
|
||||
for (auto cur = beg; !(*cur).eol(); ++cur)
|
||||
if ((*cur).token_type() == token::type::partial &&
|
||||
cur != beg && (*(cur - 1)).ws_only())
|
||||
if ((*cur).token_type() == token::type::partial && cur != beg && (*(cur - 1)).ws_only())
|
||||
(*cur).partial_prefix((*(cur - 1)).raw());
|
||||
}
|
||||
|
@ -6,25 +6,26 @@
|
||||
#include "token.hpp"
|
||||
#include "utils.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class template_type {
|
||||
public:
|
||||
class template_type
|
||||
{
|
||||
public:
|
||||
template_type() = default;
|
||||
template_type(const std::string& str);
|
||||
template_type(const std::string& str, const delim_type& delims);
|
||||
template_type(const std::string &str);
|
||||
template_type(const std::string &str, const delim_type &delims);
|
||||
std::vector<token>::const_iterator begin() const { return m_tokens.begin(); }
|
||||
std::vector<token>::const_iterator end() const { return m_tokens.end(); }
|
||||
void operator<<(const token& token) { m_tokens.push_back(token); }
|
||||
void operator<<(const token &token) { m_tokens.push_back(token); }
|
||||
|
||||
private:
|
||||
private:
|
||||
std::vector<token> m_tokens;
|
||||
std::string m_open;
|
||||
std::string m_close;
|
||||
void strip_whitespace();
|
||||
void process_text(citer beg, citer end);
|
||||
void tokenize(const std::string& tmp);
|
||||
void tokenize(const std::string &tmp);
|
||||
void store_prefixes(std::vector<token>::iterator beg);
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -3,38 +3,53 @@
|
||||
|
||||
using namespace mstch;
|
||||
|
||||
token::type token::token_info(char c) {
|
||||
switch (c) {
|
||||
case '>': return type::partial;
|
||||
case '^': return type::inverted_section_open;
|
||||
case '/': return type::section_close;
|
||||
case '&': return type::unescaped_variable;
|
||||
case '#': return type::section_open;
|
||||
case '!': return type::comment;
|
||||
default: return type::variable;
|
||||
token::type token::token_info(char c)
|
||||
{
|
||||
switch (c)
|
||||
{
|
||||
case '>':
|
||||
return type::partial;
|
||||
case '^':
|
||||
return type::inverted_section_open;
|
||||
case '/':
|
||||
return type::section_close;
|
||||
case '&':
|
||||
return type::unescaped_variable;
|
||||
case '#':
|
||||
return type::section_open;
|
||||
case '!':
|
||||
return type::comment;
|
||||
default:
|
||||
return type::variable;
|
||||
}
|
||||
}
|
||||
|
||||
token::token(const std::string& str, std::size_t left, std::size_t right):
|
||||
m_raw(str), m_eol(false), m_ws_only(false)
|
||||
token::token(const std::string &str, std::size_t left, std::size_t right) : m_raw(str), m_eol(false), m_ws_only(false)
|
||||
{
|
||||
if (left != 0 && right != 0) {
|
||||
if (str[left] == '=' && str[str.size() - right - 1] == '=') {
|
||||
if (left != 0 && right != 0)
|
||||
{
|
||||
if (str[left] == '=' && str[str.size() - right - 1] == '=')
|
||||
{
|
||||
m_type = type::delimiter_change;
|
||||
} else if (str[left] == '{' && str[str.size() - right - 1] == '}') {
|
||||
}
|
||||
else if (str[left] == '{' && str[str.size() - right - 1] == '}')
|
||||
{
|
||||
m_type = type::unescaped_variable;
|
||||
m_name = {first_not_ws(str.begin() + left + 1, str.end() - right),
|
||||
first_not_ws(str.rbegin() + 1 + right, str.rend() - left) + 1};
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
auto c = first_not_ws(str.begin() + left, str.end() - right);
|
||||
m_type = token_info(*c);
|
||||
if (m_type != type::variable)
|
||||
c = first_not_ws(c + 1, str.end() - right);
|
||||
m_name = {c, first_not_ws(str.rbegin() + right, str.rend() - left) + 1};
|
||||
m_delims = {{str.begin(), str.begin() + left},
|
||||
{str.end() - right, str.end()}};
|
||||
m_delims = {{str.begin(), str.begin() + left}, {str.end() - right, str.end()}};
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
m_type = type::text;
|
||||
m_eol = (str.size() > 0 && str[str.size() - 1] == '\n');
|
||||
m_ws_only = (str.find_first_not_of(" \r\n\t") == std::string::npos);
|
||||
|
@ -2,30 +2,38 @@
|
||||
|
||||
#include <string>
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
using delim_type = std::pair<std::string, std::string>;
|
||||
|
||||
class token {
|
||||
public:
|
||||
enum class type {
|
||||
text, variable, section_open, section_close, inverted_section_open,
|
||||
unescaped_variable, comment, partial, delimiter_change
|
||||
class token
|
||||
{
|
||||
public:
|
||||
enum class type
|
||||
{
|
||||
text,
|
||||
variable,
|
||||
section_open,
|
||||
section_close,
|
||||
inverted_section_open,
|
||||
unescaped_variable,
|
||||
comment,
|
||||
partial,
|
||||
delimiter_change
|
||||
};
|
||||
token(const std::string& str, std::size_t left = 0, std::size_t right = 0);
|
||||
token(const std::string &str, std::size_t left = 0, std::size_t right = 0);
|
||||
type token_type() const { return m_type; };
|
||||
const std::string& raw() const { return m_raw; };
|
||||
const std::string& name() const { return m_name; };
|
||||
const std::string& partial_prefix() const { return m_partial_prefix; };
|
||||
const delim_type& delims() const { return m_delims; };
|
||||
void partial_prefix(const std::string& p_partial_prefix) {
|
||||
m_partial_prefix = p_partial_prefix;
|
||||
};
|
||||
const std::string &raw() const { return m_raw; };
|
||||
const std::string &name() const { return m_name; };
|
||||
const std::string &partial_prefix() const { return m_partial_prefix; };
|
||||
const delim_type &delims() const { return m_delims; };
|
||||
void partial_prefix(const std::string &p_partial_prefix) { m_partial_prefix = p_partial_prefix; };
|
||||
bool eol() const { return m_eol; }
|
||||
void eol(bool eol) { m_eol = eol; }
|
||||
bool ws_only() const { return m_ws_only; }
|
||||
|
||||
private:
|
||||
private:
|
||||
type m_type;
|
||||
std::string m_name;
|
||||
std::string m_raw;
|
||||
@ -35,5 +43,4 @@ class token {
|
||||
bool m_ws_only;
|
||||
type token_info(char c);
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -1,43 +1,60 @@
|
||||
#include "utils.hpp"
|
||||
#include "mstch/mstch.hpp"
|
||||
|
||||
mstch::citer mstch::first_not_ws(mstch::citer begin, mstch::citer end) {
|
||||
mstch::citer mstch::first_not_ws(mstch::citer begin, mstch::citer end)
|
||||
{
|
||||
for (auto it = begin; it != end; ++it)
|
||||
if (*it != ' ') return it;
|
||||
if (*it != ' ')
|
||||
return it;
|
||||
return end;
|
||||
}
|
||||
|
||||
mstch::citer mstch::first_not_ws(mstch::criter begin, mstch::criter end) {
|
||||
mstch::citer mstch::first_not_ws(mstch::criter begin, mstch::criter end)
|
||||
{
|
||||
for (auto rit = begin; rit != end; ++rit)
|
||||
if (*rit != ' ') return --(rit.base());
|
||||
if (*rit != ' ')
|
||||
return --(rit.base());
|
||||
return --(end.base());
|
||||
}
|
||||
|
||||
mstch::criter mstch::reverse(mstch::citer it) {
|
||||
return std::reverse_iterator<mstch::citer>(it);
|
||||
}
|
||||
mstch::criter mstch::reverse(mstch::citer it) { return std::reverse_iterator<mstch::citer>(it); }
|
||||
|
||||
std::string mstch::html_escape(const std::string& str) {
|
||||
std::string mstch::html_escape(const std::string &str)
|
||||
{
|
||||
if (mstch::config::escape)
|
||||
return mstch::config::escape(str);
|
||||
|
||||
std::string out;
|
||||
citer start = str.begin();
|
||||
|
||||
auto add_escape = [&out, &start](const std::string& escaped, citer& it) {
|
||||
auto add_escape = [&out, &start](const std::string &escaped, citer &it) {
|
||||
out += std::string{start, it} + escaped;
|
||||
start = it + 1;
|
||||
};
|
||||
|
||||
for (auto it = str.begin(); it != str.end(); ++it)
|
||||
switch (*it) {
|
||||
case '&': add_escape("&", it); break;
|
||||
case '\'': add_escape("'", it); break;
|
||||
case '"': add_escape(""", it); break;
|
||||
case '<': add_escape("<", it); break;
|
||||
case '>': add_escape(">", it); break;
|
||||
case '/': add_escape("/", it); break;
|
||||
default: break;
|
||||
switch (*it)
|
||||
{
|
||||
case '&':
|
||||
add_escape("&", it);
|
||||
break;
|
||||
case '\'':
|
||||
add_escape("'", it);
|
||||
break;
|
||||
case '"':
|
||||
add_escape(""", it);
|
||||
break;
|
||||
case '<':
|
||||
add_escape("<", it);
|
||||
break;
|
||||
case '>':
|
||||
add_escape(">", it);
|
||||
break;
|
||||
case '/':
|
||||
add_escape("/", it);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return out + std::string{start, str.end()};
|
||||
|
@ -1,23 +1,21 @@
|
||||
#pragma once
|
||||
|
||||
#include <string>
|
||||
#include <boost/variant/apply_visitor.hpp>
|
||||
#include <string>
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
using citer = std::string::const_iterator;
|
||||
using criter = std::string::const_reverse_iterator;
|
||||
|
||||
citer first_not_ws(citer begin, citer end);
|
||||
citer first_not_ws(criter begin, criter end);
|
||||
std::string html_escape(const std::string& str);
|
||||
std::string html_escape(const std::string &str);
|
||||
criter reverse(citer it);
|
||||
|
||||
template<class... Args>
|
||||
auto visit(Args&&... args) -> decltype(boost::apply_visitor(
|
||||
std::forward<Args>(args)...))
|
||||
template <class... Args> auto visit(Args &&... args) -> decltype(boost::apply_visitor(std::forward<Args>(args)...))
|
||||
{
|
||||
return boost::apply_visitor(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -2,34 +2,25 @@
|
||||
|
||||
#include <boost/variant/static_visitor.hpp>
|
||||
|
||||
#include "mstch/mstch.hpp"
|
||||
#include "has_token.hpp"
|
||||
#include "mstch/mstch.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class get_token: public boost::static_visitor<const mstch::node&> {
|
||||
public:
|
||||
get_token(const std::string& token, const mstch::node& node):
|
||||
m_token(token), m_node(node)
|
||||
{
|
||||
}
|
||||
class get_token : public boost::static_visitor<const mstch::node &>
|
||||
{
|
||||
public:
|
||||
get_token(const std::string &token, const mstch::node &node) : m_token(token), m_node(node) {}
|
||||
|
||||
template<class T>
|
||||
const mstch::node& operator()(const T&) const {
|
||||
return m_node;
|
||||
}
|
||||
template <class T> const mstch::node &operator()(const T &) const { return m_node; }
|
||||
|
||||
const mstch::node& operator()(const map& map) const {
|
||||
return map.at(m_token);
|
||||
}
|
||||
const mstch::node &operator()(const map &map) const { return map.at(m_token); }
|
||||
|
||||
const mstch::node& operator()(const std::shared_ptr<object>& object) const {
|
||||
return object->at(m_token);
|
||||
}
|
||||
const mstch::node &operator()(const std::shared_ptr<object> &object) const { return object->at(m_token); }
|
||||
|
||||
private:
|
||||
const std::string& m_token;
|
||||
const mstch::node& m_node;
|
||||
private:
|
||||
const std::string &m_token;
|
||||
const mstch::node &m_node;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -4,28 +4,21 @@
|
||||
|
||||
#include "mstch/mstch.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class has_token: public boost::static_visitor<bool> {
|
||||
public:
|
||||
has_token(const std::string& token): m_token(token) {
|
||||
}
|
||||
class has_token : public boost::static_visitor<bool>
|
||||
{
|
||||
public:
|
||||
has_token(const std::string &token) : m_token(token) {}
|
||||
|
||||
template<class T>
|
||||
bool operator()(const T&) const {
|
||||
return m_token == ".";
|
||||
}
|
||||
template <class T> bool operator()(const T &) const { return m_token == "."; }
|
||||
|
||||
bool operator()(const map& map) const {
|
||||
return map.count(m_token) == 1;
|
||||
}
|
||||
bool operator()(const map &map) const { return map.count(m_token) == 1; }
|
||||
|
||||
bool operator()(const std::shared_ptr<object>& object) const {
|
||||
return object->has(m_token);
|
||||
}
|
||||
bool operator()(const std::shared_ptr<object> &object) const { return object->has(m_token); }
|
||||
|
||||
private:
|
||||
const std::string& m_token;
|
||||
private:
|
||||
const std::string &m_token;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -4,38 +4,24 @@
|
||||
|
||||
#include "mstch/mstch.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class is_node_empty: public boost::static_visitor<bool> {
|
||||
public:
|
||||
template<class T>
|
||||
bool operator()(const T&) const {
|
||||
return false;
|
||||
}
|
||||
class is_node_empty : public boost::static_visitor<bool>
|
||||
{
|
||||
public:
|
||||
template <class T> bool operator()(const T &) const { return false; }
|
||||
|
||||
bool operator()(const std::nullptr_t&) const {
|
||||
return true;
|
||||
}
|
||||
bool operator()(const std::nullptr_t &) const { return true; }
|
||||
|
||||
bool operator()(const int& value) const {
|
||||
return value == 0;
|
||||
}
|
||||
bool operator()(const int &value) const { return value == 0; }
|
||||
|
||||
bool operator()(const double& value) const {
|
||||
return value == 0;
|
||||
}
|
||||
bool operator()(const double &value) const { return value == 0; }
|
||||
|
||||
bool operator()(const bool& value) const {
|
||||
return !value;
|
||||
}
|
||||
bool operator()(const bool &value) const { return !value; }
|
||||
|
||||
bool operator()(const std::string& value) const {
|
||||
return value == "";
|
||||
}
|
||||
bool operator()(const std::string &value) const { return value == ""; }
|
||||
|
||||
bool operator()(const array& array) const {
|
||||
return array.size() == 0;
|
||||
}
|
||||
bool operator()(const array &array) const { return array.size() == 0; }
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -1,56 +1,52 @@
|
||||
#pragma once
|
||||
|
||||
#include <sstream>
|
||||
#include <boost/variant/static_visitor.hpp>
|
||||
#include <sstream>
|
||||
|
||||
#include "../render_context.hpp"
|
||||
#include "mstch/mstch.hpp"
|
||||
#include "../utils.hpp"
|
||||
#include "mstch/mstch.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class render_node: public boost::static_visitor<std::string> {
|
||||
public:
|
||||
enum class flag { none, escape_html };
|
||||
render_node(render_context& ctx, flag p_flag = flag::none):
|
||||
m_ctx(ctx), m_flag(p_flag)
|
||||
class render_node : public boost::static_visitor<std::string>
|
||||
{
|
||||
public:
|
||||
enum class flag
|
||||
{
|
||||
}
|
||||
none,
|
||||
escape_html
|
||||
};
|
||||
render_node(render_context &ctx, flag p_flag = flag::none) : m_ctx(ctx), m_flag(p_flag) {}
|
||||
|
||||
template<class T>
|
||||
std::string operator()(const T&) const {
|
||||
return "";
|
||||
}
|
||||
template <class T> std::string operator()(const T &) const { return ""; }
|
||||
|
||||
std::string operator()(const int& value) const {
|
||||
return std::to_string(value);
|
||||
}
|
||||
std::string operator()(const int &value) const { return std::to_string(value); }
|
||||
|
||||
std::string operator()(const double& value) const {
|
||||
std::string operator()(const double &value) const
|
||||
{
|
||||
std::stringstream ss;
|
||||
ss << value;
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
std::string operator()(const bool& value) const {
|
||||
return value ? "true" : "false";
|
||||
}
|
||||
std::string operator()(const bool &value) const { return value ? "true" : "false"; }
|
||||
|
||||
std::string operator()(const lambda& value) const {
|
||||
template_type interpreted{value([this](const mstch::node& n) {
|
||||
return visit(render_node(m_ctx), n);
|
||||
})};
|
||||
std::string operator()(const lambda &value) const
|
||||
{
|
||||
template_type interpreted{value([this](const mstch::node &n) { return visit(render_node(m_ctx), n); })};
|
||||
auto rendered = render_context::push(m_ctx).render(interpreted);
|
||||
return (m_flag == flag::escape_html) ? html_escape(rendered) : rendered;
|
||||
}
|
||||
|
||||
std::string operator()(const std::string& value) const {
|
||||
std::string operator()(const std::string &value) const
|
||||
{
|
||||
return (m_flag == flag::escape_html) ? html_escape(value) : value;
|
||||
}
|
||||
|
||||
private:
|
||||
render_context& m_ctx;
|
||||
private:
|
||||
render_context &m_ctx;
|
||||
flag m_flag;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -3,55 +3,56 @@
|
||||
#include <boost/variant/static_visitor.hpp>
|
||||
|
||||
#include "../render_context.hpp"
|
||||
#include "mstch/mstch.hpp"
|
||||
#include "../utils.hpp"
|
||||
#include "mstch/mstch.hpp"
|
||||
#include "render_node.hpp"
|
||||
|
||||
namespace mstch {
|
||||
namespace mstch
|
||||
{
|
||||
|
||||
class render_section: public boost::static_visitor<std::string> {
|
||||
public:
|
||||
enum class flag { none, keep_array };
|
||||
render_section(
|
||||
render_context& ctx,
|
||||
const template_type& section,
|
||||
const delim_type& delims,
|
||||
flag p_flag = flag::none):
|
||||
m_ctx(ctx), m_section(section), m_delims(delims), m_flag(p_flag)
|
||||
class render_section : public boost::static_visitor<std::string>
|
||||
{
|
||||
public:
|
||||
enum class flag
|
||||
{
|
||||
none,
|
||||
keep_array
|
||||
};
|
||||
render_section(render_context &ctx, const template_type §ion, const delim_type &delims, flag p_flag = flag::none)
|
||||
: m_ctx(ctx), m_section(section), m_delims(delims), m_flag(p_flag)
|
||||
{
|
||||
}
|
||||
|
||||
template<class T>
|
||||
std::string operator()(const T& t) const {
|
||||
template <class T> std::string operator()(const T &t) const
|
||||
{
|
||||
return render_context::push(m_ctx, t).render(m_section);
|
||||
}
|
||||
|
||||
std::string operator()(const lambda& fun) const {
|
||||
std::string operator()(const lambda &fun) const
|
||||
{
|
||||
std::string section_str;
|
||||
for (auto& token: m_section)
|
||||
for (auto &token : m_section)
|
||||
section_str += token.raw();
|
||||
template_type interpreted{fun([this](const mstch::node& n) {
|
||||
return visit(render_node(m_ctx), n);
|
||||
}, section_str), m_delims};
|
||||
template_type interpreted{fun([this](const mstch::node &n) { return visit(render_node(m_ctx), n); }, section_str),
|
||||
m_delims};
|
||||
return render_context::push(m_ctx).render(interpreted);
|
||||
}
|
||||
|
||||
std::string operator()(const array& array) const {
|
||||
std::string operator()(const array &array) const
|
||||
{
|
||||
std::string out;
|
||||
if (m_flag == flag::keep_array)
|
||||
return render_context::push(m_ctx, array).render(m_section);
|
||||
else
|
||||
for (auto& item: array)
|
||||
out += visit(render_section(
|
||||
m_ctx, m_section, m_delims, flag::keep_array), item);
|
||||
for (auto &item : array)
|
||||
out += visit(render_section(m_ctx, m_section, m_delims, flag::keep_array), item);
|
||||
return out;
|
||||
}
|
||||
|
||||
private:
|
||||
render_context& m_ctx;
|
||||
const template_type& m_section;
|
||||
const delim_type& m_delims;
|
||||
private:
|
||||
render_context &m_ctx;
|
||||
const template_type &m_section;
|
||||
const delim_type &m_delims;
|
||||
flag m_flag;
|
||||
};
|
||||
|
||||
}
|
||||
|
@ -1,65 +1,56 @@
|
||||
#include <nntpchan/base64.hpp>
|
||||
|
||||
|
||||
// taken from i2pd
|
||||
namespace i2p
|
||||
{
|
||||
namespace data
|
||||
{
|
||||
static void iT64Build(void);
|
||||
static void iT64Build(void);
|
||||
|
||||
/*
|
||||
*
|
||||
* BASE64 Substitution Table
|
||||
* -------------------------
|
||||
*
|
||||
* Direct Substitution Table
|
||||
*/
|
||||
/*
|
||||
*
|
||||
* BASE64 Substitution Table
|
||||
* -------------------------
|
||||
*
|
||||
* Direct Substitution Table
|
||||
*/
|
||||
|
||||
static const char T64[64] = {
|
||||
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
|
||||
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
|
||||
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
|
||||
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
|
||||
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
|
||||
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
|
||||
'w', 'x', 'y', 'z', '0', '1', '2', '3',
|
||||
'4', '5', '6', '7', '8', '9', '+', '/'
|
||||
};
|
||||
static const char T64[64] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
|
||||
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
|
||||
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
|
||||
'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
|
||||
|
||||
/*
|
||||
* Reverse Substitution Table (built in run time)
|
||||
*/
|
||||
|
||||
/*
|
||||
* Reverse Substitution Table (built in run time)
|
||||
*/
|
||||
static char iT64[256];
|
||||
static int isFirstTime = 1;
|
||||
|
||||
static char iT64[256];
|
||||
static int isFirstTime = 1;
|
||||
/*
|
||||
* Padding
|
||||
*/
|
||||
|
||||
/*
|
||||
* Padding
|
||||
*/
|
||||
static char P64 = '=';
|
||||
|
||||
static char P64 = '=';
|
||||
|
||||
/*
|
||||
*
|
||||
* ByteStreamToBase64
|
||||
* ------------------
|
||||
*
|
||||
* Converts binary encoded data to BASE64 format.
|
||||
*
|
||||
*/
|
||||
static size_t /* Number of bytes in the encoded buffer */
|
||||
ByteStreamToBase64 (
|
||||
const uint8_t * InBuffer, /* Input buffer, binary data */
|
||||
/*
|
||||
*
|
||||
* ByteStreamToBase64
|
||||
* ------------------
|
||||
*
|
||||
* Converts binary encoded data to BASE64 format.
|
||||
*
|
||||
*/
|
||||
static size_t /* Number of bytes in the encoded buffer */
|
||||
ByteStreamToBase64(const uint8_t *InBuffer, /* Input buffer, binary data */
|
||||
size_t InCount, /* Number of bytes in the input buffer */
|
||||
char * OutBuffer, /* output buffer */
|
||||
char *OutBuffer, /* output buffer */
|
||||
size_t len /* length of output buffer */
|
||||
)
|
||||
|
||||
{
|
||||
unsigned char * ps;
|
||||
unsigned char * pd;
|
||||
{
|
||||
unsigned char *ps;
|
||||
unsigned char *pd;
|
||||
unsigned char acc_1;
|
||||
unsigned char acc_2;
|
||||
int i;
|
||||
@ -68,77 +59,78 @@ namespace data
|
||||
size_t outCount;
|
||||
|
||||
ps = (unsigned char *)InBuffer;
|
||||
n = InCount/3;
|
||||
m = InCount%3;
|
||||
n = InCount / 3;
|
||||
m = InCount % 3;
|
||||
if (!m)
|
||||
outCount = 4*n;
|
||||
outCount = 4 * n;
|
||||
else
|
||||
outCount = 4*(n+1);
|
||||
if (outCount > len) return 0;
|
||||
outCount = 4 * (n + 1);
|
||||
if (outCount > len)
|
||||
return 0;
|
||||
pd = (unsigned char *)OutBuffer;
|
||||
for ( i = 0; i<n; i++ ){
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
acc_1 = *ps++;
|
||||
acc_2 = (acc_1<<4)&0x30;
|
||||
acc_2 = (acc_1 << 4) & 0x30;
|
||||
acc_1 >>= 2; /* base64 digit #1 */
|
||||
*pd++ = T64[acc_1];
|
||||
acc_1 = *ps++;
|
||||
acc_2 |= acc_1 >> 4; /* base64 digit #2 */
|
||||
*pd++ = T64[acc_2];
|
||||
acc_1 &= 0x0f;
|
||||
acc_1 <<=2;
|
||||
acc_1 <<= 2;
|
||||
acc_2 = *ps++;
|
||||
acc_1 |= acc_2>>6; /* base64 digit #3 */
|
||||
acc_1 |= acc_2 >> 6; /* base64 digit #3 */
|
||||
*pd++ = T64[acc_1];
|
||||
acc_2 &= 0x3f; /* base64 digit #4 */
|
||||
*pd++ = T64[acc_2];
|
||||
}
|
||||
if ( m == 1 ){
|
||||
if (m == 1)
|
||||
{
|
||||
acc_1 = *ps++;
|
||||
acc_2 = (acc_1<<4)&0x3f; /* base64 digit #2 */
|
||||
acc_2 = (acc_1 << 4) & 0x3f; /* base64 digit #2 */
|
||||
acc_1 >>= 2; /* base64 digit #1 */
|
||||
*pd++ = T64[acc_1];
|
||||
*pd++ = T64[acc_2];
|
||||
*pd++ = P64;
|
||||
*pd++ = P64;
|
||||
|
||||
}
|
||||
else if ( m == 2 ){
|
||||
else if (m == 2)
|
||||
{
|
||||
acc_1 = *ps++;
|
||||
acc_2 = (acc_1<<4)&0x3f;
|
||||
acc_2 = (acc_1 << 4) & 0x3f;
|
||||
acc_1 >>= 2; /* base64 digit #1 */
|
||||
*pd++ = T64[acc_1];
|
||||
acc_1 = *ps++;
|
||||
acc_2 |= acc_1 >> 4; /* base64 digit #2 */
|
||||
*pd++ = T64[acc_2];
|
||||
acc_1 &= 0x0f;
|
||||
acc_1 <<=2; /* base64 digit #3 */
|
||||
acc_1 <<= 2; /* base64 digit #3 */
|
||||
*pd++ = T64[acc_1];
|
||||
*pd++ = P64;
|
||||
}
|
||||
|
||||
return outCount;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* Base64ToByteStream
|
||||
* ------------------
|
||||
*
|
||||
* Converts BASE64 encoded data to binary format. If input buffer is
|
||||
* not properly padded, buffer of negative length is returned
|
||||
*
|
||||
*/
|
||||
static
|
||||
ssize_t /* Number of output bytes */
|
||||
Base64ToByteStream (
|
||||
const char * InBuffer, /* BASE64 encoded buffer */
|
||||
/*
|
||||
*
|
||||
* Base64ToByteStream
|
||||
* ------------------
|
||||
*
|
||||
* Converts BASE64 encoded data to binary format. If input buffer is
|
||||
* not properly padded, buffer of negative length is returned
|
||||
*
|
||||
*/
|
||||
static ssize_t /* Number of output bytes */
|
||||
Base64ToByteStream(const char *InBuffer, /* BASE64 encoded buffer */
|
||||
size_t InCount, /* Number of input bytes */
|
||||
uint8_t * OutBuffer, /* output buffer length */
|
||||
uint8_t *OutBuffer, /* output buffer length */
|
||||
size_t len /* length of output buffer */
|
||||
)
|
||||
{
|
||||
unsigned char * ps;
|
||||
unsigned char * pd;
|
||||
{
|
||||
unsigned char *ps;
|
||||
unsigned char *pd;
|
||||
unsigned char acc_1;
|
||||
unsigned char acc_2;
|
||||
int i;
|
||||
@ -146,36 +138,43 @@ namespace data
|
||||
int m;
|
||||
size_t outCount;
|
||||
|
||||
if (isFirstTime) iT64Build();
|
||||
n = InCount/4;
|
||||
m = InCount%4;
|
||||
if (isFirstTime)
|
||||
iT64Build();
|
||||
n = InCount / 4;
|
||||
m = InCount % 4;
|
||||
if (InCount && !m)
|
||||
outCount = 3*n;
|
||||
else {
|
||||
outCount = 3 * n;
|
||||
else
|
||||
{
|
||||
outCount = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
ps = (unsigned char *)(InBuffer + InCount - 1);
|
||||
while ( *ps-- == P64 ) outCount--;
|
||||
while (*ps-- == P64)
|
||||
outCount--;
|
||||
ps = (unsigned char *)InBuffer;
|
||||
|
||||
if (outCount > len) return -1;
|
||||
if (outCount > len)
|
||||
return -1;
|
||||
pd = OutBuffer;
|
||||
auto endOfOutBuffer = OutBuffer + outCount;
|
||||
for ( i = 0; i < n; i++ ){
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
acc_1 = iT64[*ps++];
|
||||
acc_2 = iT64[*ps++];
|
||||
acc_1 <<= 2;
|
||||
acc_1 |= acc_2>>4;
|
||||
acc_1 |= acc_2 >> 4;
|
||||
*pd++ = acc_1;
|
||||
if (pd >= endOfOutBuffer) break;
|
||||
if (pd >= endOfOutBuffer)
|
||||
break;
|
||||
|
||||
acc_2 <<= 4;
|
||||
acc_1 = iT64[*ps++];
|
||||
acc_2 |= acc_1 >> 2;
|
||||
*pd++ = acc_2;
|
||||
if (pd >= endOfOutBuffer) break;
|
||||
if (pd >= endOfOutBuffer)
|
||||
break;
|
||||
|
||||
acc_2 = iT64[*ps++];
|
||||
acc_2 |= acc_1 << 6;
|
||||
@ -183,52 +182,54 @@ namespace data
|
||||
}
|
||||
|
||||
return outCount;
|
||||
}
|
||||
}
|
||||
|
||||
static size_t Base64EncodingBufferSize (const size_t input_size)
|
||||
{
|
||||
auto d = div (input_size, 3);
|
||||
if (d.rem) d.quot++;
|
||||
return 4*d.quot;
|
||||
}
|
||||
static size_t Base64EncodingBufferSize(const size_t input_size)
|
||||
{
|
||||
auto d = div(input_size, 3);
|
||||
if (d.rem)
|
||||
d.quot++;
|
||||
return 4 * d.quot;
|
||||
}
|
||||
|
||||
/*
|
||||
*
|
||||
* iT64
|
||||
* ----
|
||||
* Reverse table builder. P64 character is replaced with 0
|
||||
*
|
||||
*
|
||||
*/
|
||||
/*
|
||||
*
|
||||
* iT64
|
||||
* ----
|
||||
* Reverse table builder. P64 character is replaced with 0
|
||||
*
|
||||
*
|
||||
*/
|
||||
|
||||
static void iT64Build()
|
||||
{
|
||||
static void iT64Build()
|
||||
{
|
||||
int i;
|
||||
isFirstTime = 0;
|
||||
for ( i=0; i<256; i++ ) iT64[i] = -1;
|
||||
for ( i=0; i<64; i++ ) iT64[(int)T64[i]] = i;
|
||||
for (i = 0; i < 256; i++)
|
||||
iT64[i] = -1;
|
||||
for (i = 0; i < 64; i++)
|
||||
iT64[(int)T64[i]] = i;
|
||||
iT64[(int)P64] = 0;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
std::string B64Encode(const uint8_t * data, const std::size_t l)
|
||||
{
|
||||
std::string B64Encode(const uint8_t *data, const std::size_t l)
|
||||
{
|
||||
std::string out;
|
||||
out.resize(i2p::data::Base64EncodingBufferSize(l));
|
||||
i2p::data::ByteStreamToBase64(data, l, &out[0], out.size());
|
||||
return out;
|
||||
}
|
||||
}
|
||||
|
||||
bool B64Decode(const std::string & data, std::vector<uint8_t> & out)
|
||||
{
|
||||
bool B64Decode(const std::string &data, std::vector<uint8_t> &out)
|
||||
{
|
||||
out.resize(data.size());
|
||||
if(i2p::data::Base64ToByteStream(data.c_str(), data.size(), &out[0], out.size()) == -1) return false;
|
||||
if (i2p::data::Base64ToByteStream(data.c_str(), data.size(), &out[0], out.size()) == -1)
|
||||
return false;
|
||||
out.shrink_to_fit();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,21 +1,17 @@
|
||||
#include <nntpchan/buffer.hpp>
|
||||
#include <cstring>
|
||||
#include <nntpchan/buffer.hpp>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
WriteBuffer::WriteBuffer(const char * b, const size_t s)
|
||||
{
|
||||
char * buf = new char[s];
|
||||
WriteBuffer::WriteBuffer(const char *b, const size_t s)
|
||||
{
|
||||
char *buf = new char[s];
|
||||
std::memcpy(buf, b, s);
|
||||
this->b = uv_buf_init(buf, s);
|
||||
w.data = this;
|
||||
}
|
||||
|
||||
WriteBuffer::WriteBuffer(const std::string & s) : WriteBuffer(s.c_str(), s.size()) {}
|
||||
|
||||
WriteBuffer::~WriteBuffer()
|
||||
{
|
||||
delete [] b.base;
|
||||
}
|
||||
}
|
||||
|
||||
WriteBuffer::WriteBuffer(const std::string &s) : WriteBuffer(s.c_str(), s.size()) {}
|
||||
|
||||
WriteBuffer::~WriteBuffer() { delete[] b.base; }
|
||||
}
|
||||
|
@ -1,20 +1,12 @@
|
||||
#include <cassert>
|
||||
#include <nntpchan/crypto.hpp>
|
||||
#include <sodium.h>
|
||||
#include <cassert>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
void SHA512(const uint8_t * d, const std::size_t l, SHA512Digest & h)
|
||||
{
|
||||
crypto_hash(h.data(), d, l);
|
||||
}
|
||||
void SHA512(const uint8_t *d, const std::size_t l, SHA512Digest &h) { crypto_hash(h.data(), d, l); }
|
||||
|
||||
Crypto::Crypto()
|
||||
{
|
||||
assert(sodium_init() == 0);
|
||||
}
|
||||
Crypto::Crypto() { assert(sodium_init() == 0); }
|
||||
|
||||
Crypto::~Crypto()
|
||||
{
|
||||
}
|
||||
Crypto::~Crypto() {}
|
||||
}
|
||||
|
@ -14,31 +14,15 @@ typedef struct
|
||||
unsigned char buffer[64];
|
||||
} SHA1_CTX;
|
||||
|
||||
void SHA1Transform(
|
||||
uint32_t state[5],
|
||||
const unsigned char buffer[64]
|
||||
);
|
||||
void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]);
|
||||
|
||||
void SHA1Init(
|
||||
SHA1_CTX * context
|
||||
);
|
||||
void SHA1Init(SHA1_CTX *context);
|
||||
|
||||
void SHA1Update(
|
||||
SHA1_CTX * context,
|
||||
const unsigned char *data,
|
||||
uint32_t len
|
||||
);
|
||||
void SHA1Update(SHA1_CTX *context, const unsigned char *data, uint32_t len);
|
||||
|
||||
void SHA1Final(
|
||||
unsigned char digest[20],
|
||||
SHA1_CTX * context
|
||||
);
|
||||
|
||||
void sha1(
|
||||
uint8_t *hash_out,
|
||||
const uint8_t *str,
|
||||
size_t len);
|
||||
void SHA1Final(unsigned char digest[20], SHA1_CTX *context);
|
||||
|
||||
void sha1(uint8_t *hash_out, const uint8_t *str, size_t len);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
@ -1,27 +1,17 @@
|
||||
#include <nntpchan/event.hpp>
|
||||
#include <cassert>
|
||||
#include <nntpchan/event.hpp>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
Mainloop::Mainloop()
|
||||
{
|
||||
Mainloop::Mainloop()
|
||||
{
|
||||
m_loop = uv_default_loop();
|
||||
assert(uv_loop_init(m_loop) == 0);
|
||||
}
|
||||
|
||||
Mainloop::~Mainloop()
|
||||
{
|
||||
uv_loop_close(m_loop);
|
||||
}
|
||||
|
||||
void Mainloop::Stop()
|
||||
{
|
||||
uv_stop(m_loop);
|
||||
}
|
||||
|
||||
void Mainloop::Run(uv_run_mode mode)
|
||||
{
|
||||
assert(uv_run(m_loop, mode) == 0);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Mainloop::~Mainloop() { uv_loop_close(m_loop); }
|
||||
|
||||
void Mainloop::Stop() { uv_stop(m_loop); }
|
||||
|
||||
void Mainloop::Run(uv_run_mode mode) { assert(uv_run(m_loop, mode) == 0); }
|
||||
}
|
||||
|
@ -1,57 +1,51 @@
|
||||
#include <nntpchan/exec_frontend.hpp>
|
||||
#include <cstring>
|
||||
#include <iostream>
|
||||
#include <errno.h>
|
||||
#include <unistd.h>
|
||||
#include <iostream>
|
||||
#include <nntpchan/exec_frontend.hpp>
|
||||
#include <sys/wait.h>
|
||||
#include <unistd.h>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
ExecFrontend::ExecFrontend(const std::string & fname) :
|
||||
m_exec(fname)
|
||||
{
|
||||
}
|
||||
ExecFrontend::ExecFrontend(const std::string &fname) : m_exec(fname) {}
|
||||
|
||||
ExecFrontend::~ExecFrontend() {}
|
||||
ExecFrontend::~ExecFrontend() {}
|
||||
|
||||
void ExecFrontend::ProcessNewMessage(const fs::path & fpath)
|
||||
{
|
||||
Exec({"post", fpath});
|
||||
}
|
||||
void ExecFrontend::ProcessNewMessage(const fs::path &fpath) { Exec({"post", fpath}); }
|
||||
|
||||
bool ExecFrontend::AcceptsNewsgroup(const std::string & newsgroup)
|
||||
{
|
||||
return Exec({"newsgroup", newsgroup}) == 0;
|
||||
}
|
||||
bool ExecFrontend::AcceptsNewsgroup(const std::string &newsgroup) { return Exec({"newsgroup", newsgroup}) == 0; }
|
||||
|
||||
bool ExecFrontend::AcceptsMessage(const std::string & msgid)
|
||||
{
|
||||
return Exec({"msgid", msgid}) == 0;
|
||||
}
|
||||
bool ExecFrontend::AcceptsMessage(const std::string &msgid) { return Exec({"msgid", msgid}) == 0; }
|
||||
|
||||
int ExecFrontend::Exec(std::deque<std::string> args)
|
||||
{
|
||||
int ExecFrontend::Exec(std::deque<std::string> args)
|
||||
{
|
||||
// set up arguments
|
||||
const char ** cargs = new char const *[args.size() +2];
|
||||
const char **cargs = new char const *[args.size() + 2];
|
||||
std::size_t l = 0;
|
||||
cargs[l++] = m_exec.c_str();
|
||||
while (args.size()) {
|
||||
while (args.size())
|
||||
{
|
||||
cargs[l++] = args.front().c_str();
|
||||
args.pop_front();
|
||||
}
|
||||
cargs[l] = 0;
|
||||
int retcode = 0;
|
||||
pid_t child = fork();
|
||||
if(child) {
|
||||
if (child)
|
||||
{
|
||||
waitpid(child, &retcode, 0);
|
||||
} else {
|
||||
int r = execvpe(m_exec.c_str(),(char * const *) cargs, environ);
|
||||
if ( r == -1 ) {
|
||||
}
|
||||
else
|
||||
{
|
||||
int r = execvpe(m_exec.c_str(), (char *const *)cargs, environ);
|
||||
if (r == -1)
|
||||
{
|
||||
std::cout << strerror(errno) << std::endl;
|
||||
exit( errno );
|
||||
} else
|
||||
exit(errno);
|
||||
}
|
||||
else
|
||||
exit(r);
|
||||
}
|
||||
return retcode;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,12 +1,11 @@
|
||||
#include <nntpchan/file_handle.hpp>
|
||||
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
FileHandle_ptr OpenFile(const fs::path & fname, FileMode mode)
|
||||
{
|
||||
std::fstream * f = new std::fstream;
|
||||
if(mode == eRead)
|
||||
FileHandle_ptr OpenFile(const fs::path &fname, FileMode mode)
|
||||
{
|
||||
std::fstream *f = new std::fstream;
|
||||
if (mode == eRead)
|
||||
{
|
||||
f->open(fname, std::ios::in);
|
||||
}
|
||||
@ -14,9 +13,9 @@ namespace nntpchan
|
||||
{
|
||||
f->open(fname, std::ios::out);
|
||||
}
|
||||
if(f->is_open())
|
||||
if (f->is_open())
|
||||
return FileHandle_ptr(f);
|
||||
delete f;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,40 +1,45 @@
|
||||
#include <nntpchan/line.hpp>
|
||||
|
||||
namespace nntpchan {
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
LineReader::LineReader(size_t limit) : m_close(false), lineLimit(limit) {}
|
||||
LineReader::LineReader(size_t limit) : m_close(false), lineLimit(limit) {}
|
||||
|
||||
void LineReader::Data(const char * data, ssize_t l)
|
||||
{
|
||||
if(l <= 0) return;
|
||||
void LineReader::Data(const char *data, ssize_t l)
|
||||
{
|
||||
if (l <= 0)
|
||||
return;
|
||||
// process leftovers
|
||||
std::size_t idx = 0;
|
||||
std::size_t pos = 0;
|
||||
while(l-- > 0) {
|
||||
while (l-- > 0)
|
||||
{
|
||||
char c = data[idx++];
|
||||
if(c == '\n') {
|
||||
if (c == '\n')
|
||||
{
|
||||
OnLine(data, pos);
|
||||
pos = 0;
|
||||
data += idx;
|
||||
} else if (c == '\r' && data[idx] == '\n') {
|
||||
}
|
||||
else if (c == '\r' && data[idx] == '\n')
|
||||
{
|
||||
OnLine(data, pos);
|
||||
data += idx + 1;
|
||||
pos = 0;
|
||||
} else {
|
||||
pos ++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LineReader::OnLine(const char *d, const size_t l)
|
||||
else
|
||||
{
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void LineReader::OnLine(const char *d, const size_t l)
|
||||
{
|
||||
std::string line;
|
||||
line += std::string(d, l);
|
||||
HandleLine(line);
|
||||
}
|
||||
|
||||
bool LineReader::ShouldClose()
|
||||
{
|
||||
return m_close;
|
||||
}
|
||||
}
|
||||
|
||||
bool LineReader::ShouldClose() { return m_close; }
|
||||
}
|
||||
|
@ -2,25 +2,25 @@
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
bool ReadHeader(const FileHandle_ptr & file, RawHeader & header)
|
||||
{
|
||||
bool ReadHeader(const FileHandle_ptr &file, RawHeader &header)
|
||||
{
|
||||
std::string line;
|
||||
while(std::getline(*file, line) && !(line == "\r" || line == ""))
|
||||
while (std::getline(*file, line) && !(line == "\r" || line == ""))
|
||||
{
|
||||
std::string k, v;
|
||||
auto idx = line.find(": ");
|
||||
auto endidx = line.size() - 1;
|
||||
|
||||
while(line[endidx] == '\r') --endidx;
|
||||
while (line[endidx] == '\r')
|
||||
--endidx;
|
||||
|
||||
if(idx != std::string::npos && idx + 2 < endidx)
|
||||
if (idx != std::string::npos && idx + 2 < endidx)
|
||||
{
|
||||
k = line.substr(0, idx);
|
||||
v = line.substr(idx+2, endidx);
|
||||
v = line.substr(idx + 2, endidx);
|
||||
header[k] = v;
|
||||
}
|
||||
}
|
||||
return file->good();
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
@ -1,44 +1,44 @@
|
||||
#include <cstring>
|
||||
#include <nntpchan/net.hpp>
|
||||
#include <uv.h>
|
||||
#include <sstream>
|
||||
#include <stdexcept>
|
||||
#include <cstring>
|
||||
#include <uv.h>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
std::string NetAddr::to_string()
|
||||
{
|
||||
std::string NetAddr::to_string()
|
||||
{
|
||||
std::string str("invalid");
|
||||
const size_t s = 128;
|
||||
char * buff = new char[s];
|
||||
if(uv_ip6_name(&addr, buff, s) == 0) {
|
||||
char *buff = new char[s];
|
||||
if (uv_ip6_name(&addr, buff, s) == 0)
|
||||
{
|
||||
str = std::string(buff);
|
||||
delete [] buff;
|
||||
delete[] buff;
|
||||
}
|
||||
std::stringstream ss;
|
||||
ss << "[" << str << "]:" << ntohs(addr.sin6_port);
|
||||
return ss.str();
|
||||
}
|
||||
}
|
||||
|
||||
NetAddr::NetAddr()
|
||||
{
|
||||
std::memset(&addr, 0, sizeof(addr));
|
||||
}
|
||||
NetAddr::NetAddr() { std::memset(&addr, 0, sizeof(addr)); }
|
||||
|
||||
NetAddr ParseAddr(const std::string & addr)
|
||||
{
|
||||
NetAddr ParseAddr(const std::string &addr)
|
||||
{
|
||||
NetAddr saddr;
|
||||
auto n = addr.rfind("]:");
|
||||
if (n == std::string::npos) {
|
||||
throw std::runtime_error("invalid address: "+addr);
|
||||
if (n == std::string::npos)
|
||||
{
|
||||
throw std::runtime_error("invalid address: " + addr);
|
||||
}
|
||||
if (addr[0] != '[') {
|
||||
throw std::runtime_error("invalid address: "+addr);
|
||||
if (addr[0] != '[')
|
||||
{
|
||||
throw std::runtime_error("invalid address: " + addr);
|
||||
}
|
||||
auto p = addr.substr(n+2);
|
||||
auto p = addr.substr(n + 2);
|
||||
int port = std::atoi(p.c_str());
|
||||
auto a = addr.substr(0, n);
|
||||
uv_ip6_addr(a.c_str(), port, &saddr.addr);
|
||||
return saddr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,16 +1,16 @@
|
||||
#include <nntpchan/nntp_auth.hpp>
|
||||
#include <nntpchan/crypto.hpp>
|
||||
#include <nntpchan/base64.hpp>
|
||||
#include <array>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
#include <nntpchan/base64.hpp>
|
||||
#include <nntpchan/crypto.hpp>
|
||||
#include <nntpchan/nntp_auth.hpp>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
HashedCredDB::HashedCredDB() : LineReader(1024) {}
|
||||
HashedCredDB::HashedCredDB() : LineReader(1024) {}
|
||||
|
||||
bool HashedCredDB::CheckLogin(const std::string & user, const std::string & passwd)
|
||||
{
|
||||
bool HashedCredDB::CheckLogin(const std::string &user, const std::string &passwd)
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(m_access);
|
||||
m_found = false;
|
||||
m_user = user;
|
||||
@ -18,82 +18,80 @@ namespace nntpchan
|
||||
m_instream->seekg(0, std::ios::end);
|
||||
const auto l = m_instream->tellg();
|
||||
m_instream->seekg(0, std::ios::beg);
|
||||
char * buff = new char[l];
|
||||
char *buff = new char[l];
|
||||
// read file
|
||||
m_instream->read(buff, l);
|
||||
Data(buff, l);
|
||||
delete [] buff;
|
||||
delete[] buff;
|
||||
return m_found;
|
||||
}
|
||||
}
|
||||
|
||||
bool HashedCredDB::ProcessLine(const std::string & line)
|
||||
{
|
||||
bool HashedCredDB::ProcessLine(const std::string &line)
|
||||
{
|
||||
// strip comments
|
||||
auto comment = line.find("#");
|
||||
std::string part = line;
|
||||
for (; comment != std::string::npos; comment = part.find("#")) {
|
||||
if(comment)
|
||||
for (; comment != std::string::npos; comment = part.find("#"))
|
||||
{
|
||||
if (comment)
|
||||
part = part.substr(0, comment);
|
||||
else break;
|
||||
else
|
||||
break;
|
||||
}
|
||||
if(!part.size()) return false; // empty line after comments
|
||||
if (!part.size())
|
||||
return false; // empty line after comments
|
||||
auto idx = part.find(":");
|
||||
if (idx == std::string::npos) return false; // bad format
|
||||
if (m_user != part.substr(0, idx)) return false; // username mismatch
|
||||
part = part.substr(idx+1);
|
||||
if (idx == std::string::npos)
|
||||
return false; // bad format
|
||||
if (m_user != part.substr(0, idx))
|
||||
return false; // username mismatch
|
||||
part = part.substr(idx + 1);
|
||||
|
||||
idx = part.find(":");
|
||||
if (idx == std::string::npos) return false; // bad format
|
||||
if (idx == std::string::npos)
|
||||
return false; // bad format
|
||||
std::string cred = part.substr(0, idx);
|
||||
std::string salt = part.substr(idx+1);
|
||||
std::string salt = part.substr(idx + 1);
|
||||
return Hash(m_passwd, salt) == cred;
|
||||
}
|
||||
}
|
||||
|
||||
void HashedCredDB::HandleLine(const std::string &line)
|
||||
{
|
||||
if(m_found) return;
|
||||
if(ProcessLine(line))
|
||||
void HashedCredDB::HandleLine(const std::string &line)
|
||||
{
|
||||
if (m_found)
|
||||
return;
|
||||
if (ProcessLine(line))
|
||||
m_found = true;
|
||||
}
|
||||
}
|
||||
|
||||
void HashedCredDB::SetStream(std::istream * s)
|
||||
{
|
||||
m_instream = s;
|
||||
}
|
||||
void HashedCredDB::SetStream(std::istream *s) { m_instream = s; }
|
||||
|
||||
std::string HashedCredDB::Hash(const std::string & data, const std::string & salt)
|
||||
{
|
||||
std::string HashedCredDB::Hash(const std::string &data, const std::string &salt)
|
||||
{
|
||||
SHA512Digest h;
|
||||
std::string d = data + salt;
|
||||
SHA512((const uint8_t*)d.c_str(), d.size(), h);
|
||||
SHA512((const uint8_t *)d.c_str(), d.size(), h);
|
||||
return B64Encode(h.data(), h.size());
|
||||
}
|
||||
}
|
||||
|
||||
HashedFileDB::HashedFileDB(const std::string & fname) :
|
||||
m_fname(fname),
|
||||
f(nullptr)
|
||||
{
|
||||
HashedFileDB::HashedFileDB(const std::string &fname) : m_fname(fname), f(nullptr) {}
|
||||
|
||||
}
|
||||
HashedFileDB::~HashedFileDB() {}
|
||||
|
||||
HashedFileDB::~HashedFileDB()
|
||||
{
|
||||
}
|
||||
|
||||
void HashedFileDB::Close()
|
||||
{
|
||||
if(f.is_open())
|
||||
void HashedFileDB::Close()
|
||||
{
|
||||
if (f.is_open())
|
||||
f.close();
|
||||
}
|
||||
}
|
||||
|
||||
bool HashedFileDB::Open()
|
||||
{
|
||||
if(!f.is_open())
|
||||
bool HashedFileDB::Open()
|
||||
{
|
||||
if (!f.is_open())
|
||||
f.open(m_fname);
|
||||
if(f.is_open()) {
|
||||
if (f.is_open())
|
||||
{
|
||||
SetStream(&f);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,44 +1,40 @@
|
||||
#include <nntpchan/nntp_handler.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <iostream>
|
||||
#include <nntpchan/nntp_handler.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
NNTPServerHandler::NNTPServerHandler(const fs::path & storage) :
|
||||
LineReader(1024),
|
||||
m_article(nullptr),
|
||||
m_auth(nullptr),
|
||||
m_store(std::make_unique<ArticleStorage>(storage)),
|
||||
m_authed(false),
|
||||
m_state(eStateReadCommand)
|
||||
{
|
||||
}
|
||||
NNTPServerHandler::NNTPServerHandler(const fs::path &storage)
|
||||
: LineReader(1024), m_article(nullptr), m_auth(nullptr), m_store(std::make_unique<ArticleStorage>(storage)),
|
||||
m_authed(false), m_state(eStateReadCommand)
|
||||
{
|
||||
}
|
||||
|
||||
NNTPServerHandler::~NNTPServerHandler()
|
||||
{
|
||||
}
|
||||
NNTPServerHandler::~NNTPServerHandler() {}
|
||||
|
||||
void NNTPServerHandler::HandleLine(const std::string &line)
|
||||
{
|
||||
if(m_state == eStateReadCommand)
|
||||
void NNTPServerHandler::HandleLine(const std::string &line)
|
||||
{
|
||||
if (m_state == eStateReadCommand)
|
||||
{
|
||||
std::deque<std::string> command;
|
||||
std::istringstream s;
|
||||
s.str(line);
|
||||
for (std::string part; std::getline(s, part, ' '); ) {
|
||||
if(part.size()) command.push_back(part);
|
||||
for (std::string part; std::getline(s, part, ' ');)
|
||||
{
|
||||
if (part.size())
|
||||
command.push_back(part);
|
||||
}
|
||||
if(command.size())
|
||||
if (command.size())
|
||||
HandleCommand(command);
|
||||
else
|
||||
QueueLine("501 Syntax error");
|
||||
}
|
||||
else if(m_state == eStateStoreArticle)
|
||||
else if (m_state == eStateStoreArticle)
|
||||
{
|
||||
std::string l = line + "\r\n";
|
||||
OnData(l.c_str(), l.size());
|
||||
@ -47,28 +43,29 @@ namespace nntpchan
|
||||
{
|
||||
std::cerr << "invalid state" << std::endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void NNTPServerHandler::OnData(const char * data, ssize_t l)
|
||||
void NNTPServerHandler::OnData(const char *data, ssize_t l)
|
||||
{
|
||||
if (l <= 0)
|
||||
return;
|
||||
if (m_state == eStateStoreArticle)
|
||||
{
|
||||
if(l <= 0 ) return;
|
||||
if(m_state == eStateStoreArticle)
|
||||
const char *end = strstr(data, "\r\n.\r\n");
|
||||
if (end)
|
||||
{
|
||||
const char * end = strstr(data, "\r\n.\r\n");
|
||||
if(end)
|
||||
std::size_t diff = end - data;
|
||||
if (m_article)
|
||||
{
|
||||
std::size_t diff = end - data ;
|
||||
if(m_article)
|
||||
{
|
||||
m_article->write(data, diff+2);
|
||||
m_article->write(data, diff + 2);
|
||||
m_article->flush();
|
||||
}
|
||||
ArticleObtained();
|
||||
diff += 5;
|
||||
Data(end+5, l-diff);
|
||||
Data(end + 5, l - diff);
|
||||
return;
|
||||
}
|
||||
if(m_article)
|
||||
if (m_article)
|
||||
{
|
||||
m_article->write(data, l);
|
||||
m_article->flush();
|
||||
@ -76,17 +73,18 @@ namespace nntpchan
|
||||
}
|
||||
else
|
||||
Data(data, l);
|
||||
}
|
||||
}
|
||||
|
||||
void NNTPServerHandler::HandleCommand(const std::deque<std::string> & command)
|
||||
{
|
||||
void NNTPServerHandler::HandleCommand(const std::deque<std::string> &command)
|
||||
{
|
||||
auto cmd = command[0];
|
||||
std::transform(cmd.begin(), cmd.end(), cmd.begin(), ::toupper);
|
||||
std::size_t cmdlen = command.size();
|
||||
for(const auto & part : command)
|
||||
for (const auto &part : command)
|
||||
std::cerr << " " << part;
|
||||
std::cerr << std::endl;
|
||||
if (cmd == "QUIT") {
|
||||
if (cmd == "QUIT")
|
||||
{
|
||||
Quit();
|
||||
return;
|
||||
}
|
||||
@ -94,41 +92,54 @@ namespace nntpchan
|
||||
{
|
||||
return;
|
||||
}
|
||||
else if (cmd == "MODE" ) {
|
||||
if(cmdlen == 2) {
|
||||
else if (cmd == "MODE")
|
||||
{
|
||||
if (cmdlen == 2)
|
||||
{
|
||||
// set mode
|
||||
SwitchMode(command[1]);
|
||||
} else if(cmdlen) {
|
||||
}
|
||||
else if (cmdlen)
|
||||
{
|
||||
// too many arguments
|
||||
QueueLine("500 too many arguments");
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
// get mode
|
||||
QueueLine("500 wrong arguments");
|
||||
}
|
||||
} else if(cmd == "CAPABILITIES") {
|
||||
}
|
||||
else if (cmd == "CAPABILITIES")
|
||||
{
|
||||
QueueLine("101 I support the following:");
|
||||
QueueLine("READER");
|
||||
QueueLine("IMPLEMENTATION nntpchan-daemon");
|
||||
QueueLine("VERSION 2");
|
||||
QueueLine("STREAMING");
|
||||
QueueLine(".");
|
||||
} else if (cmd == "CHECK") {
|
||||
if(cmdlen >= 2) {
|
||||
const std::string & msgid = command[1];
|
||||
if(IsValidMessageID(msgid) && m_store->Accept(msgid))
|
||||
}
|
||||
else if (cmd == "CHECK")
|
||||
{
|
||||
QueueLine("238 "+msgid);
|
||||
if (cmdlen >= 2)
|
||||
{
|
||||
const std::string &msgid = command[1];
|
||||
if (IsValidMessageID(msgid) && m_store->Accept(msgid))
|
||||
{
|
||||
QueueLine("238 " + msgid);
|
||||
}
|
||||
else
|
||||
QueueLine("438 "+msgid);
|
||||
QueueLine("438 " + msgid);
|
||||
}
|
||||
else
|
||||
QueueLine("501 syntax error");
|
||||
} else if (cmd == "TAKETHIS") {
|
||||
}
|
||||
else if (cmd == "TAKETHIS")
|
||||
{
|
||||
if (cmdlen >= 2)
|
||||
{
|
||||
const std::string & msgid = command[1];
|
||||
if(m_store->Accept(msgid))
|
||||
const std::string &msgid = command[1];
|
||||
if (m_store->Accept(msgid))
|
||||
{
|
||||
m_article = m_store->OpenWrite(msgid);
|
||||
}
|
||||
@ -137,83 +148,87 @@ namespace nntpchan
|
||||
return;
|
||||
}
|
||||
QueueLine("501 invalid syntax");
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
// unknown command
|
||||
QueueLine("500 Unknown Command");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void NNTPServerHandler::ArticleObtained()
|
||||
{
|
||||
if(m_article)
|
||||
void NNTPServerHandler::ArticleObtained()
|
||||
{
|
||||
if (m_article)
|
||||
{
|
||||
m_article->close();
|
||||
m_article = nullptr;
|
||||
QueueLine("239 "+m_articleName);
|
||||
QueueLine("239 " + m_articleName);
|
||||
std::cerr << "stored " << m_articleName << std::endl;
|
||||
}
|
||||
else
|
||||
QueueLine("439 "+m_articleName);
|
||||
QueueLine("439 " + m_articleName);
|
||||
m_articleName = "";
|
||||
EnterState(eStateReadCommand);
|
||||
}
|
||||
}
|
||||
|
||||
void NNTPServerHandler::SwitchMode(const std::string & mode)
|
||||
{
|
||||
void NNTPServerHandler::SwitchMode(const std::string &mode)
|
||||
{
|
||||
std::string m = mode;
|
||||
std::transform(m.begin(), m.end(), m.begin(), ::toupper);
|
||||
if (m == "READER") {
|
||||
if (m == "READER")
|
||||
{
|
||||
m_mode = m;
|
||||
if(PostingAllowed()) {
|
||||
if (PostingAllowed())
|
||||
{
|
||||
QueueLine("200 Posting is permitted yo");
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
QueueLine("201 Posting is not permitted yo");
|
||||
}
|
||||
} else if (m == "STREAM") {
|
||||
}
|
||||
else if (m == "STREAM")
|
||||
{
|
||||
m_mode = m;
|
||||
if (PostingAllowed()) {
|
||||
if (PostingAllowed())
|
||||
{
|
||||
QueueLine("203 Streaming enabled");
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
QueueLine("483 Streaming Denied");
|
||||
}
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
// unknown mode
|
||||
QueueLine("500 Unknown mode");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void NNTPServerHandler::EnterState(State st)
|
||||
{
|
||||
void NNTPServerHandler::EnterState(State st)
|
||||
{
|
||||
std::cerr << "enter state " << st << std::endl;
|
||||
m_state = st;
|
||||
}
|
||||
}
|
||||
|
||||
void NNTPServerHandler::Quit()
|
||||
{
|
||||
void NNTPServerHandler::Quit()
|
||||
{
|
||||
EnterState(eStateQuit);
|
||||
QueueLine("205 quitting");
|
||||
}
|
||||
}
|
||||
|
||||
bool NNTPServerHandler::ShouldClose()
|
||||
{
|
||||
return m_state == eStateQuit;
|
||||
}
|
||||
bool NNTPServerHandler::ShouldClose() { return m_state == eStateQuit; }
|
||||
|
||||
bool NNTPServerHandler::PostingAllowed()
|
||||
{
|
||||
return m_authed || m_auth == nullptr;
|
||||
}
|
||||
bool NNTPServerHandler::PostingAllowed() { return m_authed || m_auth == nullptr; }
|
||||
|
||||
void NNTPServerHandler::Greet()
|
||||
{
|
||||
if(PostingAllowed())
|
||||
void NNTPServerHandler::Greet()
|
||||
{
|
||||
if (PostingAllowed())
|
||||
QueueLine("200 Posting allowed");
|
||||
else
|
||||
QueueLine("201 Posting not allowed");
|
||||
}
|
||||
|
||||
void NNTPServerHandler::SetAuth(CredDB_ptr creds)
|
||||
{
|
||||
m_auth = creds;
|
||||
}
|
||||
}
|
||||
|
||||
void NNTPServerHandler::SetAuth(CredDB_ptr creds) { m_auth = creds; }
|
||||
}
|
||||
|
@ -1,85 +1,62 @@
|
||||
|
||||
#include <nntpchan/nntp_server.hpp>
|
||||
#include <nntpchan/nntp_auth.hpp>
|
||||
#include <nntpchan/nntp_handler.hpp>
|
||||
#include <nntpchan/net.hpp>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <nntpchan/net.hpp>
|
||||
#include <nntpchan/nntp_auth.hpp>
|
||||
#include <nntpchan/nntp_handler.hpp>
|
||||
#include <nntpchan/nntp_server.hpp>
|
||||
#include <sstream>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
NNTPServer::NNTPServer(uv_loop_t * loop) : Server(loop), m_frontend(nullptr) {}
|
||||
NNTPServer::NNTPServer(uv_loop_t *loop) : Server(loop), m_frontend(nullptr) {}
|
||||
|
||||
NNTPServer::~NNTPServer()
|
||||
{
|
||||
}
|
||||
NNTPServer::~NNTPServer() {}
|
||||
|
||||
IServerConn * NNTPServer::CreateConn(uv_stream_t * s)
|
||||
{
|
||||
IServerConn *NNTPServer::CreateConn(uv_stream_t *s)
|
||||
{
|
||||
CredDB_ptr creds;
|
||||
|
||||
std::ifstream i;
|
||||
i.open(m_logindbpath);
|
||||
if(i.is_open()) creds = std::make_shared<HashedFileDB>(m_logindbpath);
|
||||
if (i.is_open())
|
||||
creds = std::make_shared<HashedFileDB>(m_logindbpath);
|
||||
|
||||
NNTPServerHandler * handler = new NNTPServerHandler(m_storagePath);
|
||||
if(creds)
|
||||
NNTPServerHandler *handler = new NNTPServerHandler(m_storagePath);
|
||||
if (creds)
|
||||
handler->SetAuth(creds);
|
||||
|
||||
NNTPServerConn * conn = new NNTPServerConn(GetLoop(), s, this, handler);
|
||||
NNTPServerConn *conn = new NNTPServerConn(GetLoop(), s, this, handler);
|
||||
return conn;
|
||||
}
|
||||
}
|
||||
|
||||
void NNTPServer::SetLoginDB(const std::string path)
|
||||
void NNTPServer::SetLoginDB(const std::string path) { m_logindbpath = path; }
|
||||
|
||||
void NNTPServer::SetStoragePath(const std::string &path) { m_storagePath = path; }
|
||||
|
||||
void NNTPServer::SetInstanceName(const std::string &name) { m_servername = name; }
|
||||
|
||||
void NNTPServer::SetFrontend(Frontend *f) { m_frontend.reset(f); }
|
||||
|
||||
std::string NNTPServer::InstanceName() const { return m_servername; }
|
||||
|
||||
void NNTPServer::OnAcceptError(int status) { std::cerr << "nntpserver::accept() " << uv_strerror(status) << std::endl; }
|
||||
|
||||
void NNTPServerConn::SendNextReply()
|
||||
{
|
||||
IConnHandler *handler = GetHandler();
|
||||
while (handler->HasNextLine())
|
||||
{
|
||||
m_logindbpath = path;
|
||||
}
|
||||
|
||||
|
||||
void NNTPServer::SetStoragePath(const std::string & path)
|
||||
{
|
||||
m_storagePath = path;
|
||||
}
|
||||
|
||||
void NNTPServer::SetInstanceName(const std::string & name)
|
||||
{
|
||||
m_servername = name;
|
||||
}
|
||||
|
||||
void NNTPServer::SetFrontend(Frontend * f)
|
||||
{
|
||||
m_frontend.reset(f);
|
||||
}
|
||||
|
||||
std::string NNTPServer::InstanceName() const
|
||||
{
|
||||
return m_servername;
|
||||
}
|
||||
|
||||
void NNTPServer::OnAcceptError(int status)
|
||||
{
|
||||
std::cerr << "nntpserver::accept() " << uv_strerror(status) << std::endl;
|
||||
}
|
||||
|
||||
void NNTPServerConn::SendNextReply()
|
||||
{
|
||||
IConnHandler * handler = GetHandler();
|
||||
while(handler->HasNextLine()) {
|
||||
auto line = handler->GetNextLine();
|
||||
SendString(line + "\r\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void NNTPServerConn::Greet()
|
||||
{
|
||||
IConnHandler * handler = GetHandler();
|
||||
void NNTPServerConn::Greet()
|
||||
{
|
||||
IConnHandler *handler = GetHandler();
|
||||
handler->Greet();
|
||||
SendNextReply();
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
@ -1,49 +1,45 @@
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <algorithm>
|
||||
#include <regex>
|
||||
#include <cctype>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <regex>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
std::string NNTPSanitizeLine(const std::string & str)
|
||||
{
|
||||
if(str == ".") return " .";
|
||||
std::string NNTPSanitizeLine(const std::string &str)
|
||||
{
|
||||
if (str == ".")
|
||||
return " .";
|
||||
std::string sane;
|
||||
sane += str;
|
||||
const char ch = ' ';
|
||||
std::replace_if(sane.begin(), sane.end(), [](unsigned char ch) -> bool { return iscntrl(ch); } , ch);
|
||||
std::replace_if(sane.begin(), sane.end(), [](unsigned char ch) -> bool { return iscntrl(ch); }, ch);
|
||||
return sane;
|
||||
}
|
||||
}
|
||||
|
||||
std::string ToLower(const std::string & str)
|
||||
{
|
||||
std::string ToLower(const std::string &str)
|
||||
{
|
||||
std::string lower = str;
|
||||
std::transform(lower.begin(), lower.end(), lower.begin(), [](unsigned char ch) -> unsigned char { return std::tolower(ch); } );
|
||||
std::transform(lower.begin(), lower.end(), lower.begin(),
|
||||
[](unsigned char ch) -> unsigned char { return std::tolower(ch); });
|
||||
return lower;
|
||||
}
|
||||
}
|
||||
|
||||
static const std::regex re_ValidMessageID("^<[a-zA-Z0-9$\\._]{2,128}@[a-zA-Z0-9\\-\\.]{2,63}>$");
|
||||
static const std::regex re_ValidMessageID("^<[a-zA-Z0-9$\\._]{2,128}@[a-zA-Z0-9\\-\\.]{2,63}>$");
|
||||
|
||||
bool IsValidMessageID(const std::string & msgid)
|
||||
{
|
||||
return std::regex_search(msgid, re_ValidMessageID) == 1;
|
||||
}
|
||||
bool IsValidMessageID(const std::string &msgid) { return std::regex_search(msgid, re_ValidMessageID) == 1; }
|
||||
|
||||
static const std::regex re_ValidNewsgroup("^[a-zA-Z][a-zA-Z0-9.]{1,128}$");
|
||||
static const std::regex re_ValidNewsgroup("^[a-zA-Z][a-zA-Z0-9.]{1,128}$");
|
||||
|
||||
bool IsValidNewsgroup(const std::string & msgid)
|
||||
{
|
||||
return std::regex_search(msgid, re_ValidNewsgroup) == 1;
|
||||
}
|
||||
bool IsValidNewsgroup(const std::string &msgid) { return std::regex_search(msgid, re_ValidNewsgroup) == 1; }
|
||||
|
||||
std::string StripWhitespaces(const std::string & str)
|
||||
{
|
||||
std::string StripWhitespaces(const std::string &str)
|
||||
{
|
||||
std::string stripped;
|
||||
for(const auto & ch : str)
|
||||
if(!(std::isspace(ch)||std::iscntrl(ch)))
|
||||
for (const auto &ch : str)
|
||||
if (!(std::isspace(ch) || std::iscntrl(ch)))
|
||||
stripped += ch;
|
||||
|
||||
return stripped;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,107 +1,111 @@
|
||||
#include <nntpchan/buffer.hpp>
|
||||
#include <nntpchan/server.hpp>
|
||||
#include <nntpchan/net.hpp>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <nntpchan/buffer.hpp>
|
||||
#include <nntpchan/net.hpp>
|
||||
#include <nntpchan/server.hpp>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
Server::Server(uv_loop_t * loop)
|
||||
{
|
||||
Server::Server(uv_loop_t *loop)
|
||||
{
|
||||
m_loop = loop;
|
||||
uv_tcp_init(m_loop, &m_server);
|
||||
m_server.data = this;
|
||||
}
|
||||
}
|
||||
|
||||
void Server::Close()
|
||||
{
|
||||
void Server::Close()
|
||||
{
|
||||
std::cout << "Close server" << std::endl;
|
||||
uv_close((uv_handle_t*)&m_server, [](uv_handle_t * s) {
|
||||
Server * self = (Server*)s->data;
|
||||
if (self) delete self;
|
||||
uv_close((uv_handle_t *)&m_server, [](uv_handle_t *s) {
|
||||
Server *self = (Server *)s->data;
|
||||
if (self)
|
||||
delete self;
|
||||
s->data = nullptr;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void Server::Bind(const std::string & addr)
|
||||
{
|
||||
void Server::Bind(const std::string &addr)
|
||||
{
|
||||
auto saddr = ParseAddr(addr);
|
||||
assert(uv_tcp_bind(*this, saddr, 0) == 0);
|
||||
auto cb = [] (uv_stream_t * s, int status) {
|
||||
Server * self = (Server *) s->data;
|
||||
auto cb = [](uv_stream_t *s, int status) {
|
||||
Server *self = (Server *)s->data;
|
||||
self->OnAccept(s, status);
|
||||
};
|
||||
assert(uv_listen(*this, 5, cb) == 0);
|
||||
}
|
||||
}
|
||||
|
||||
void Server::OnAccept(uv_stream_t * s, int status)
|
||||
void Server::OnAccept(uv_stream_t *s, int status)
|
||||
{
|
||||
if (status < 0)
|
||||
{
|
||||
if(status < 0) {
|
||||
OnAcceptError(status);
|
||||
return;
|
||||
}
|
||||
IServerConn * conn = CreateConn(s);
|
||||
IServerConn *conn = CreateConn(s);
|
||||
assert(conn);
|
||||
m_conns.push_back(conn);
|
||||
conn->Greet();
|
||||
}
|
||||
}
|
||||
|
||||
void Server::RemoveConn(IServerConn * conn)
|
||||
{
|
||||
void Server::RemoveConn(IServerConn *conn)
|
||||
{
|
||||
auto itr = m_conns.begin();
|
||||
while(itr != m_conns.end())
|
||||
while (itr != m_conns.end())
|
||||
{
|
||||
if(*itr == conn)
|
||||
if (*itr == conn)
|
||||
itr = m_conns.erase(itr);
|
||||
else
|
||||
++itr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void IConnHandler::QueueLine(const std::string & line)
|
||||
{
|
||||
m_sendlines.push_back(line);
|
||||
}
|
||||
void IConnHandler::QueueLine(const std::string &line) { m_sendlines.push_back(line); }
|
||||
|
||||
bool IConnHandler::HasNextLine()
|
||||
{
|
||||
return m_sendlines.size() > 0;
|
||||
}
|
||||
bool IConnHandler::HasNextLine() { return m_sendlines.size() > 0; }
|
||||
|
||||
std::string IConnHandler::GetNextLine()
|
||||
{
|
||||
std::string IConnHandler::GetNextLine()
|
||||
{
|
||||
std::string line = m_sendlines[0];
|
||||
m_sendlines.pop_front();
|
||||
return line;
|
||||
}
|
||||
}
|
||||
|
||||
IServerConn::IServerConn(uv_loop_t * l, uv_stream_t * st, Server * parent, IConnHandler * h)
|
||||
{
|
||||
IServerConn::IServerConn(uv_loop_t *l, uv_stream_t *st, Server *parent, IConnHandler *h)
|
||||
{
|
||||
m_loop = l;
|
||||
m_parent = parent;
|
||||
m_handler = h;
|
||||
uv_tcp_init(l, &m_conn);
|
||||
m_conn.data = this;
|
||||
uv_accept(st, (uv_stream_t*) &m_conn);
|
||||
uv_read_start((uv_stream_t*) &m_conn, [] (uv_handle_t * h, size_t s, uv_buf_t * b) {
|
||||
IServerConn * self = (IServerConn*) h->data;
|
||||
if(self == nullptr) return;
|
||||
uv_accept(st, (uv_stream_t *)&m_conn);
|
||||
uv_read_start((uv_stream_t *)&m_conn,
|
||||
[](uv_handle_t *h, size_t s, uv_buf_t *b) {
|
||||
IServerConn *self = (IServerConn *)h->data;
|
||||
if (self == nullptr)
|
||||
return;
|
||||
b->base = new char[s];
|
||||
}, [] (uv_stream_t * s, ssize_t nread, const uv_buf_t * b) {
|
||||
IServerConn * self = (IServerConn*) s->data;
|
||||
if(self == nullptr) {
|
||||
if(b->base)
|
||||
delete [] b->base;
|
||||
},
|
||||
[](uv_stream_t *s, ssize_t nread, const uv_buf_t *b) {
|
||||
IServerConn *self = (IServerConn *)s->data;
|
||||
if (self == nullptr)
|
||||
{
|
||||
if (b->base)
|
||||
delete[] b->base;
|
||||
return;
|
||||
}
|
||||
if(nread > 0) {
|
||||
if (nread > 0)
|
||||
{
|
||||
self->m_handler->OnData(b->base, nread);
|
||||
self->SendNextReply();
|
||||
if(self->m_handler->ShouldClose())
|
||||
if (self->m_handler->ShouldClose())
|
||||
self->Close();
|
||||
delete [] b->base;
|
||||
} else {
|
||||
if (nread != UV_EOF) {
|
||||
delete[] b->base;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (nread != UV_EOF)
|
||||
{
|
||||
std::cerr << "error in nntp server conn alloc: ";
|
||||
std::cerr << uv_strerror(nread);
|
||||
std::cerr << std::endl;
|
||||
@ -110,32 +114,29 @@ namespace nntpchan
|
||||
self->Close();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
IServerConn::~IServerConn()
|
||||
{
|
||||
delete m_handler;
|
||||
}
|
||||
IServerConn::~IServerConn() { delete m_handler; }
|
||||
|
||||
void IServerConn::SendString(const std::string & str)
|
||||
{
|
||||
WriteBuffer * b = new WriteBuffer(str);
|
||||
uv_write(&b->w, (uv_stream_t*)&m_conn, &b->b, 1, [](uv_write_t * w, int status) {
|
||||
(void) status;
|
||||
WriteBuffer * wb = (WriteBuffer *) w->data;
|
||||
if(wb)
|
||||
void IServerConn::SendString(const std::string &str)
|
||||
{
|
||||
WriteBuffer *b = new WriteBuffer(str);
|
||||
uv_write(&b->w, (uv_stream_t *)&m_conn, &b->b, 1, [](uv_write_t *w, int status) {
|
||||
(void)status;
|
||||
WriteBuffer *wb = (WriteBuffer *)w->data;
|
||||
if (wb)
|
||||
delete wb;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
void IServerConn::Close()
|
||||
{
|
||||
void IServerConn::Close()
|
||||
{
|
||||
m_parent->RemoveConn(this);
|
||||
uv_close((uv_handle_t*)&m_conn, [] (uv_handle_t * s) {
|
||||
IServerConn * self = (IServerConn*) s->data;
|
||||
if(self)
|
||||
uv_close((uv_handle_t *)&m_conn, [](uv_handle_t *s) {
|
||||
IServerConn *self = (IServerConn *)s->data;
|
||||
if (self)
|
||||
delete self;
|
||||
s->data = nullptr;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -27,42 +27,45 @@ extern "C" {
|
||||
/* for uint32_t */
|
||||
#include <stdint.h>
|
||||
|
||||
|
||||
|
||||
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
|
||||
|
||||
/* blk0() and blk() perform the initial expand. */
|
||||
/* I got the idea of expanding during the round function from SSLeay */
|
||||
#if BYTE_ORDER == LITTLE_ENDIAN
|
||||
#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
|
||||
|(rol(block->l[i],8)&0x00FF00FF))
|
||||
#define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF))
|
||||
#elif BYTE_ORDER == BIG_ENDIAN
|
||||
#define blk0(i) block->l[i]
|
||||
#else
|
||||
#error "Endianness not defined!"
|
||||
#endif
|
||||
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
|
||||
^block->l[(i+2)&15]^block->l[i&15],1))
|
||||
#define blk(i) \
|
||||
(block->l[i & 15] = \
|
||||
rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
|
||||
|
||||
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
|
||||
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
|
||||
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
|
||||
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
|
||||
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
|
||||
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
|
||||
|
||||
#define R0(v, w, x, y, z, i) \
|
||||
z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
|
||||
w = rol(w, 30);
|
||||
#define R1(v, w, x, y, z, i) \
|
||||
z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
|
||||
w = rol(w, 30);
|
||||
#define R2(v, w, x, y, z, i) \
|
||||
z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
|
||||
w = rol(w, 30);
|
||||
#define R3(v, w, x, y, z, i) \
|
||||
z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
|
||||
w = rol(w, 30);
|
||||
#define R4(v, w, x, y, z, i) \
|
||||
z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
|
||||
w = rol(w, 30);
|
||||
|
||||
/* Hash a single 512-bit block. This is the core of the algorithm. */
|
||||
|
||||
void SHA1Transform(
|
||||
uint32_t state[5],
|
||||
const unsigned char buffer[64]
|
||||
)
|
||||
void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
|
||||
{
|
||||
uint32_t a, b, c, d, e;
|
||||
|
||||
typedef union
|
||||
{
|
||||
typedef union {
|
||||
unsigned char c[64];
|
||||
uint32_t l[16];
|
||||
} CHAR64LONG16;
|
||||
@ -77,7 +80,7 @@ void SHA1Transform(
|
||||
* And the result is written through. I threw a "const" in, hoping
|
||||
* this will cause a diagnostic.
|
||||
*/
|
||||
CHAR64LONG16 *block = (const CHAR64LONG16 *) buffer;
|
||||
CHAR64LONG16 *block = (const CHAR64LONG16 *)buffer;
|
||||
#endif
|
||||
/* Copy context->state[] to working vars */
|
||||
a = state[0];
|
||||
@ -179,12 +182,9 @@ void SHA1Transform(
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* SHA1Init - Initialize new context */
|
||||
|
||||
void SHA1Init(
|
||||
SHA1_CTX * context
|
||||
)
|
||||
void SHA1Init(SHA1_CTX *context)
|
||||
{
|
||||
/* SHA1 initialization constants */
|
||||
context->state[0] = 0x67452301;
|
||||
@ -195,14 +195,9 @@ void SHA1Init(
|
||||
context->count[0] = context->count[1] = 0;
|
||||
}
|
||||
|
||||
|
||||
/* Run your data through this. */
|
||||
|
||||
void SHA1Update(
|
||||
SHA1_CTX * context,
|
||||
const unsigned char *data,
|
||||
uint32_t len
|
||||
)
|
||||
void SHA1Update(SHA1_CTX *context, const unsigned char *data, uint32_t len)
|
||||
{
|
||||
uint32_t i;
|
||||
|
||||
@ -228,13 +223,9 @@ void SHA1Update(
|
||||
memcpy(&context->buffer[j], &data[i], len - i);
|
||||
}
|
||||
|
||||
|
||||
/* Add padding and return the message digest. */
|
||||
|
||||
void SHA1Final(
|
||||
unsigned char digest[20],
|
||||
SHA1_CTX * context
|
||||
)
|
||||
void SHA1Final(unsigned char digest[20], SHA1_CTX *context)
|
||||
{
|
||||
unsigned i;
|
||||
|
||||
@ -261,7 +252,8 @@ void SHA1Final(
|
||||
#else
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
|
||||
finalcount[i] =
|
||||
(unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
|
||||
}
|
||||
#endif
|
||||
c = 0200;
|
||||
@ -274,54 +266,49 @@ void SHA1Final(
|
||||
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
|
||||
for (i = 0; i < 20; i++)
|
||||
{
|
||||
digest[i] = (unsigned char)
|
||||
((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
|
||||
digest[i] = (unsigned char)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
|
||||
}
|
||||
/* Wipe variables */
|
||||
memset(context, '\0', sizeof(*context));
|
||||
memset(&finalcount, '\0', sizeof(finalcount));
|
||||
}
|
||||
|
||||
void sha1(
|
||||
uint8_t *hash_out,
|
||||
const uint8_t *str,
|
||||
size_t len)
|
||||
void sha1(uint8_t *hash_out, const uint8_t *str, size_t len)
|
||||
{
|
||||
SHA1_CTX ctx;
|
||||
size_t ii;
|
||||
|
||||
SHA1Init(&ctx);
|
||||
for (ii=0; ii<len; ii+=1)
|
||||
for (ii = 0; ii < len; ii += 1)
|
||||
SHA1Update(&ctx, str + ii, 1);
|
||||
SHA1Final(hash_out, &ctx);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
static inline char nibble_to_char(uint8_t n)
|
||||
{
|
||||
if(n >= 10)
|
||||
static inline char nibble_to_char(uint8_t n)
|
||||
{
|
||||
if (n >= 10)
|
||||
return n + 87;
|
||||
else
|
||||
return n + 48;
|
||||
}
|
||||
}
|
||||
|
||||
std::string sha1_hex(const std::string & data)
|
||||
{
|
||||
std::string sha1_hex(const std::string &data)
|
||||
{
|
||||
uint8_t digest[20];
|
||||
const uint8_t * ptr = (uint8_t*) data.c_str();
|
||||
const uint8_t *ptr = (uint8_t *)data.c_str();
|
||||
sha1(digest, ptr, data.size());
|
||||
std::string out;
|
||||
std::size_t idx = 0;
|
||||
while(idx < 20)
|
||||
while (idx < 20)
|
||||
{
|
||||
out += nibble_to_char((digest[idx] & 0xf0) >> 8) + nibble_to_char(digest[idx] & 0x0f);
|
||||
++idx;
|
||||
}
|
||||
|
||||
return out;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,34 +1,31 @@
|
||||
#include <nntpchan/staticfile_frontend.hpp>
|
||||
#include <nntpchan/file_handle.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <nntpchan/mime.hpp>
|
||||
#include <nntpchan/sha1.hpp>
|
||||
#include <any>
|
||||
#include <iostream>
|
||||
#include <nntpchan/file_handle.hpp>
|
||||
#include <nntpchan/mime.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <nntpchan/sha1.hpp>
|
||||
#include <nntpchan/staticfile_frontend.hpp>
|
||||
#include <set>
|
||||
#include <sstream>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
StaticFileFrontend::StaticFileFrontend(TemplateEngine *tmpl, const std::string &templateDir, const std::string &outDir,
|
||||
uint32_t pages)
|
||||
: m_TemplateEngine(tmpl), m_TemplateDir(templateDir), m_OutDir(outDir), m_Pages(pages)
|
||||
{
|
||||
}
|
||||
|
||||
StaticFileFrontend::StaticFileFrontend(TemplateEngine * tmpl, const std::string & templateDir, const std::string & outDir, uint32_t pages) :
|
||||
m_TemplateEngine(tmpl),
|
||||
m_TemplateDir(templateDir),
|
||||
m_OutDir(outDir),
|
||||
m_Pages(pages)
|
||||
{
|
||||
}
|
||||
|
||||
void StaticFileFrontend::ProcessNewMessage(const fs::path & fpath)
|
||||
{
|
||||
void StaticFileFrontend::ProcessNewMessage(const fs::path &fpath)
|
||||
{
|
||||
std::clog << "process message " << fpath << std::endl;
|
||||
auto file = OpenFile(fpath, eRead);
|
||||
if(file)
|
||||
if (file)
|
||||
{
|
||||
// read header
|
||||
RawHeader header;
|
||||
if(!ReadHeader(file, header))
|
||||
if (!ReadHeader(file, header))
|
||||
{
|
||||
std::clog << "failed to read mime header" << std::endl;
|
||||
return;
|
||||
@ -36,14 +33,13 @@ namespace nntpchan
|
||||
|
||||
// read body
|
||||
|
||||
|
||||
auto findMsgidFunc = [](const std::pair<std::string, std::string> & item) -> bool {
|
||||
auto findMsgidFunc = [](const std::pair<std::string, std::string> &item) -> bool {
|
||||
auto lower = ToLower(item.first);
|
||||
return (lower == "message-id") || (lower == "messageid");
|
||||
};
|
||||
|
||||
auto msgid_itr = std::find_if(header.begin(), header.end(), findMsgidFunc);
|
||||
if(msgid_itr == std::end(header))
|
||||
if (msgid_itr == std::end(header))
|
||||
{
|
||||
std::clog << "no message id for file " << fpath << std::endl;
|
||||
return;
|
||||
@ -51,7 +47,7 @@ namespace nntpchan
|
||||
|
||||
std::string msgid = StripWhitespaces(msgid_itr->second);
|
||||
|
||||
if(!IsValidMessageID(msgid))
|
||||
if (!IsValidMessageID(msgid))
|
||||
{
|
||||
std::clog << "invalid message-id: " << msgid << std::endl;
|
||||
return;
|
||||
@ -59,21 +55,21 @@ namespace nntpchan
|
||||
|
||||
std::string rootmsgid;
|
||||
|
||||
auto findReferences = [](const std::pair<std::string, std::string> & item) -> bool {
|
||||
auto findReferences = [](const std::pair<std::string, std::string> &item) -> bool {
|
||||
auto lower = ToLower(item.first);
|
||||
return lower == "references";
|
||||
};
|
||||
|
||||
auto references_itr = std::find_if(header.begin(), header.end(), findReferences);
|
||||
if(references_itr == std::end(header) || StripWhitespaces(references_itr->second).size() == 0)
|
||||
if (references_itr == std::end(header) || StripWhitespaces(references_itr->second).size() == 0)
|
||||
{
|
||||
rootmsgid = msgid;
|
||||
}
|
||||
else
|
||||
{
|
||||
const auto & s = references_itr->second;
|
||||
auto checkfunc = [] (unsigned char ch) -> bool { return std::isspace(ch) || std::iscntrl(ch); };
|
||||
if(std::count_if(s.begin(), s.end(), checkfunc))
|
||||
const auto &s = references_itr->second;
|
||||
auto checkfunc = [](unsigned char ch) -> bool { return std::isspace(ch) || std::iscntrl(ch); };
|
||||
if (std::count_if(s.begin(), s.end(), checkfunc))
|
||||
{
|
||||
/** split off first element */
|
||||
auto idx = std::find_if(s.begin(), s.end(), checkfunc);
|
||||
@ -85,44 +81,16 @@ namespace nntpchan
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
std::string rootmsgid_hash = sha1_hex(rootmsgid);
|
||||
|
||||
fs::path threadFilePath = m_OutDir / fs::path("thread-" + rootmsgid_hash + ".html");
|
||||
nntpchan::model::Thread thread;
|
||||
|
||||
if(!m_MessageDB)
|
||||
{
|
||||
std::clog << "no message database" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
if(!m_MessageDB->LoadThread(thread, rootmsgid))
|
||||
{
|
||||
std::clog << "cannot find thread with root " << rootmsgid << std::endl;
|
||||
return;
|
||||
}
|
||||
TemplateEngine::Args_t thread_args;
|
||||
thread_args["posts"] = thread;
|
||||
if(m_TemplateEngine)
|
||||
{
|
||||
FileHandle_ptr out = OpenFile(threadFilePath, eWrite);
|
||||
if(!out || !m_TemplateEngine->WriteTemplate("thread.mustache", thread_args, out))
|
||||
{
|
||||
std::clog << "failed to write " << threadFilePath << std::endl;
|
||||
return;
|
||||
}
|
||||
}
|
||||
std::set<std::string> newsgroups_list;
|
||||
|
||||
auto findNewsgroupsFunc = [](const std::pair<std::string, std::string> & item) -> bool
|
||||
{
|
||||
auto findNewsgroupsFunc = [](const std::pair<std::string, std::string> &item) -> bool {
|
||||
return ToLower(item.first) == "newsgroups";
|
||||
};
|
||||
|
||||
auto group = std::find_if(header.begin(), header.end(), findNewsgroupsFunc);
|
||||
if(group == std::end(header))
|
||||
if (group == std::end(header))
|
||||
{
|
||||
std::clog << "no newsgroups header" << std::endl;
|
||||
return;
|
||||
@ -130,37 +98,63 @@ namespace nntpchan
|
||||
std::istringstream input(group->second);
|
||||
|
||||
std::string newsgroup;
|
||||
while(std::getline(input, newsgroup, ' '))
|
||||
while (std::getline(input, newsgroup, ' '))
|
||||
{
|
||||
if(IsValidNewsgroup(newsgroup))
|
||||
if (IsValidNewsgroup(newsgroup))
|
||||
newsgroups_list.insert(newsgroup);
|
||||
}
|
||||
|
||||
fs::path threadFilePath = m_OutDir / fs::path("thread-" + rootmsgid_hash + ".html");
|
||||
nntpchan::model::Thread thread;
|
||||
|
||||
if (!m_MessageDB)
|
||||
{
|
||||
std::clog << "no message database" << std::endl;
|
||||
return;
|
||||
}
|
||||
|
||||
if (!m_MessageDB->LoadThread(thread, rootmsgid))
|
||||
{
|
||||
std::clog << "cannot find thread with root " << rootmsgid << std::endl;
|
||||
return;
|
||||
}
|
||||
TemplateEngine::Args_t thread_args;
|
||||
thread_args["posts"] = thread;
|
||||
if (m_TemplateEngine)
|
||||
{
|
||||
FileHandle_ptr out = OpenFile(threadFilePath, eWrite);
|
||||
if (!out || !m_TemplateEngine->WriteTemplate("thread.mustache", thread_args, out))
|
||||
{
|
||||
std::clog << "failed to write " << threadFilePath << std::endl;
|
||||
return;
|
||||
}
|
||||
}
|
||||
nntpchan::model::BoardPage page;
|
||||
for(const auto & name : newsgroups_list)
|
||||
for (const auto &name : newsgroups_list)
|
||||
{
|
||||
uint32_t pageno = 0;
|
||||
while(pageno < m_Pages)
|
||||
while (pageno < m_Pages)
|
||||
{
|
||||
page.clear();
|
||||
if(!m_MessageDB->LoadBoardPage(page, name, 10, m_Pages))
|
||||
if (!m_MessageDB->LoadBoardPage(page, name, 10, m_Pages))
|
||||
{
|
||||
std::clog << "cannot load board page "<< pageno << " for " << name << std::endl;
|
||||
std::clog << "cannot load board page " << pageno << " for " << name << std::endl;
|
||||
break;
|
||||
}
|
||||
TemplateEngine::Args_t page_args;
|
||||
page_args["group"] = name;
|
||||
page_args["threads"] = page;
|
||||
page_args["pageno"] = std::to_string(pageno);
|
||||
if(pageno)
|
||||
page_args["prev_pageno"] = std::to_string(pageno-1);
|
||||
if(pageno+1 < m_Pages)
|
||||
page_args["next_pageno"] = std::to_string(pageno+1);
|
||||
if (pageno)
|
||||
page_args["prev_pageno"] = std::to_string(pageno - 1);
|
||||
if (pageno + 1 < m_Pages)
|
||||
page_args["next_pageno"] = std::to_string(pageno + 1);
|
||||
fs::path boardPageFilename(name + "-" + std::to_string(pageno) + ".html");
|
||||
if(m_TemplateEngine)
|
||||
if (m_TemplateEngine)
|
||||
{
|
||||
fs::path outfile = m_OutDir / boardPageFilename;
|
||||
FileHandle_ptr out = OpenFile(outfile, eWrite);
|
||||
if(out)
|
||||
if (out)
|
||||
m_TemplateEngine->WriteTemplate("board.mustache", page_args, out);
|
||||
else
|
||||
std::clog << "failed to open board page " << outfile << std::endl;
|
||||
@ -170,17 +164,9 @@ namespace nntpchan
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool StaticFileFrontend::AcceptsNewsgroup(const std::string & newsgroup)
|
||||
{
|
||||
return IsValidNewsgroup(newsgroup);
|
||||
}
|
||||
|
||||
bool StaticFileFrontend::AcceptsMessage(const std::string & msgid)
|
||||
{
|
||||
return IsValidMessageID(msgid);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
bool StaticFileFrontend::AcceptsNewsgroup(const std::string &newsgroup) { return IsValidNewsgroup(newsgroup); }
|
||||
|
||||
bool StaticFileFrontend::AcceptsMessage(const std::string &msgid) { return IsValidMessageID(msgid); }
|
||||
}
|
||||
|
@ -1,59 +1,71 @@
|
||||
#include <nntpchan/storage.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <cassert>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <nntpchan/storage.hpp>
|
||||
#include <sstream>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
ArticleStorage::ArticleStorage()
|
||||
{
|
||||
}
|
||||
|
||||
ArticleStorage::ArticleStorage(const fs::path & fpath) {
|
||||
SetPath(fpath);
|
||||
}
|
||||
ArticleStorage::ArticleStorage(const fs::path &fpath) { SetPath(fpath); }
|
||||
|
||||
ArticleStorage::~ArticleStorage()
|
||||
{
|
||||
}
|
||||
ArticleStorage::~ArticleStorage() {}
|
||||
|
||||
void ArticleStorage::SetPath(const fs::path & fpath)
|
||||
{
|
||||
void ArticleStorage::SetPath(const fs::path &fpath)
|
||||
{
|
||||
basedir = fpath;
|
||||
fs::create_directories(basedir);
|
||||
assert(init_skiplist("posts_skiplist"));
|
||||
}
|
||||
}
|
||||
|
||||
bool ArticleStorage::init_skiplist(const std::string & subdir) const
|
||||
{
|
||||
bool ArticleStorage::init_skiplist(const std::string &subdir) const
|
||||
{
|
||||
fs::path skiplist = basedir / fs::path(subdir);
|
||||
fs::create_directories(skiplist);
|
||||
const auto subdirs = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"};
|
||||
for (const auto & s : subdirs)
|
||||
for (const auto &s : subdirs)
|
||||
fs::create_directories(skiplist / s);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
bool ArticleStorage::Accept(const std::string& msgid) const
|
||||
{
|
||||
if (!IsValidMessageID(msgid)) return false;
|
||||
bool ArticleStorage::Accept(const std::string &msgid) const
|
||||
{
|
||||
if (!IsValidMessageID(msgid))
|
||||
return false;
|
||||
auto p = MessagePath(msgid);
|
||||
return !fs::exists(p);
|
||||
}
|
||||
|
||||
fs::path ArticleStorage::MessagePath(const std::string & msgid) const
|
||||
{
|
||||
return basedir / msgid;
|
||||
}
|
||||
|
||||
FileHandle_ptr ArticleStorage::OpenRead(const std::string & msgid) const
|
||||
{
|
||||
return OpenFile(MessagePath(msgid), eRead);
|
||||
}
|
||||
|
||||
FileHandle_ptr ArticleStorage::OpenWrite(const std::string & msgid) const
|
||||
{
|
||||
return OpenFile(MessagePath(msgid), eWrite);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
fs::path ArticleStorage::MessagePath(const std::string &msgid) const { return basedir / msgid; }
|
||||
|
||||
FileHandle_ptr ArticleStorage::OpenRead(const std::string &msgid) const { return OpenFile(MessagePath(msgid), eRead); }
|
||||
|
||||
FileHandle_ptr ArticleStorage::OpenWrite(const std::string &msgid) const
|
||||
{
|
||||
return OpenFile(MessagePath(msgid), eWrite);
|
||||
}
|
||||
|
||||
bool ArticleStorage::LoadBoardPage(BoardPage &board, const std::string &newsgroup, uint32_t perpage,
|
||||
uint32_t page) const
|
||||
{
|
||||
(void)board;
|
||||
(void)newsgroup;
|
||||
(void)perpage;
|
||||
(void)page;
|
||||
return false;
|
||||
}
|
||||
bool ArticleStorage::FindThreadByHash(const std::string &hashhex, std::string &msgid) const
|
||||
{
|
||||
(void)hashhex;
|
||||
(void)msgid;
|
||||
return false;
|
||||
}
|
||||
bool ArticleStorage::LoadThread(Thread &thread, const std::string &rootmsgid) const
|
||||
{
|
||||
(void)thread;
|
||||
(void)rootmsgid;
|
||||
return false;
|
||||
}
|
||||
|
||||
/** ensure symlinks are formed for this article by message id */
|
||||
void ArticleStorage::EnsureSymlinks(const std::string &msgid) const { (void)msgid; }
|
||||
}
|
||||
|
@ -1,24 +1,27 @@
|
||||
#include <nntpchan/template_engine.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <mstch/mstch.hpp>
|
||||
#include <iostream>
|
||||
#include <mstch/mstch.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <nntpchan/template_engine.hpp>
|
||||
#include <sstream>
|
||||
|
||||
namespace nntpchan
|
||||
{
|
||||
|
||||
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
|
||||
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
|
||||
template <class... Ts> struct overloaded : Ts...
|
||||
{
|
||||
using Ts::operator()...;
|
||||
};
|
||||
template <class... Ts> overloaded(Ts...)->overloaded<Ts...>;
|
||||
|
||||
namespace mustache = mstch;
|
||||
namespace mustache = mstch;
|
||||
|
||||
static mustache::map post_to_map(const nntpchan::model::Post & post)
|
||||
{
|
||||
static mustache::map post_to_map(const nntpchan::model::Post &post)
|
||||
{
|
||||
mustache::map m;
|
||||
mustache::array attachments;
|
||||
mustache::map h;
|
||||
|
||||
for (const auto & att : nntpchan::model::GetAttachments(post))
|
||||
for (const auto &att : nntpchan::model::GetAttachments(post))
|
||||
{
|
||||
mustache::map a;
|
||||
a["filename"] = nntpchan::model::GetFilename(att);
|
||||
@ -27,10 +30,10 @@ namespace nntpchan
|
||||
attachments.push_back(a);
|
||||
}
|
||||
|
||||
for (const auto & item : nntpchan::model::GetHeader(post))
|
||||
for (const auto &item : nntpchan::model::GetHeader(post))
|
||||
{
|
||||
mustache::array vals;
|
||||
for(const auto & v : item.second)
|
||||
for (const auto &v : item.second)
|
||||
vals.push_back(v);
|
||||
h[item.first] = vals;
|
||||
}
|
||||
@ -39,64 +42,60 @@ namespace nntpchan
|
||||
m["message"] = nntpchan::model::GetBody(post);
|
||||
m["header"] = h;
|
||||
return m;
|
||||
}
|
||||
}
|
||||
|
||||
static mustache::map thread_to_map(const nntpchan::model::Thread & t)
|
||||
{
|
||||
static mustache::map thread_to_map(const nntpchan::model::Thread &t)
|
||||
{
|
||||
mustache::map thread;
|
||||
mustache::array posts;
|
||||
for(const auto & post : t)
|
||||
for (const auto &post : t)
|
||||
{
|
||||
posts.push_back(post_to_map(post));
|
||||
}
|
||||
auto & opHeader = nntpchan::model::GetHeader(t[0]);
|
||||
auto &opHeader = nntpchan::model::GetHeader(t[0]);
|
||||
thread["title"] = nntpchan::model::HeaderIFind(opHeader, "subject", "None")[0];
|
||||
thread["posts"] = posts;
|
||||
return thread;
|
||||
}
|
||||
}
|
||||
|
||||
struct MustacheTemplateEngine : public TemplateEngine
|
||||
{
|
||||
struct MustacheTemplateEngine : public TemplateEngine
|
||||
{
|
||||
struct Impl
|
||||
{
|
||||
|
||||
Impl(const std::map<std::string, std::string> & partials) : m_partials(partials) {}
|
||||
Impl(const std::map<std::string, std::string> &partials) : m_partials(partials) {}
|
||||
|
||||
bool ParseTemplate(const FileHandle_ptr & in)
|
||||
bool ParseTemplate(const FileHandle_ptr &in)
|
||||
{
|
||||
std::stringstream str;
|
||||
std::string line;
|
||||
while(std::getline(*in, line))
|
||||
while (std::getline(*in, line))
|
||||
str << line << "\n";
|
||||
m_tmplString = str.str();
|
||||
return in->eof();
|
||||
}
|
||||
|
||||
bool RenderFile(const Args_t & args, const FileHandle_ptr & out)
|
||||
bool RenderFile(const Args_t &args, const FileHandle_ptr &out)
|
||||
{
|
||||
mustache::map obj;
|
||||
for (const auto & item : args)
|
||||
for (const auto &item : args)
|
||||
{
|
||||
std::visit(overloaded {
|
||||
[&obj, item](const nntpchan::model::Model & m) {
|
||||
std::visit(overloaded {
|
||||
[&obj, item](const nntpchan::model::BoardPage & p) {
|
||||
std::visit(overloaded{[&obj, item](const nntpchan::model::Model &m) {
|
||||
std::visit(overloaded{[&obj, item](const nntpchan::model::BoardPage &p) {
|
||||
mustache::array threads;
|
||||
for (const auto & thread : p)
|
||||
for (const auto &thread : p)
|
||||
{
|
||||
threads.push_back(thread_to_map(thread));
|
||||
}
|
||||
obj[item.first] = threads;
|
||||
},
|
||||
[&obj, item](const nntpchan::model::Thread & t) {
|
||||
[&obj, item](const nntpchan::model::Thread &t) {
|
||||
obj[item.first] = thread_to_map(t);
|
||||
}
|
||||
}, m);
|
||||
}
|
||||
,[&obj, item](const std::string & str) {
|
||||
obj[item.first] = str;
|
||||
}
|
||||
}, item.second);
|
||||
}},
|
||||
m);
|
||||
},
|
||||
[&obj, item](const std::string &str) { obj[item.first] = str; }},
|
||||
item.second);
|
||||
}
|
||||
|
||||
std::string str = mustache::render(m_tmplString, obj);
|
||||
@ -106,27 +105,27 @@ namespace nntpchan
|
||||
}
|
||||
|
||||
std::string m_tmplString;
|
||||
const std::map<std::string, std::string> & m_partials;
|
||||
const std::map<std::string, std::string> &m_partials;
|
||||
};
|
||||
|
||||
virtual bool WriteTemplate(const fs::path & fpath, const Args_t & args, const FileHandle_ptr & out)
|
||||
virtual bool WriteTemplate(const fs::path &fpath, const Args_t &args, const FileHandle_ptr &out)
|
||||
{
|
||||
auto templFile = OpenFile(fpath, eRead);
|
||||
if(!templFile)
|
||||
if (!templFile)
|
||||
{
|
||||
std::clog << "no such template at " << fpath << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::map<std::string, std::string> partials;
|
||||
if(!LoadPartials(fpath.parent_path(), partials))
|
||||
if (!LoadPartials(fpath.parent_path(), partials))
|
||||
{
|
||||
std::clog << "failed to load partials" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
Impl impl(partials);
|
||||
if(impl.ParseTemplate(templFile))
|
||||
if (impl.ParseTemplate(templFile))
|
||||
{
|
||||
return impl.RenderFile(args, out);
|
||||
}
|
||||
@ -135,32 +134,33 @@ namespace nntpchan
|
||||
return false;
|
||||
}
|
||||
|
||||
bool LoadPartials(fs::path dir, std::map<std::string, std::string> & partials)
|
||||
bool LoadPartials(fs::path dir, std::map<std::string, std::string> &partials)
|
||||
{
|
||||
const auto partial_files = { "header", "footer" };
|
||||
for(const auto & fname : partial_files)
|
||||
const auto partial_files = {"header", "footer"};
|
||||
for (const auto &fname : partial_files)
|
||||
{
|
||||
auto file = OpenFile(dir / fs::path(fname + std::string(".html")), eRead);
|
||||
if(!file) {
|
||||
if (!file)
|
||||
{
|
||||
std::clog << "no such partial: " << fname << std::endl;
|
||||
return false;
|
||||
}
|
||||
std::string line;
|
||||
std::stringstream input;
|
||||
while(std::getline(*file, line))
|
||||
while (std::getline(*file, line))
|
||||
input << line << "\n";
|
||||
partials[fname] = input.str();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
TemplateEngine * CreateTemplateEngine(const std::string & dialect)
|
||||
{
|
||||
TemplateEngine *CreateTemplateEngine(const std::string &dialect)
|
||||
{
|
||||
auto d = ToLower(dialect);
|
||||
if(d == "mustache")
|
||||
if (d == "mustache")
|
||||
return new MustacheTemplateEngine;
|
||||
else
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1,13 +1,11 @@
|
||||
#include <nntpchan/exec_frontend.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <nntpchan/exec_frontend.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
|
||||
|
||||
|
||||
int main(int , char * [])
|
||||
int main(int, char *[])
|
||||
{
|
||||
nntpchan::Frontend_ptr f (new nntpchan::ExecFrontend("./contrib/nntpchan.sh"));
|
||||
nntpchan::Frontend_ptr f(new nntpchan::ExecFrontend("./contrib/nntpchan.sh"));
|
||||
assert(f->AcceptsMessage("<test@server>"));
|
||||
assert(f->AcceptsNewsgroup("overchan.test"));
|
||||
assert(nntpchan::IsValidMessageID("<test@test>"));
|
||||
|
@ -3,21 +3,18 @@
|
||||
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <sodium.h>
|
||||
#include <string>
|
||||
|
||||
static void print_help(const std::string & exename)
|
||||
static void print_help(const std::string &exename)
|
||||
{
|
||||
std::cout << "usage: " << exename << " [help|gen|check]" << std::endl;
|
||||
}
|
||||
|
||||
static void print_long_help()
|
||||
{
|
||||
static void print_long_help() {}
|
||||
|
||||
}
|
||||
|
||||
static void gen_passwd(const std::string & username, const std::string & passwd)
|
||||
static void gen_passwd(const std::string &username, const std::string &passwd)
|
||||
{
|
||||
std::array<uint8_t, 8> random;
|
||||
randombytes_buf(random.data(), random.size());
|
||||
@ -29,57 +26,69 @@ static void gen_passwd(const std::string & username, const std::string & passwd)
|
||||
std::cout << username << ":" << hash << ":" << salt << std::endl;
|
||||
}
|
||||
|
||||
|
||||
static bool check_cred(const std::string & cred, const std::string & passwd)
|
||||
static bool check_cred(const std::string &cred, const std::string &passwd)
|
||||
{
|
||||
auto idx = cred.find(":");
|
||||
if(idx == std::string::npos || idx == 0) return false;
|
||||
std::string part = cred.substr(idx+1);
|
||||
if (idx == std::string::npos || idx == 0)
|
||||
return false;
|
||||
std::string part = cred.substr(idx + 1);
|
||||
idx = part.find(":");
|
||||
if(idx == std::string::npos || idx == 0) return false;
|
||||
std::string salt = part.substr(idx+1);
|
||||
if (idx == std::string::npos || idx == 0)
|
||||
return false;
|
||||
std::string salt = part.substr(idx + 1);
|
||||
std::string hash = part.substr(0, idx);
|
||||
std::vector<uint8_t> h;
|
||||
if(!nntpchan::B64Decode(hash, h)) return false;
|
||||
if (!nntpchan::B64Decode(hash, h))
|
||||
return false;
|
||||
nntpchan::SHA512Digest d;
|
||||
std::string l = passwd + salt;
|
||||
nntpchan::SHA512((const uint8_t*)l.data(), l.size(), d);
|
||||
nntpchan::SHA512((const uint8_t *)l.data(), l.size(), d);
|
||||
return std::memcmp(h.data(), d.data(), d.size()) == 0;
|
||||
}
|
||||
|
||||
int main(int argc, char * argv[])
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
assert(sodium_init() == 0);
|
||||
if(argc == 1) {
|
||||
if (argc == 1)
|
||||
{
|
||||
print_help(argv[0]);
|
||||
return 1;
|
||||
}
|
||||
std::string cmd(argv[1]);
|
||||
if (cmd == "help") {
|
||||
if (cmd == "help")
|
||||
{
|
||||
print_long_help();
|
||||
return 0;
|
||||
}
|
||||
if (cmd == "gen") {
|
||||
if(argc == 4) {
|
||||
if (cmd == "gen")
|
||||
{
|
||||
if (argc == 4)
|
||||
{
|
||||
gen_passwd(argv[2], argv[3]);
|
||||
return 0;
|
||||
} else {
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout << "usage: " << argv[0] << " gen username password" << std::endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
if(cmd == "check" ) {
|
||||
if (cmd == "check")
|
||||
{
|
||||
std::string cred;
|
||||
std::cout << "credential: " ;
|
||||
if(!std::getline(std::cin, cred)) {
|
||||
std::cout << "credential: ";
|
||||
if (!std::getline(std::cin, cred))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
std::string passwd;
|
||||
std::cout << "password: ";
|
||||
if(!std::getline(std::cin, passwd)) {
|
||||
if (!std::getline(std::cin, passwd))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
if(check_cred(cred, passwd)) {
|
||||
if (check_cred(cred, passwd))
|
||||
{
|
||||
std::cout << "okay" << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
@ -1,11 +1,9 @@
|
||||
#include <nntpchan/exec_frontend.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
#include <cassert>
|
||||
#include <iostream>
|
||||
#include <nntpchan/exec_frontend.hpp>
|
||||
#include <nntpchan/sanitize.hpp>
|
||||
|
||||
|
||||
|
||||
int main(int , char * [])
|
||||
int main(int, char *[])
|
||||
{
|
||||
nntpchan::Frontend_ptr f(new nntpchan::ExecFrontend("./contrib/nntpchan.sh"));
|
||||
assert(nntpchan::IsValidMessageID("<a28a71493831188@web.oniichan.onion>"));
|
||||
|
Reference in New Issue
Block a user