more nntpchan-daemon stuff

contrib/backends/nntpchan-daemon/include/mstch/mstch.hpp

@@ -0,0 +1,113 @@
+#pragma once
+
+#include <vector>
+#include <map>
+#include <string>
+#include <memory>
+#include <functional>
+
+#include <boost/variant.hpp>
+
+namespace mstch {
+
+struct config {
+  static std::function<std::string(const std::string&)> escape;
+};
+
+namespace internal {
+
+template<class N>
+class object_t {
+ public:
+  const N& at(const std::string& name) const {
+    cache[name] = (methods.at(name))();
+    return cache[name];
+  }
+
+  bool has(const std::string name) const {
+    return methods.count(name) != 0;
+  }
+
+ protected:
+  template<class S>
+  void register_methods(S* s, std::map<std::string,N(S::*)()> methods) {
+    for(auto& item: methods)
+      this->methods.insert({item.first, std::bind(item.second, s)});
+  }
+
+ private:
+  std::map<std::string, std::function<N()>> methods;
+  mutable std::map<std::string, N> cache;
+};
+
+template<class T, class N>
+class is_fun {
+ private:
+  using not_fun = char;
+  using fun_without_args = char[2];
+  using fun_with_args = char[3];
+  template <typename U, U> struct really_has;
+  template <typename C> static fun_without_args& test(
+      really_has<N(C::*)() const, &C::operator()>*);
+  template <typename C> static fun_with_args& test(
+      really_has<N(C::*)(const std::string&) const,
+      &C::operator()>*);
+  template <typename> static not_fun& test(...);
+
+ public:
+  static bool const no_args = sizeof(test<T>(0)) == sizeof(fun_without_args);
+  static bool const has_args = sizeof(test<T>(0)) == sizeof(fun_with_args);
+};
+
+template<class N>
+using node_renderer = std::function<std::string(const N& n)>;
+
+template<class N>
+class lambda_t {
+ public:
+  template<class F>
+  lambda_t(F f, typename std::enable_if<is_fun<F, N>::no_args>::type* = 0):
+      fun([f](node_renderer<N> renderer, const std::string&) {
+        return renderer(f());
+      })
+  {
+  }
+
+  template<class F>
+  lambda_t(F f, typename std::enable_if<is_fun<F, N>::has_args>::type* = 0):
+      fun([f](node_renderer<N> renderer, const std::string& text) {
+        return renderer(f(text));
+      })
+  {
+  }
+
+  std::string operator()(node_renderer<N> renderer,
+      const std::string& text = "") const
+  {
+    return fun(renderer, text);
+  }
+
+ private:
+  std::function<std::string(node_renderer<N> renderer, const std::string&)> fun;
+};
+
+}
+
+using node = boost::make_recursive_variant<
+    std::nullptr_t, std::string, int, double, bool,
+    internal::lambda_t<boost::recursive_variant_>,
+    std::shared_ptr<internal::object_t<boost::recursive_variant_>>,
+    std::map<const std::string, boost::recursive_variant_>,
+    std::vector<boost::recursive_variant_>>::type;
+using object = internal::object_t<node>;
+using lambda = internal::lambda_t<node>;
+using map = std::map<const std::string, node>;
+using array = std::vector<node>;
+
+std::string render(
+    const std::string& tmplt,
+    const node& root,
+    const std::map<std::string,std::string>& partials =
+        std::map<std::string,std::string>());
+
+}

contrib/backends/nntpchan-daemon/include/nntpchan/base64.hpp

@@ -0,0 +1,17 @@
+#ifndef NNTPCHAN_BASE64_HPP
+#define NNTPCHAN_BASE64_HPP
+#include <string>
+#include <vector>
+
+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);
+
+}
+
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/buffer.hpp

@@ -0,0 +1,19 @@
+#ifndef NNTPCHAN_BUFFER_HPP
+#define NNTPCHAN_BUFFER_HPP
+#include <uv.h>
+#include <string>
+
+namespace nntpchan
+{
+  struct WriteBuffer
+  {
+    uv_write_t w;
+    uv_buf_t b;
+
+    WriteBuffer(const std::string & s);
+    WriteBuffer(const char * b, const size_t s);
+    ~WriteBuffer();
+  };
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/crypto.hpp

@@ -0,0 +1,22 @@
+#ifndef NNTPCHAN_CRYPTO_HPP
+#define NNTPCHAN_CRYPTO_HPP
+
+#include <sodium/crypto_hash.h>
+#include <array>
+
+namespace nntpchan
+{
+  typedef std::array<uint8_t, crypto_hash_BYTES> SHA512Digest;
+
+  void SHA512(const uint8_t * d, std::size_t l, SHA512Digest & h);
+
+  /** global crypto initializer */
+  struct Crypto
+  {
+    Crypto();
+    ~Crypto();
+  };
+}
+
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/event.hpp

@@ -0,0 +1,26 @@
+#ifndef NNTPCHAN_EVENT_HPP
+#define NNTPCHAN_EVENT_HPP
+#include <uv.h>
+
+namespace nntpchan
+{
+  class Mainloop
+  {
+  public:
+
+    Mainloop();
+    ~Mainloop();
+
+    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;
+    
+  };
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/exec_frontend.hpp

@@ -0,0 +1,30 @@
+#ifndef NNTPCHAN_EXEC_FRONTEND_HPP
+#define NNTPCHAN_EXEC_FRONTEND_HPP
+#include "frontend.hpp"
+#include <deque>
+
+namespace nntpchan
+{
+  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:
+
+    int Exec(std::deque<std::string> args);
+    
+  private:
+    std::string m_exec;
+    
+  };
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/file_handle.hpp

@@ -0,0 +1,23 @@
+#ifndef NNTPCHAN_FILE_HANDLE_HPP
+#define NNTPCHAN_FILE_HANDLE_HPP
+
+#include <memory>
+#include <fstream>
+#include <experimental/filesystem>
+
+namespace nntpchan
+{
+  typedef std::unique_ptr<std::fstream> FileHandle_ptr;
+
+  enum FileMode
+  {
+    eRead,
+    eWrite
+  };
+
+  namespace fs = std::experimental::filesystem;
+  
+  FileHandle_ptr OpenFile(const fs::path & fname, FileMode mode);
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/frontend.hpp

@@ -0,0 +1,29 @@
+#ifndef NNTPCHAN_FRONTEND_HPP
+#define NNTPCHAN_FRONTEND_HPP
+#include <string>
+#include <memory>
+#include <experimental/filesystem>
+namespace nntpchan
+{
+
+  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;
+
+    /** @brief return true if we take posts in a newsgroup */
+    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;
+    
+  };
+
+  typedef std::unique_ptr<Frontend> Frontend_ptr;
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/http.hpp

@@ -0,0 +1,6 @@
+#ifndef NNTPCHAN_HTTP_HPP
+#define NNTPCHAN_HTTP_HPP
+
+
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/http_client.hpp

@@ -0,0 +1,5 @@
+#ifndef NNTPCHAN_HTTP_CLIENT_HPP
+#define NNTPCHAN_HTTP_CLIENT_HPP
+
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/http_server.hpp

@@ -0,0 +1,6 @@
+#ifndef NNTPCHAN_HTTP_SERVER_HPP
+#define NNTPCHAN_HTTP_SERVER_HPP
+
+
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/io_handle.hpp

@@ -0,0 +1,12 @@
+#ifndef NNTPCHAN_IO_HANDLE_HPP
+#define NNTPCHAN_IO_HANDLE_HPP
+#include <memory>
+#include <iostream>
+
+namespace nntpchan
+{
+  typedef std::unique_ptr<std::iostream> IOHandle_ptr;
+  
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/line.hpp

@@ -0,0 +1,34 @@
+#ifndef NNTPCHAN_LINE_HPP
+#define NNTPCHAN_LINE_HPP
+#include "server.hpp"
+#include <stdint.h>
+namespace nntpchan
+{
+
+  /** @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);
+
+    /** implements IConnHandler */
+    virtual bool ShouldClose();
+
+  protected:
+    /** @brief handle a line from the client */
+    virtual void HandleLine(const std::string & line) = 0;
+
+
+  private:
+    void OnLine(const char * d, const size_t l);
+    std::string m_leftovers;
+    bool m_close;
+    const size_t lineLimit;
+  };
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/mime.hpp

@@ -0,0 +1,30 @@
+#ifndef NNTPCHAN_MIME_HPP
+#define NNTPCHAN_MIME_HPP
+#include "file_handle.hpp"
+#include "io_handle.hpp"
+#include <functional>
+#include <map>
+#include <string>
+
+namespace nntpchan
+{
+
+  typedef std::map<std::string, std::string> RawHeader;
+
+  bool ReadHeader(const FileHandle_ptr & f, RawHeader & h);
+
+
+  struct MimePart
+  {
+    virtual RawHeader & Header() = 0;
+    virtual IOHandle_ptr OpenPart() = 0;
+  };
+
+  typedef std::unique_ptr<MimePart> MimePart_ptr;
+  
+  typedef std::function<bool(MimePart_ptr)> PartReader;
+  
+  bool ReadParts(const FileHandle_ptr & f, PartReader r);
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/model.hpp

@@ -0,0 +1,59 @@
+#ifndef NNTPCHAN_MODEL_HPP
+#define NNTPCHAN_MODEL_HPP
+#include <map>
+#include <set>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace nntpchan
+{
+  namespace model
+  {
+    // MIME Header
+    typedef std::map<std::string, std::set<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;
+
+
+    static inline std::string & GetFilename(PostAttachment & att)
+    {
+      return std::get<0>(att);
+    }
+    
+    static inline std::string & GetHexDigest(PostAttachment & att)
+    {
+      return std::get<1>(att);
+    }
+    
+    static inline std::string & GetThumbnail(PostAttachment & att)
+    {
+      return std::get<2>(att);
+    }
+    
+    static inline PostHeader & GetHeader(Post & post)
+    {
+      return std::get<0>(post);
+    }
+    
+    static inline PostBody & GetBody(Post & post)
+    {
+      return std::get<1>(post);
+    }
+    
+    static inline Attachments & GetAttachments(Post & post)
+    {
+      return std::get<2>(post);
+    }
+  }
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/net.hpp

@@ -0,0 +1,23 @@
+#ifndef NNTPCHAN_NET_HPP
+#define NNTPCHAN_NET_HPP
+
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <string>
+
+namespace nntpchan
+{
+  struct NetAddr
+  {
+    NetAddr();
+    
+    sockaddr_in6 addr;
+    operator sockaddr * () { return (sockaddr *) &addr; }
+    operator const sockaddr * () const { return (sockaddr *) &addr; }
+    std::string to_string();
+  };
+
+  NetAddr ParseAddr(const std::string & addr);
+}
+
+#endif 

contrib/backends/nntpchan-daemon/include/nntpchan/nntp_auth.hpp

@@ -0,0 +1,61 @@
+#ifndef NNTPCHAN_NNTP_AUTH_HPP
+#define NNTPCHAN_NNTP_AUTH_HPP
+#include <string>
+#include <iostream>
+#include <fstream>
+#include <mutex>
+#include <memory>
+#include "line.hpp"
+
+namespace nntpchan
+{
+  /** @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 ~NNTPCredentialDB() {}
+  };
+
+  typedef std::shared_ptr<NNTPCredentialDB> CredDB_ptr;
+  
+  /** @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);
+
+    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;
+  };
+
+  class HashedFileDB : public HashedCredDB
+  {
+  public:
+    HashedFileDB(const std::string & fname);
+    ~HashedFileDB();
+    bool Open();
+    void Close();
+  private:
+    std::string m_fname;
+    std::ifstream f;
+  };
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/nntp_handler.hpp

@@ -0,0 +1,62 @@
+#ifndef NNTPCHAN_NNTP_HANDLER_HPP
+#define NNTPCHAN_NNTP_HANDLER_HPP
+#include <deque>
+#include <string>
+#include "line.hpp"
+#include "nntp_auth.hpp"
+#include "storage.hpp"
+
+namespace nntpchan
+{
+  class NNTPServerHandler : public LineReader, public IConnHandler
+  {
+  public:
+    NNTPServerHandler(const std::string & storage);
+    ~NNTPServerHandler();
+
+    virtual bool ShouldClose();
+
+    void SetAuth(CredDB_ptr creds);
+
+    virtual void OnData(const char *, ssize_t);
+
+    void Greet();
+
+  protected:
+    void HandleLine(const std::string & line);
+    void HandleCommand(const std::deque<std::string> & command);
+  private:
+
+    enum State {
+      eStateReadCommand,
+      eStateStoreArticle,
+      eStateQuit
+    };
+
+  private:
+
+    void EnterState(State st);
+
+    void ArticleObtained();
+
+    // handle quit command, this queues a reply
+    void Quit();
+
+    // switch nntp modes, this queues a reply
+    void SwitchMode(const std::string & mode);
+
+    bool PostingAllowed();
+
+  private:
+    std::string m_articleName;
+    FileHandle_ptr m_article;
+    CredDB_ptr m_auth;
+    ArticleStorage m_store;
+    std::string m_mode;
+    bool m_authed;
+    State m_state;
+  };
+}
+
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/nntp_server.hpp

@@ -0,0 +1,62 @@
+#ifndef NNTPCHAN_NNTP_SERVER_HPP
+#define NNTPCHAN_NNTP_SERVER_HPP
+#include <uv.h>
+#include <string>
+#include <deque>
+#include "frontend.hpp"
+#include "server.hpp"
+
+namespace nntpchan
+{
+
+  class NNTPServer : public Server
+  {
+  public:
+
+    NNTPServer(uv_loop_t * loop);
+
+    virtual ~NNTPServer();
+
+    void SetStoragePath(const std::string & path);
+
+    void SetLoginDB(const std::string path);
+
+    void SetInstanceName(const std::string & name);
+
+    std::string InstanceName() const;
+
+    void Close();
+
+    virtual IServerConn * CreateConn(uv_stream_t * s);
+
+    virtual void OnAcceptError(int status);
+
+    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) {}
+
+    virtual bool IsTimedOut() { return false; };
+
+    /** @brief send next queued reply */
+    virtual void SendNextReply();
+
+    virtual void Greet();
+
+  };
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/sanitize.hpp

@@ -0,0 +1,13 @@
+#ifndef NNTPCHAN_SANITIZE_HPP
+#define NNTPCHAN_SANITIZE_HPP
+#include <string>
+
+namespace nntpchan
+{
+  std::string NNTPSanitizeLine(const std::string & str);
+  std::string ToLower(const std::string & str);
+  bool IsValidMessageID(const std::string & msgid);
+  bool IsValidNewsgroup(const std::string & group);
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/server.hpp

@@ -0,0 +1,98 @@
+#ifndef NNTPCHAN_SERVER_HPP
+#define NNTPCHAN_SERVER_HPP
+#include <uv.h>
+#include <deque>
+#include <functional>
+#include <string>
+
+namespace nntpchan
+{
+
+  class Server;
+
+
+  struct IConnHandler
+  {
+
+    virtual ~IConnHandler() {};
+
+    /** got inbound data */
+    virtual void OnData(const char * data, ssize_t s) = 0;
+
+    /** get next line of data to send */
+    std::string GetNextLine();
+
+    /** return true if we have a line to send */
+    bool HasNextLine();
+
+    /** return true if we should close this connection otherwise return false */
+    virtual bool ShouldClose() = 0;
+
+    /** queue a data send */
+    void QueueLine(const std::string & line);
+
+    virtual void Greet() = 0;
+
+
+  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);
+    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;
+  };
+
+  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;
+    /** close all sockets and stop */
+    void Close();
+    /** bind to address */
+    void Bind(const std::string & addr);
+
+    typedef std::function<void(IServerConn *)> ConnVisitor;
+
+    /** visit all open connections */
+    void VisitConns(ConnVisitor v);
+
+    /** remove connection from server, called after proper close */
+    void RemoveConn(IServerConn * conn);
+
+  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);
+    std::deque<IServerConn *> m_conns;
+    uv_tcp_t m_server;
+    uv_loop_t * m_loop;
+  };
+}
+
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/sha1.hpp

@@ -0,0 +1,11 @@
+#ifndef NNTPCHAN_SHA1_HPP
+#define NNTPCHAN_SHA1_HPP
+
+#include <string>
+
+namespace nntpchan
+{
+  std::string sha1_hex(const std::string & data);
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/staticfile_frontend.hpp

@@ -0,0 +1,44 @@
+#ifndef NNTPCHAN_STATICFILE_FRONTEND_HPP
+#define NNTPCHAN_STATICFILE_FRONTEND_HPP
+#include "frontend.hpp"
+#include "template_engine.hpp"
+#include "model.hpp"
+#include <experimental/filesystem>
+
+namespace nntpchan
+{
+
+  namespace fs = std::experimental::filesystem;
+  
+  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);
+
+  private:
+
+    typedef nntpchan::model::Thread Thread_t;
+
+    typedef std::vector<Thread_t> Threads_t;
+
+    typedef std::vector<Threads_t> BoardPage_t;
+    
+    BoardPage_t GetThreadsPaginated(const std::string & group, uint32_t perpage, uint32_t pages);
+    
+  private:
+    
+    TemplateEngine_ptr m_TemplateEngine;
+    fs::path m_TemplateDir;
+    fs::path m_OutDir;
+    uint32_t m_Pages;
+  };
+}
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/storage.hpp

@@ -0,0 +1,40 @@
+#ifndef NNTPCHAN_STORAGE_HPP
+#define NNTPCHAN_STORAGE_HPP
+
+#include <experimental/filesystem>
+#include <string>
+#include "file_handle.hpp"
+
+namespace nntpchan
+{
+
+  namespace fs = std::experimental::filesystem;
+  
+  class ArticleStorage
+  {
+  public:
+    ArticleStorage();
+    ArticleStorage(const fs::path & fpath);
+    ~ArticleStorage();
+
+    void SetPath(const fs::path & fpath);
+
+    FileHandle_ptr OpenWrite(const std::string & msgid);
+    FileHandle_ptr OpenRead(const std::string & msgid);
+
+    /**
+       return true if we should accept a new message give its message id
+     */
+    bool Accept(const std::string & msgid);
+    
+  private:
+
+    fs::path MessagePath(const std::string & msgid);
+
+    fs::path basedir;
+
+  };
+}
+
+
+#endif

contrib/backends/nntpchan-daemon/include/nntpchan/template_engine.hpp

@@ -0,0 +1,23 @@
+#ifndef NNTPCHAN_TEMPLATE_ENGINE_HPP
+#define NNTPCHAN_TEMPLATE_ENGINE_HPP
+#include "file_handle.hpp"
+#include <any>
+#include <map>
+#include <memory>
+#include <string>
+
+namespace nntpchan
+{
+
+  struct TemplateEngine
+  {
+    using Args_t = std::map<std::string, std::any>;
+    virtual bool WriteTemplate(const fs::path & template_fpath, const Args_t & args, const FileHandle_ptr & out) = 0;
+  };
+
+  TemplateEngine * CreateTemplateEngine(const std::string & dialect);
+
+  typedef std::unique_ptr<TemplateEngine> TemplateEngine_ptr;
+}
+
+#endif