Merge pull request #190 from cargoedit/master

chore: remove unused min/max func

.github/CONTRIBUTING.md

@@ -0,0 +1,5 @@
+
+* be awesome to each other
+* fun is required, don't be a killjoy
+* **vendor everything**
+

.github/issue_template.md

@@ -0,0 +1,21 @@
+## info
+
+git revision / version: [git revision or version here]
+
+OS: [os here]
+
+Architecture: [architecture here]
+
+## problem
+
+[insert description of problem here]
+
+## backtrace / error messages
+
+Error messages: [yes/no]
+
+[insert any error messages here]
+
+Backtrace: [yes/no]
+
+[insert any backtraces here]

.gitignore

@@ -8,10 +8,35 @@
 .\#*
 
 # srnd config files
-*.ini
+srnd.ini
+feeds.ini
 
 # default article store directory
 articles
 
 # generated files
-webroot
+webroot
+
+# built binaries
+go
+gopherjs_go
+./srndv2
+
+# private key
+*.key
+
+# certificates
+certs
+
+
+rebuild.sh
+.gx
+
+# generated js
+contrib/static/nntpchan.js
+contrib/static/js/nntpchan.js
+contrib/static/miner-js.js
+
+
+#docs trash
+doc/.trash

CODE_OF_CONDUCT.md

@@ -0,0 +1,30 @@
+
+**You have been visited by the CoC(K)**
+
+
+                                           _.+._              
+                                         (^\/^\/^)            
+                                          \@☆@☆@/             
+           CoC(k)                         {_____}             
+        Code Of Conduct Killer           _oOPPYbo.            
+                                   _,ooO8O'    `Ob            
+                             _,ooOPP"'  Ob      dO            
+                        _oooOP"''       `Oo.   ,O[            
+       Ob         _,ooOPP''               `YYboOP             
+      `O[     _ooOP"''                  _,oOPP"'              
+       YOooooOP'                    _ooOP"'                   
+         ''                     ,ooOP''                       
+                            ,odPP''                           
+                        _,oOP'                                
+                     ooOP"'                                   
+                  _oOP'o                                      
+                 ,OP   YOL                                    
+    ,O.         ,OP      Yb     contribute code or you're a racist    
+    dO'          "        Yb    get offended as a responsible adult
+    ]O.                   dO    spread this like happy herpes    
+     Ob        _,o.      dOP    
+     `Ooo___ooOP'`YbooodPP      just imagine what would happen
+       '`"""''     `'''         if we all decided to understand
+
+
+Sweet blessing be upon you but **ONLY** if comment `ebin` to this commit.

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Jeff Becker
+Copyright (c) 2015-2020 Jeff Becker
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -0,0 +1,108 @@
+REPO=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
+REPO_GOPATH=$(REPO)/go
+MINIFY=$(REPO_GOPATH)/bin/minify
+STATIC_DIR=$(REPO)/contrib/static
+JS=$(STATIC_DIR)/nntpchan.js
+MINER_JS=$(STATIC_DIR)/miner-js.js
+CONTRIB_JS=$(REPO)/contrib/js/contrib
+LOCAL_JS=$(REPO)/contrib/js/nntpchan
+VENDOR_JS=$(REPO)/contrib/js/vendor
+SRND_DIR=$(REPO)/contrib/backends/srndv2
+NNTPCHAND_DIR=$(REPO)/contrib/backends/nntpchand
+NNTPCHAN_DAEMON_DIR=$(REPO)/contrib/backends/nntpchan-daemon
+SRND=$(REPO)/srndv2
+NNTPCHAND=$(REPO)/nntpchand
+NNTPD=$(REPO)/nntpd
+
+GOROOT=$(shell go env GOROOT)
+GO=$(GOROOT)/bin/go
+
+GOPHERJS_GOROOT ?= $(GOROOT)
+GOPHERJS_GO = $(GOPHERJS_GOROOT)/bin/go
+
+GOPHERJS_GOPATH=$(REPO)/gopherjs_go
+GOPHERJS=$(GOPHERJS_GOPATH)/bin/gopherjs
+
+all: clean build
+
+build: js srnd
+
+full: clean full-build
+
+full-build: srnd beta native
+
+js: $(JS) 
+
+srnd: $(SRND)
+
+$(MINIFY):
+	GO111MODULE=on GOPATH=$(REPO_GOPATH) go get -u github.com/tdewolff/minify
+
+
+$(GOPHERJS):
+	GOROOT=$(GOPHERJS_GOROOT) GOPATH=$(GOPHERJS_GOPATH) $(GOPHERJS_GO) get -v github.com/gopherjs/gopherjs
+
+js-deps: $(MINIFY)
+
+$(MINER_JS): $(GOPHERJS) $(MINIFY)
+	rm -rf $(GOPHERJS_GOPATH)/pkg/
+	cp -rf $(SRND_DIR)/src/github.com $(GOPHERJS_GOPATH)/src/
+	GOROOT=$(GOPHERJS_GOROOT) GOPATH=$(GOPHERJS_GOPATH) $(GOPHERJS) -m -v build github.com/ZiRo-/cuckgo/miner_js -o miner.js
+	$(MINIFY) --mime=text/javascript > $(STATIC_DIR)/miner-js.js < miner.js
+	rm -f miner.js.map miner.js
+
+$(JS): js-deps
+
+
+$(SRND):
+	GOROOT=$(GOROOT) $(MAKE) -C $(SRND_DIR)
+	cp $(SRND_DIR)/srndv2 $(SRND)
+
+beta: $(NNTPCHAND)
+
+$(NNTPCHAND):
+	GOROOT=$(GOROOT) $(MAKE) -C $(NNTPCHAND_DIR)
+	cp $(NNTPCHAND_DIR)/nntpchand $(NNTPCHAND)
+
+native: $(NNTPD)
+
+$(NNTPD):
+	$(MAKE) -C $(NNTPCHAN_DAEMON_DIR)
+	cp $(NNTPCHAN_DAEMON_DIR)/nntpd $(NNTPD)
+
+test: test-srnd
+
+test-full: test-srnd test-beta test-native
+
+test-srnd:
+	GOROOT=$(GOROOT) $(MAKE) -C $(SRND_DIR) test
+
+test-beta:
+	GOROOT=$(GOROOT) $(MAKE) -C $(NNTPCHAND_DIR) test
+
+test-native:
+	GOROOT=$(GOROOT) $(MAKE) -C $(NNTPCHAN_DAEMON_DIR) test
+
+
+clean: clean-srnd clean-js
+
+clean-full: clean clean-beta clean-native clean-js
+
+clean-srnd:
+	rm -f $(SRND)
+	GOROOT=$(GOROOT) $(MAKE) -C $(SRND_DIR) clean
+
+clean-js:
+	rm -f $(JS) $(MINER_JS)
+
+clean-beta:
+	rm -f $(NNTPCHAND)
+	GOROOT=$(GOROOT) $(MAKE) -C $(NNTPCHAND_DIR) clean
+
+clean-native:
+	rm -f $(NNTPD)
+	$(MAKE) -C $(NNTPCHAN_DAEMON_DIR) clean
+
+distclean: clean
+	rm -rf $(REPO_GOPATH)
+	rm -rf $(GOPHERJS_GOPATH)

README.md

@@ -1,32 +1,107 @@
-# NNTPChan #
 
-NNTPChan (previously known as overchan) is a decentralized imageboard that uses nntp to synchronize content between many different servers. It utilizes cryptograpghicly signed posts to perform optional/opt-in decentralized moderation.
+![le ebin logo](nntpchan.png "ebin logo")
 
-This repository contains resources used by the core daemon which is located [here](https://github.com/majestrate/srndv2) along with general documentation, [here](doc/)
-
-## getting started ##
-
-After you [built and installed the daemon](doc/build.md) and [set up your database](doc/database.md), clone this repository and start up the daemon
-
-    # clone it
-    git clone https://github.com/majestrate/nntpchan ~/nntpchan
-    cd ~/nntpchan
-
-    # set up the workspace
-    srndv2 setup
-
-    # run the daemon
-    srndv2 run
+![MIT License](https://img.shields.io/github/license/majestrate/nntpchan.svg)
+![Logo is ebin](https://img.shields.io/badge/logo-ebin-brightgreen.svg)
 
 
-Then open http://127.0.0.1:18000/ukko.html in your browser.
+**NNTPChan** (previously known as overchan) is a decentralized imageboard that uses the [NNTP protocol](https://en.wikipedia.org/wiki/Network_News_Transfer_Protocol) (network-news transfer protocol) to synchronize content between many different servers. It utilizes cryptographically signed posts to perform optional/opt-in decentralized moderation.
 
-*PLEASE* report any bugs you find while setting up or building [(here)](https://github.com/majestrate/nntpchan/issues) so that the problems get fixed (^:
+## Getting started Ubuntu 24.04 installation guide
 
-For peering requests, questions or support find me on [rizon](https://qchat.rizon.net/?channels=#nntpchan) as \__uguu\__
+[This](doc) is a step-by-step guide for getting up-and-running with NNTPChan as well as documentation for developers who want to either work on NNTPChan directly or use NNTPChan in their aplications with the API. It works fine on ubuntu 24.04
+
+### Step 1: Download Go 1.15 Tarball
+```
+wget https://dl.google.com/go/go1.15.linux-amd64.tar.gz
+```
+
+### Step 2: Extract the Tarball
+```
+sudo tar -C /usr/local -xvzf go1.15.linux-amd64.tar.gz
+```
+
+### Set Up Go Environment Variables
+```
+export PATH=$PATH:/usr/local/go/bin
+export GOPATH=$HOME/go
+export PATH=$PATH:$GOPATH/bin
+```
+
+### Install the dependancies
+
+    sudo apt-get update
+    sudo apt-get --no-install-recommends install imagemagick ffmpeg sox build-essential git ca-certificates postgresql postgresql-client golang
+    
+
+### Get the NNTPChan source
+    git clone https://github.com/konamicode9/nntpchan
+    cd nntpchan
+
+### Now compile!
+
+Run `make`:
+
+    make
+
+## now its time to create the database in postgres
+```
+CREATE DATABASE root;
+CREATE USER root WITH PASSWORD 'root';
+GRANT ALL PRIVILEGES ON DATABASE root TO root;
+```
+note this only allows db root and username root
+not sure why but i will investigate oh and the default port is 5432
+your gonna need it in the installation
+
+Running NNTPChan
+================
+
+Once you have [built NNTPChan](building.md) and done [the initial setup you](setting-up.md) you can start NNTPChan.
+
+Before running make sure you run the setup command, you only need to do this one time:
+
+    ./srndv2 setup
+
+You can now start the NNTPChan node (srndv2) by running:
+
+    ./srndv2 run
+
+Now you can check out the web-interface by navigating to 127.0.0.1:18000 (default address - unless you have changed it in your `srnd.ini`) or you can [configure your newsreader](extras/configure-newsreader.md).
 
 
-Like this project? Fund it:
+## Support chat 
 
-bitcoin: 15yuMzuueV8y5vPQQ39ZqQVz5Ey98DNrjE
+https://discord.gg/Ydss9wTk7G
 
+
+## Bugs and issues
+
+*PLEASE* report any bugs you find while building, setting-up or using NNTPChan on the [GitHub issue tracker](https://github.com/majestrate/nntpchan/issues), the [issue tracker on tor](http://git.psii2pdloxelodts.onion/psi/nntpchan/), the [issue tracker on i2p](http://git.psi.i2p/psi/nntpchan/) or on the [GitGud issue tracker](https://gitgud.io/jeff/nntpchan/issues) so that the probelms can be resolved or discussed.
+
+## Clients
+
+NNTP (confirmed working):
+
+* Thunderbird
+
+Web:
+
+* [Yukko](https://github.com/faissaloo/Yukko): ncurses based nntpchan web ui reader
+
+## History
+
+* started in mid 2013 on anonet
+
+This is a graph of the post flow of the `overchan.test` newsgroup over 4 years, quite a big network.
+
+(thnx anon who made this btw)
+
+![network topology of 4 years](topology.png "changolia")
+
+[source code for map generation](https://github.com/nilesr/nntpchan-mapper)
+
+
+## Acknowledgements
+
+* [Deavmi](https://deavmi.carteronline.net/) - Making the documentation beautiful.

TODO.md

@@ -0,0 +1,10 @@
+## TODO ##
+
+* imrpove frontend templates
+* extra stylesheets
+* better mod panel
+* easier peering
+* improve command line mod tools
+* refactor srnd package
+* configurable thumbnail size [issue #40](https://github.com/majestrate/nntpchan/issues/40)
+* postgres password bug [issue #137](https://github.com/majestrate/nntpchan/issues/137)

contrib/backends/nntpchan-daemon/.clang-format

@@ -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

contrib/backends/nntpchan-daemon/.gitignore

@@ -0,0 +1,6 @@
+*.o
+*.a
+nntpd
+tools/authtool
+tools/testtool
+.gdb_history

contrib/backends/nntpchan-daemon/Makefile

@@ -0,0 +1,80 @@
+
+REPO=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
+NNTPCHAN_PATH = $(REPO)/libnntpchan
+
+NNTPCHAN_SRC := $(wildcard $(NNTPCHAN_PATH)/*.cpp)
+NNTPCHAN_HDR := $(wildcard $(NNTPCHAN_PATH)/*.hpp)
+NNTPCHAN_OBJ := $(NNTPCHAN_SRC:.cpp=.o)
+
+HEADERS_PATH=$(REPO)/include
+
+TOOL_PATH := $(REPO)/tools
+
+TOOL_SRC := $(wildcard $(TOOL_PATH)/*.cpp)
+TOOLS := $(TOOL_SRC:.cpp=)
+
+SRCS = $(NNTPCHAN_SRC) $(TOOL_SRC)
+
+OBJ := $(NNTPCHAN_OBJ)
+
+TEST = $(REPO)/test
+
+DAEMON_SRC = $(REPO)/daemon
+
+LD_FLAGS ?= 
+
+INC_FLAGS = -I$(HEADERS_PATH)
+
+ifeq ($(shell uname -s),FreeBSD)
+	LD_FLAGS += $(shell dirname $(CXX))/../lib/libc++experimental.a
+	INC_FLAGS += -I/usr/local/include
+	LD_FLAGS += /usr/local/lib/libsodium.a
+else 
+	LD_FLAGS += -lstdc++fs
+	INC_FLAGS += $(shell pkg-config --cflags libsodium)
+	LD_FLAGS += $(shell pkg-config --libs --static libsodium)
+endif
+
+REQUIRED_CXXFLAGS = -std=c++17 -Wall -Wextra -Werror -pedantic $(INC_FLAGS)
+
+DEBUG = 1
+
+ifeq ($(DEBUG),1)
+	REQUIRED_CXXFLAGS += -g
+endif
+
+CXXFLAGS += $(REQUIRED_CXXFLAGS)
+
+NNTPCHAN_LIB = $(REPO)/libnntpchan.a
+
+LIBS = $(NNTPCHAN_LIB)
+
+EXE = $(REPO)/nntpd
+
+
+all: build
+
+format:
+	clang-format -i $(SRCS)
+
+build: $(EXE) tools
+
+$(NNTPCHAN_LIB): $(NNTPCHAN_OBJ)
+	$(AR) -r $(NNTPCHAN_LIB) $(NNTPCHAN_OBJ)
+
+$(EXE): $(LIBS)
+	$(CXX) $(CXXFLAGS) $(DAEMON_SRC)/main.cpp $(LIBS) $(LD_FLAGS) -o $(EXE)
+
+tools: $(TOOLS)
+
+$(TOOLS): $(LIBS)
+	$(CXX) $(CXXFLAGS) $@.cpp $(LIBS) $(LD_FLAGS) -o $@
+
+build-test: $(LIBS)
+	$(CXX) -o $(TEST) $(CXXFLAGS) test.cpp $(LIBS) $(LD_FLAGS)
+
+test: build-test
+	$(TEST)
+
+clean:
+	$(RM) $(OBJ) $(LIBS) $(EXE) $(TOOLS) $(TEST)

contrib/backends/nntpchan-daemon/README.md

@@ -0,0 +1,19 @@
+# nntpchan-daemon
+
+C++ rewrite
+
+requirements:
+
+* C++17 compiler
+
+* libsodium 1.x
+
+* GNU Make
+
+building on freebsd:
+
+    $ gmake
+
+building on Linux:
+
+    $ make

contrib/backends/nntpchan-daemon/contrib/nntpchan.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+exit 0

contrib/backends/nntpchan-daemon/daemon/ini.hpp

@@ -0,0 +1,197 @@
+/**
+ * The MIT License (MIT)
+ * Copyright (c) <2015> <carriez.md@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+  *
+  */
+
+#ifndef INI_HPP
+#define INI_HPP
+
+#include <cassert>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <list>
+#include <map>
+#include <stdexcept>
+#include <string>
+
+namespace INI
+{
+
+struct Level
+{
+  Level() : parent(NULL), 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;
+  typedef std::list<value_map_t::const_iterator> values_t;
+  typedef std::list<section_map_t::const_iterator> sections_t;
+  value_map_t values;
+  section_map_t sections;
+  values_t ordered_values; // original order in the ini file
+  sections_t ordered_sections;
+  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]; }
+};
+
+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(), ""); }
+
+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);
+
+private:
+  Level top_;
+  std::ifstream f0_;
+  std::istream *f_;
+  std::string line_;
+  size_t ln_;
+};
+
+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)
+{
+  char p[] = " \t\r\n";
+  long sp = 0;
+  long ep = s.length() - 1;
+  for (; sp <= ep; ++sp)
+    if (!strchr(p, s[sp]))
+      break;
+  for (; ep >= 0; --ep)
+    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)
+{
+  if (!f0_)
+    throw std::runtime_error(std::string("failed to open file: ") + fn);
+
+  parse(top_);
+}
+
+inline void Parser::parseSLine(std::string &sname, size_t &depth)
+{
+  depth = 0;
+  for (; depth < line_.length(); ++depth)
+    if (line_[depth] != '[')
+      break;
+
+  sname = line_.substr(depth, line_.length() - 2 * depth);
+}
+
+inline void Parser::parse(Level &l)
+{
+  while (std::getline(*f_, line_))
+  {
+    ++ln_;
+    if (line_[0] == '#' || line_[0] == ';')
+      continue;
+    line_ = trim(line_);
+    if (line_.empty())
+      continue;
+    if (line_[0] == '[')
+    {
+      size_t depth;
+      std::string sname;
+      parseSLine(sname, depth);
+      Level *lp = NULL;
+      Level *parent = &l;
+      if (depth > l.depth + 1)
+        err("section with wrong depth");
+      if (l.depth == depth - 1)
+        lp = &l.sections[sname];
+      else
+      {
+        lp = l.parent;
+        size_t n = l.depth - depth;
+        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)
+      {
+        lp->depth = depth;
+        lp->parent = parent;
+      }
+      parent->ordered_sections.push_back(parent->sections.find(sname));
+      parse(*lp);
+    }
+    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))));
+      if (!res.second)
+        err("duplicated key found");
+      l.ordered_values.push_back(res.first);
+    }
+  }
+}
+
+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;
+  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);
+    dump(s, (*it)->second, (*it)->first);
+  }
+}
+}
+
+#endif // INI_HPP

contrib/backends/nntpchan-daemon/daemon/main.cpp

@@ -0,0 +1,164 @@
+#include "ini.hpp"
+
+#include <nntpchan/crypto.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 <string>
+#include <vector>
+
+
+int main(int argc, char *argv[], char * argenv[])
+{
+  if (argc != 2)
+  {
+    std::cerr << "usage: " << argv[0] << " config.ini" << std::endl;
+    return 1;
+  }
+
+  nntpchan::Crypto crypto;
+
+  std::unique_ptr<nntpchan::ev::Loop> loop(nntpchan::NewMainLoop());
+
+  std::unique_ptr<nntpchan::NNTPServer> nntp = std::make_unique<nntpchan::NNTPServer>(loop.get());
+
+  std::string fname(argv[1]);
+
+  std::ifstream i(fname);
+
+  if (i.is_open())
+  {
+    INI::Parser conf(i);
+
+    std::vector<std::string> requiredSections = {"nntp", "articles"};
+
+    auto &level = conf.top();
+
+    for (const auto &section : 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;
+
+    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;
+
+    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())
+    {
+      std::cerr << "nntp section lacks 'instance_name' value" << std::endl;
+      return 1;
+    }
+
+    nntp->SetInstanceName(nntpconf["instance_name"]);
+
+    if (nntpconf.find("authdb") != nntpconf.end())
+    {
+      nntp->SetLoginDB(nntpconf["authdb"]);
+    }
+
+    if (level.sections.find("frontend") != level.sections.end())
+    {
+      // frontend enabled
+      auto &frontconf = level.sections["frontend"].values;
+      if (frontconf.find("type") == frontconf.end())
+      {
+        std::cerr << "frontend section provided but 'type' value not provided" << std::endl;
+        return 1;
+      }
+      auto &ftype = frontconf["type"];
+      if (ftype == "exec")
+      {
+        if (frontconf.find("exec") == frontconf.end())
+        {
+          std::cerr << "exec frontend specified but no 'exec' value provided" << std::endl;
+          return 1;
+        }
+        nntp->SetFrontend(new nntpchan::ExecFrontend(frontconf["exec"], argenv));
+      }
+      else if (ftype == "staticfile")
+      {
+        auto required = {"template_dir", "out_dir", "template_dialect", "max_pages"};
+        for (const auto &opt : required)
+        {
+          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)
+        {
+          std::cerr << "max_pages invalid value '" << frontconf["max_pages"] << "'" << std::endl;
+          return 1;
+        }
+        auto & dialect = frontconf["template_dialect"];
+        auto templateEngine = nntpchan::CreateTemplateEngine(dialect);
+        if(templateEngine == nullptr)
+        {
+          std::cerr << "invalid template dialect '" << dialect << "'" << std::endl;
+          return 1;
+        }
+        nntp->SetFrontend(new nntpchan::StaticFileFrontend(templateEngine, frontconf["template_dir"], frontconf["out_dir"], maxPages));
+      }
+      else
+      {
+        std::cerr << "unknown frontend type '" << ftype << "'" << std::endl;
+        return 1;
+      }
+    }
+    else 
+    {
+      std::cerr << "no frontend configured, running without generating markup" << std::endl;
+    }
+
+    auto &a = nntpconf["bind"];
+
+    try
+    {
+      if(nntp->Bind(a))
+      {
+        std::cerr << "nntpd for " << nntp->InstanceName() << " bound to " << a << std::endl;
+      }
+      else 
+      {
+        std::cerr << "nntpd for " << nntp->InstanceName() << " failed to bind to " << a << ": "<< strerror(errno) << std::endl;
+        return 1;
+      }
+    } catch (std::exception &ex)
+    {
+      std::cerr << "failed to bind: " << ex.what() << std::endl;
+      return 1;
+    }
+
+    loop->Run();
+    std::cerr << "Exiting" << std::endl;
+  }
+  else
+  {
+    std::cerr << "failed to open " << fname << std::endl;
+    return 1;
+  }
+}

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

@@ -0,0 +1,22 @@
+#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);
+
+/** returns base32 encoded string */
+std::string B32Encode(const uint8_t *data, const std::size_t l);
+
+/** @brief returns true if decode was successful */
+bool B32Decode(const std::string &data, std::vector<uint8_t> &out);
+
+}
+
+#endif

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

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

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

@@ -0,0 +1,52 @@
+#ifndef NNTPCHAN_EVENT_HPP
+#define NNTPCHAN_EVENT_HPP
+
+#include <unistd.h>
+#include <cstdint>
+#include <string>
+#include <sys/socket.h>
+
+namespace nntpchan
+{
+namespace ev
+{
+  struct io
+  {
+    int fd;
+
+    io(int f) : fd(f) {};
+    virtual ~io() {};
+    virtual bool readable() const { return true; };
+    virtual int read(char * buf, size_t sz) = 0;
+    virtual bool writeable() const { return true; };
+    virtual int write(size_t avail) = 0;
+    virtual bool keepalive() = 0;
+    virtual void close() 
+    { 
+      if(fd!=-1)
+      {
+        ::close(fd);
+      }
+    };
+    virtual bool acceptable() const { return false; };
+    virtual int accept() { return -1; };
+  };
+
+  struct Loop
+  {
+  public:
+    virtual ~Loop() {};
+
+    bool BindTCP(const sockaddr * addr, ev::io * handler);
+    virtual bool TrackConn(ev::io * handler) = 0;
+    virtual void UntrackConn(ev::io * handler) = 0;
+    virtual void Run() = 0;
+    bool SetNonBlocking(ev::io *handler);
+  };
+}
+
+ev::Loop * NewMainLoop();
+
+}
+
+#endif

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

@@ -0,0 +1,28 @@
+#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, char * const* env);
+
+  ~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:
+  char * const* m_Environ;
+  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 <experimental/filesystem>
+#include <fstream>
+#include <memory>
+
+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,28 @@
+#ifndef NNTPCHAN_FRONTEND_HPP
+#define NNTPCHAN_FRONTEND_HPP
+#include <experimental/filesystem>
+#include <memory>
+#include <string>
+namespace nntpchan
+{
+
+namespace fs = std::experimental::filesystem;
+/** @brief nntpchan frontend ui interface */
+class Frontend
+{
+public:
+  virtual ~Frontend() {};
+  /** @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,4 @@
+#ifndef NNTPCHAN_HTTP_HPP
+#define NNTPCHAN_HTTP_HPP
+
+#endif

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+#ifndef NNTPCHAN_LINE_HPP
+#define NNTPCHAN_LINE_HPP
+#include "server.hpp"
+#include <stdint.h>
+#include <sstream>
+
+namespace nntpchan
+{
+
+/** @brief a buffered line reader */
+class LineReader
+{
+public:
+
+  /** @brief queue inbound data from connection */
+  void Data(const char *data, ssize_t s);
+
+protected:
+  /** @brief handle a line from the client */
+  virtual void HandleLine(const std::string line) = 0;
+
+private:
+  
+  std::stringstream m_line;
+  std::string m_leftover;
+};
+}
+
+#endif

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

@@ -0,0 +1,22 @@
+#ifndef NNTPCHAN_MESSAGE_HPP
+#define NNTPCHAN_MESSAGE_HPP
+
+#include <memory>
+#include <nntpchan/model.hpp>
+
+namespace nntpchan
+{
+struct MessageDB
+{
+  using BoardPage = nntpchan::model::BoardPage;
+  using Thread = nntpchan::model::Thread;
+  virtual ~MessageDB() {};
+  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;
+}
+
+#endif

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

@@ -0,0 +1,29 @@
+#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,65 @@
+#ifndef NNTPCHAN_MODEL_HPP
+#define NNTPCHAN_MODEL_HPP
+#include <algorithm>
+#include <map>
+#include <nntpchan/sanitize.hpp>
+#include <set>
+#include <string>
+#include <tuple>
+#include <variant>
+#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
+struct BoardPage
+{
+  std::vector<Thread> threads = {};
+  std::string name = "";
+  uint32_t pageno = 0;
+};
+
+
+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 &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 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 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; });
+  if (itr == std::end(header))
+    return fallback;
+  else
+    return itr->second[0];
+}
+
+using Model = std::variant<Thread, BoardPage>;
+}
+}
+
+#endif

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

@@ -0,0 +1,24 @@
+#ifndef NNTPCHAN_NET_HPP
+#define NNTPCHAN_NET_HPP
+
+#include <netinet/in.h>
+#include <string>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+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,64 @@
+#ifndef NNTPCHAN_NNTP_AUTH_HPP
+#define NNTPCHAN_NNTP_AUTH_HPP
+#include "line.hpp"
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <string>
+
+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,61 @@
+#ifndef NNTPCHAN_NNTP_HANDLER_HPP
+#define NNTPCHAN_NNTP_HANDLER_HPP
+#include "line.hpp"
+#include "nntp_auth.hpp"
+#include "storage.hpp"
+#include <deque>
+#include <string>
+
+namespace nntpchan
+{
+class NNTPServerHandler : public LineReader, public IConnHandler
+{
+public:
+  NNTPServerHandler(fs::path 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,51 @@
+#ifndef NNTPCHAN_NNTP_SERVER_HPP
+#define NNTPCHAN_NNTP_SERVER_HPP
+#include "frontend.hpp"
+#include "server.hpp"
+#include <deque>
+#include <string>
+
+namespace nntpchan
+{
+
+class NNTPServer : public Server
+{
+public:
+  NNTPServer(ev::Loop * 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;
+
+  virtual IServerConn *CreateConn(int fd);
+
+  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(int fd, Server *parent, IConnHandler *h) : IServerConn(fd, parent, h) {}
+
+  virtual bool IsTimedOut() { return false; };
+
+  virtual void Greet();
+};
+}
+
+#endif

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

@@ -0,0 +1,14 @@
+#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);
+std::string StripWhitespaces(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,96 @@
+#ifndef NNTPCHAN_SERVER_HPP
+#define NNTPCHAN_SERVER_HPP
+#include <deque>
+#include <functional>
+#include <string>
+#include <nntpchan/event.hpp>
+
+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 : public ev::io
+{
+  IServerConn(int fd, Server *parent, IConnHandler *h);
+  virtual ~IServerConn();
+  virtual int read(char * buf, size_t sz);
+  virtual int write(size_t avail);
+  virtual void close();
+  virtual void Greet() = 0;
+  virtual bool IsTimedOut() = 0;
+  virtual bool keepalive() ;
+  Server *Parent() { return m_parent; };
+  IConnHandler *GetHandler() { return m_handler; };
+
+private:
+  Server *m_parent;
+  IConnHandler *m_handler;
+  std::string m_writeLeftover;
+};
+
+class Server : public ev::io
+{
+public:
+  Server(ev::Loop * loop);
+  virtual ~Server() {};
+
+  virtual bool acceptable() const { return true; };
+  virtual void close();
+  virtual bool readable() const { return false; };
+  virtual int read(char *,size_t) { return -1; };
+  virtual bool writeable() const { return false; };
+  virtual int write(size_t) {return -1; };
+  virtual int accept();
+  virtual bool keepalive() { return true; };
+
+
+  /** create connection handler from open stream */
+  virtual IServerConn *CreateConn(int fd) = 0;
+  /** bind to address */
+  bool 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);
+
+private:
+
+  void OnAccept(int fd);
+  ev::Loop * m_Loop;
+  std::deque<IServerConn *> m_conns;
+};
+}
+
+#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,34 @@
+#ifndef NNTPCHAN_STATICFILE_FRONTEND_HPP
+#define NNTPCHAN_STATICFILE_FRONTEND_HPP
+#include "frontend.hpp"
+#include "message.hpp"
+#include "model.hpp"
+#include "template_engine.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);
+
+  virtual ~StaticFileFrontend();
+
+  virtual void ProcessNewMessage(const fs::path &fpath);
+  virtual bool AcceptsNewsgroup(const std::string &newsgroup);
+  virtual bool AcceptsMessage(const std::string &msgid);
+
+private:
+  MessageDB_ptr m_MessageDB;
+  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,51 @@
+#ifndef NNTPCHAN_STORAGE_HPP
+#define NNTPCHAN_STORAGE_HPP
+
+#include "file_handle.hpp"
+#include "message.hpp"
+#include <experimental/filesystem>
+#include <string>
+
+namespace nntpchan
+{
+
+namespace fs = std::experimental::filesystem;
+
+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;
+
+  /**
+     return true if we should accept a new message give its message id
+   */
+  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;
+
+  /** ensure symlinks are formed for this article by message id */
+  void EnsureSymlinks(const std::string &msgid) const;
+
+private:
+  void SetPath(const fs::path &fpath);
+
+  fs::path MessagePath(const std::string &msgid) const;
+
+  bool init_skiplist(const std::string &subdir) const;
+
+  fs::path skiplist_root(const std::string &name) const;
+  fs::path skiplist_dir(const fs::path & root, const std::string & name) const;
+
+  fs::path basedir;
+};
+
+typedef std::unique_ptr<ArticleStorage> ArticleStorage_ptr;
+}
+
+#endif

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

@@ -0,0 +1,27 @@
+#ifndef NNTPCHAN_TEMPLATE_ENGINE_HPP
+#define NNTPCHAN_TEMPLATE_ENGINE_HPP
+#include "file_handle.hpp"
+#include "model.hpp"
+#include <any>
+#include <map>
+#include <memory>
+#include <string>
+
+namespace nntpchan
+{
+
+struct TemplateEngine
+{
+  virtual ~TemplateEngine() {};
+  virtual bool WriteBoardPage(const nntpchan::model::BoardPage & page, const FileHandle_ptr &out) = 0;
+  virtual bool WriteThreadPage(const nntpchan::model::Thread & thread, const FileHandle_ptr &out) = 0;
+};
+
+
+
+typedef std::unique_ptr<TemplateEngine> TemplateEngine_ptr;
+
+TemplateEngine * CreateTemplateEngine(const std::string &dialect);
+}
+
+#endif

contrib/backends/nntpchan-daemon/libnntpchan/base64.cpp

@@ -0,0 +1,334 @@
+#include <nntpchan/base64.hpp>
+
+// taken from i2pd
+namespace i2p
+{
+namespace data
+{
+
+static const char T32[32] = {
+    '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', '2', '3', '4', '5', '6', '7',
+};
+
+const char *GetBase32SubstitutionTable() { return T32; }
+
+static void iT64Build(void);
+
+/*
+ *
+ * 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', '-', '~'};
+
+const char *GetBase64SubstitutionTable() { return T64; }
+
+/*
+ * Reverse Substitution Table (built in run time)
+ */
+
+static char iT64[256];
+static int isFirstTime = 1;
+
+/*
+ * Padding
+ */
+
+static char P64 = '=';
+
+/*
+ *
+ * ByteStreamToBase64
+ * ------------------
+ *
+ * Converts binary encoded data to BASE64 format.
+ *
+ */
+
+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 */
+                   size_t len               /* length of output buffer */
+)
+
+{
+  unsigned char *ps;
+  unsigned char *pd;
+  unsigned char acc_1;
+  unsigned char acc_2;
+  int i;
+  int n;
+  int m;
+  size_t outCount;
+
+  ps = (unsigned char *)InBuffer;
+  n = InCount / 3;
+  m = InCount % 3;
+  if (!m)
+    outCount = 4 * n;
+  else
+    outCount = 4 * (n + 1);
+  if (outCount > len)
+    return 0;
+  pd = (unsigned char *)OutBuffer;
+  for (i = 0; i < n; i++)
+  {
+    acc_1 = *ps++;
+    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_2 = *ps++;
+    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)
+  {
+    acc_1 = *ps++;
+    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)
+  {
+    acc_1 = *ps++;
+    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 */
+    *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
+ *
+ */
+
+size_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 */
+                   size_t len            /* length of output buffer */
+)
+{
+  unsigned char *ps;
+  unsigned char *pd;
+  unsigned char acc_1;
+  unsigned char acc_2;
+  int i;
+  int n;
+  int m;
+  size_t outCount;
+
+  if (isFirstTime)
+    iT64Build();
+  n = InCount / 4;
+  m = InCount % 4;
+  if (InCount && !m)
+    outCount = 3 * n;
+  else
+  {
+    outCount = 0;
+    return 0;
+  }
+
+  ps = (unsigned char *)(InBuffer + InCount - 1);
+  while (*ps-- == P64)
+    outCount--;
+  ps = (unsigned char *)InBuffer;
+
+  if (outCount > len)
+    return -1;
+  pd = OutBuffer;
+  auto endOfOutBuffer = OutBuffer + outCount;
+  for (i = 0; i < n; i++)
+  {
+    acc_1 = iT64[*ps++];
+    acc_2 = iT64[*ps++];
+    acc_1 <<= 2;
+    acc_1 |= acc_2 >> 4;
+    *pd++ = acc_1;
+    if (pd >= endOfOutBuffer)
+      break;
+
+    acc_2 <<= 4;
+    acc_1 = iT64[*ps++];
+    acc_2 |= acc_1 >> 2;
+    *pd++ = acc_2;
+    if (pd >= endOfOutBuffer)
+      break;
+
+    acc_2 = iT64[*ps++];
+    acc_2 |= acc_1 << 6;
+    *pd++ = acc_2;
+  }
+
+  return outCount;
+}
+
+size_t Base64EncodingBufferSize(const size_t input_size)
+{
+  auto d = div(input_size, 3);
+  if (d.rem)
+    d.quot++;
+  return 4 * d.quot;
+}
+
+size_t Base32EncodingBufferSize(const size_t input_size)
+{
+  auto d = div(input_size, 5);
+  if (d.rem)
+    d.quot++;
+  return 8 * d.quot;
+}
+/*
+ *
+ * iT64
+ * ----
+ * Reverse table builder. P64 character is replaced with 0
+ *
+ *
+ */
+
+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;
+  iT64[(int)P64] = 0;
+}
+
+size_t Base32ToByteStream(const char *inBuf, size_t len, uint8_t *outBuf, size_t outLen)
+{
+  int tmp = 0, bits = 0;
+  size_t ret = 0;
+  for (size_t i = 0; i < len; i++)
+  {
+    char ch = inBuf[i];
+    if (ch >= '2' && ch <= '7') // digit
+      ch = (ch - '2') + 26;     // 26 means a-z
+    else if (ch >= 'a' && ch <= 'z')
+      ch = ch - 'a'; // a = 0
+    else
+      return 0; // unexpected character
+
+    tmp |= ch;
+    bits += 5;
+    if (bits >= 8)
+    {
+      if (ret >= outLen)
+        return ret;
+      outBuf[ret] = tmp >> (bits - 8);
+      bits -= 8;
+      ret++;
+    }
+    tmp <<= 5;
+  }
+  return ret;
+}
+
+size_t ByteStreamToBase32(const uint8_t *inBuf, size_t len, char *outBuf, size_t outLen)
+{
+  size_t ret = 0, pos = 1;
+  int bits = 8, tmp = inBuf[0];
+  while (ret < outLen && (bits > 0 || pos < len))
+  {
+    if (bits < 5)
+    {
+      if (pos < len)
+      {
+        tmp <<= 8;
+        tmp |= inBuf[pos] & 0xFF;
+        pos++;
+        bits += 8;
+      }
+      else // last byte
+      {
+        tmp <<= (5 - bits);
+        bits = 5;
+      }
+    }
+
+    bits -= 5;
+    int ind = (tmp >> bits) & 0x1F;
+    outBuf[ret] = (ind < 26) ? (ind + 'a') : ((ind - 26) + '2');
+    ret++;
+  }
+  return ret;
+}
+}
+}
+
+namespace nntpchan
+{
+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)
+{
+  out.resize(data.size());
+  if (i2p::data::Base64ToByteStream(data.c_str(), data.size(), &out[0], out.size()))
+  {
+    out.shrink_to_fit();
+    return true;
+  }
+  return false;
+}
+
+std::string B32Encode(const uint8_t *data, const std::size_t l)
+{
+  std::string out;
+  out.resize(i2p::data::Base32EncodingBufferSize(l));
+  i2p::data::ByteStreamToBase32(data, l, &out[0], out.size());
+  return out;
+}
+
+bool B32Decode(const std::string &data, std::vector<uint8_t> &out)
+{
+  out.resize(data.size());
+  if (i2p::data::Base32ToByteStream(data.c_str(), data.size(), &out[0], out.size()))
+  {
+    out.shrink_to_fit();
+    return true;
+  }
+  return false;
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/crypto.cpp

@@ -0,0 +1,25 @@
+#include <cassert>
+#include <nntpchan/base64.hpp>
+#include <nntpchan/crypto.hpp>
+#include <sodium.h>
+
+namespace nntpchan
+{
+void SHA512(const uint8_t *d, const std::size_t l, SHA512Digest &h) { crypto_hash(h.data(), d, l); }
+
+void Blake2B(const uint8_t *d, std::size_t l, Blake2BDigest &h)
+{
+  crypto_generichash(h.data(), h.size(), d, l, nullptr, 0);
+}
+
+std::string Blake2B_base32(const std::string &str)
+{
+  Blake2BDigest d;
+  Blake2B(reinterpret_cast<const uint8_t *>(str.c_str()), str.size(), d);
+  return B32Encode(d.data(), d.size());
+}
+
+Crypto::Crypto() { assert(sodium_init() == 0); }
+
+Crypto::~Crypto() {}
+}

contrib/backends/nntpchan-daemon/libnntpchan/crypto_old.hpp

@@ -0,0 +1,28 @@
+
+
+#ifndef NNTPCHAN_CRYPTO_OLD_HPP
+#define NNTPCHAN_CRYPTO_OLD_HPP
+
+#include <cstdint>
+#include <cstdlib>
+extern "C" {
+
+typedef struct
+{
+  uint32_t state[5];
+  uint32_t count[2];
+  unsigned char buffer[64];
+} SHA1_CTX;
+
+void SHA1Transform(uint32_t state[5], const unsigned char buffer[64]);
+
+void SHA1Init(SHA1_CTX *context);
+
+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);
+}
+
+#endif

contrib/backends/nntpchan-daemon/libnntpchan/epoll.hpp

@@ -0,0 +1,183 @@
+#include <cassert>
+#include <nntpchan/event.hpp>
+#include <sys/epoll.h>
+#include <unistd.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/signalfd.h>
+
+#include <iostream>
+
+namespace nntpchan
+{
+namespace ev
+{
+  template<size_t bufsz>
+  struct EpollLoop : public Loop
+  {
+    size_t conns;
+    int epollfd;
+    char readbuf[bufsz];
+    EpollLoop() : conns(0), epollfd(epoll_create1(EPOLL_CLOEXEC))
+    {
+    }
+    
+    virtual ~EpollLoop()
+    {
+        ::close(epollfd);
+    }
+
+    
+
+    virtual bool TrackConn(ev::io * handler)
+    {
+        epoll_event ev;
+        ev.data.ptr = handler;
+        ev.events = EPOLLET;
+        if(handler->readable() || handler->acceptable())
+        {
+            ev.events |= EPOLLIN;
+        }
+        if(handler->writeable())
+        {
+            ev.events |= EPOLLOUT;
+        }
+        if ( epoll_ctl(epollfd, EPOLL_CTL_ADD, handler->fd, &ev) == -1)
+        {
+            return false;
+        }
+        ++conns;
+        return true;
+    }
+
+    virtual void UntrackConn(ev::io * handler)
+    {
+        if(epoll_ctl(epollfd, EPOLL_CTL_DEL, handler->fd, nullptr) != -1)
+            --conns;
+    }
+
+
+    virtual void Run() 
+    {
+        epoll_event evs[512];
+        epoll_event * ev;
+        ev::io * handler;
+        int res = -1;
+        int idx ;
+
+        sigset_t mask;
+        
+        sigemptyset(&mask);
+        sigaddset(&mask, SIGWINCH);
+
+        int sfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
+        epoll_event sig_ev;
+        sig_ev.data.fd = sfd;
+        sig_ev.events = EPOLLIN;
+        epoll_ctl(epollfd, EPOLL_CTL_ADD, sfd, &sig_ev);
+        do
+        {
+            res = epoll_wait(epollfd, evs, 512, -1);
+            idx = 0;
+            while(idx < res)
+            {
+                errno = 0;
+                ev = &evs[idx++];
+                if(ev->data.fd == sfd)
+                {
+                    read(sfd, readbuf, sizeof(readbuf));
+                    continue;
+                }
+                
+                handler = static_cast<ev::io *>(ev->data.ptr);
+
+                if(ev->events & EPOLLERR || ev->events & EPOLLHUP)
+                {
+                    handler->close();
+                    delete handler;
+                    continue;
+                }
+
+                if (handler->acceptable())
+                {
+                    int acceptfd;
+                    bool errored = false;
+                    while(true)
+                    {
+                    acceptfd = handler->accept();
+                    if(acceptfd == -1)
+                    {
+                        if (errno == EAGAIN || errno == EWOULDBLOCK)
+                        {
+                        break;
+                        }
+                        perror("accept()");
+                        errored = true;
+                        break;
+                    }
+                    }
+                    if(errored)
+                    {
+                    handler->close();
+                    delete handler;
+                    continue;
+                    }
+                }
+                if(ev->events & EPOLLIN && handler->readable())
+                {
+                    bool errored = false;
+                    while(true)
+                    {
+                    int readed = handler->read(readbuf, sizeof(readbuf));
+                    if(readed == -1)
+                    {
+                        if(errno != EAGAIN)
+                        {
+                        perror("read()");
+                        handler->close();
+                        delete handler;
+                        errored = true;
+                        }
+                        break;
+                    }
+                    else if (readed == 0)
+                    {
+                        handler->close();
+                        delete handler;
+                        errored = true;
+                        break;
+                    }
+                    }
+                    if(errored) continue;
+                }
+                if(ev->events & EPOLLOUT && handler->writeable())
+                {
+                    int written = handler->write(1024);
+                    if(written < 0)
+                    {
+                        if (errno == EAGAIN || errno == EWOULDBLOCK)
+                        {
+                            // blocking
+                        }
+                        else
+                        {
+                            perror("write()");
+                            handler->close();
+                            delete handler;
+                        }
+                    }
+                }
+                if (!handler->keepalive())
+                {
+                    handler->close();
+                    delete handler;
+                }
+            }
+        }
+        while(res != -1 && conns);
+    }
+};
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/event.cpp

@@ -0,0 +1,78 @@
+#include <fcntl.h>
+#include <cstdlib>
+#include <cassert>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+
+constexpr std::size_t ev_buffsz = 512;
+
+#ifdef __linux__
+#include "epoll.hpp"
+typedef nntpchan::ev::EpollLoop<ev_buffsz> LoopImpl;
+#else
+#ifdef __FreeBSD__
+#include "kqueue.hpp"
+typedef nntpchan::ev::KqueueLoop<ev_buffsz> LoopImpl;
+#else
+#ifdef __netbsd__
+typedef nntpchan::ev::KqueueLoop<ev_buffsz> LoopImpl;
+#else
+#error "unsupported platform"
+#endif
+#endif
+#endif
+
+namespace nntpchan
+{
+namespace ev
+{
+bool ev::Loop::BindTCP(const sockaddr *addr, ev::io *handler)
+{
+  assert(handler->acceptable());
+  socklen_t slen;
+  switch (addr->sa_family)
+  {
+  case AF_INET:
+    slen = sizeof(sockaddr_in);
+    break;
+  case AF_INET6:
+    slen = sizeof(sockaddr_in6);
+    break;
+  case AF_UNIX:
+    slen = sizeof(sockaddr_un);
+    break;
+  default:
+    return false;
+  }
+  int fd = socket(addr->sa_family, SOCK_STREAM | SOCK_NONBLOCK, 0);
+  if (fd == -1)
+  {
+    return false;
+  }
+
+  if (bind(fd, addr, slen) == -1)
+  {
+    ::close(fd);
+    return false;
+  }
+
+  if (listen(fd, 5) == -1)
+  {
+    ::close(fd);
+    return false;
+  }
+
+  handler->fd = fd;
+  return TrackConn(handler);
+}
+
+bool Loop::SetNonBlocking(ev::io *handler)
+{
+  return fcntl(handler->fd, F_SETFL, fcntl(handler->fd, F_GETFL, 0) | O_NONBLOCK) != -1;
+}
+}
+
+ev::Loop *NewMainLoop() { return new LoopImpl; }
+}

contrib/backends/nntpchan-daemon/libnntpchan/exec_frontend.cpp

@@ -0,0 +1,51 @@
+#include <cstring>
+#include <errno.h>
+#include <iostream>
+#include <nntpchan/exec_frontend.hpp>
+#include <sys/wait.h>
+#include <unistd.h>
+
+namespace nntpchan
+{
+ExecFrontend::ExecFrontend(const std::string &fname, char * const* env) : m_Environ(env), m_exec(fname) {}
+
+ExecFrontend::~ExecFrontend() {}
+
+void ExecFrontend::ProcessNewMessage(const fs::path &fpath) { Exec({"post", fpath}); }
+
+bool ExecFrontend::AcceptsNewsgroup(const std::string &newsgroup) { return Exec({"newsgroup", newsgroup}) == 0; }
+
+bool ExecFrontend::AcceptsMessage(const std::string &msgid) { return Exec({"msgid", msgid}) == 0; }
+
+int ExecFrontend::Exec(std::deque<std::string> args)
+{
+  // set up arguments
+  const char **cargs = new char const *[args.size() + 2];
+  std::size_t l = 0;
+  cargs[l++] = m_exec.c_str();
+  while (args.size())
+  {
+    cargs[l++] = args.front().c_str();
+    args.pop_front();
+  }
+  cargs[l] = 0;
+  int retcode = 0;
+  pid_t child = fork();
+  if (child)
+  {
+    waitpid(child, &retcode, 0);
+  }
+  else
+  {
+    int r = execve(m_exec.c_str(), (char *const *)cargs, m_Environ);
+    if (r == -1)
+    {
+      std::cout << strerror(errno) << std::endl;
+      exit(errno);
+    }
+    else
+      exit(r);
+  }
+  return retcode;
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/file_handle.cpp

@@ -0,0 +1,21 @@
+#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)
+  {
+    f->open(fname, std::ios::in);
+  }
+  else if (mode == eWrite)
+  {
+    f->open(fname, std::ios::out);
+  }
+  if (f->is_open())
+    return FileHandle_ptr(f);
+  delete f;
+  return nullptr;
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/kqueue.hpp

@@ -0,0 +1,162 @@
+#include <nntpchan/event.hpp>
+#include <sys/types.h>
+#include <sys/event.h>
+
+#include <iostream>
+#include <cstring>
+#include <errno.h>
+
+namespace nntpchan 
+{
+namespace ev 
+{
+    template<size_t bufsz>
+    struct KqueueLoop : public Loop
+    {
+        int kfd;
+        size_t conns;
+        char readbuf[bufsz];
+
+
+        KqueueLoop() : kfd(kqueue()), conns(0)
+        {
+
+        };
+
+        virtual ~KqueueLoop()
+        {
+            ::close(kfd);
+        }
+
+        virtual bool TrackConn(ev::io * handler)
+        {
+            struct kevent event;
+            short filter = 0;
+            if(handler->readable() || handler->acceptable())
+            {   
+                filter |= EVFILT_READ;
+            }
+            if(handler->writeable())
+            {
+                filter |= EVFILT_WRITE;
+            }
+            EV_SET(&event, handler->fd, filter, EV_ADD | EV_CLEAR, 0, 0, handler);
+            int ret = kevent(kfd, &event, 1, nullptr, 0, nullptr);
+            if(ret == -1) return false;
+            if(event.flags & EV_ERROR) 
+            {
+                std::cerr << "KqueueLoop::TrackConn() kevent failed: " << strerror(event.data) << std::endl;
+                return false;
+            }
+            ++conns;
+            return true;
+        }
+
+        virtual void UntrackConn(ev::io * handler)
+        {
+            struct kevent event;
+            short filter = 0;
+            if(handler->readable() || handler->acceptable())
+            {   
+                filter |= EVFILT_READ;
+            }
+            if(handler->writeable())
+            {
+                filter |= EVFILT_WRITE;
+            }
+            EV_SET(&event, handler->fd, filter, EV_DELETE, 0, 0, handler);
+            int ret = kevent(kfd, &event, 1, nullptr, 0, nullptr);
+            if(ret == -1 || event.flags & EV_ERROR) 
+                std::cerr << "KqueueLoop::UntrackConn() kevent failed: " << strerror(event.data) << std::endl;
+            else
+                --conns;
+        }
+
+        virtual void Run()
+        {
+            struct kevent events[512];
+            struct kevent * event;
+            io * handler;
+            int ret, idx;
+            do
+            {
+                idx = 0;
+                ret = kevent(kfd, nullptr, 0, events, 512, nullptr);
+                if(ret > 0)
+                {
+                    while(idx < ret)
+                    {
+                        event = &events[idx++];
+                        handler = static_cast<io *>(event->udata);
+                        if(event->flags & EV_EOF)
+                        {
+                            handler->close();
+                            delete handler;
+                            continue;
+                        }
+                        if(event->filter & EVFILT_READ && handler->acceptable())
+                        {
+                            int backlog = event->data;
+                            while(backlog)
+                            {
+                                handler->accept();
+                                --backlog;
+                            }
+                        }
+
+                        if(event->filter & EVFILT_READ && handler->readable())
+                        {
+                            int readed = 0;
+                            size_t readnum = event->data;
+                            while(readnum > sizeof(readbuf))
+                            {
+                                int r = handler->read(readbuf, sizeof(readbuf));
+                                if(r > 0)
+                                {
+                                    readnum -= r;
+                                    readed += r;
+                                }
+                                else
+                                    readnum = 0;
+                            }
+                            if(readnum && readed != -1)
+                            {
+                               int r = handler->read(readbuf, readnum);
+                               if(r > 0)
+                                 readed += r;
+                               else
+                                 readed = r;
+                            }
+                        }
+                        if(event->filter & EVFILT_WRITE && handler->writeable())
+                        {
+                            int writespace = 1024;
+                            int written = handler->write(writespace);
+                            if(written == -1)
+                            {
+                                if (errno == EAGAIN || errno == EWOULDBLOCK)
+                                {
+                                    // blocking
+                                }
+                                else 
+                                {
+                                    perror("write()");
+                                    handler->close();
+                                    delete handler;
+                                    continue;
+                                }
+                            }
+                        }
+                        if(!handler->keepalive())
+                        {
+                            handler->close();
+                            delete handler;
+                        }
+                    }
+                }
+            }
+            while(ret != -1);
+        }
+    };
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/line.cpp

@@ -0,0 +1,24 @@
+#include <nntpchan/line.hpp>
+
+namespace nntpchan
+{
+
+void LineReader::Data(const char *data, ssize_t l)
+{
+  if (l <= 0)
+    return;
+  m_line << m_leftover;
+  m_leftover = "";
+  m_line << std::string(data, l);
+
+  for (std::string line; std::getline(m_line, line);)
+  {
+    line.erase(std::remove(line.begin(), line.end(), '\r'), line.end());
+    HandleLine(line);
+  }
+  if (m_line)
+    m_leftover = m_line.str();
+  m_line.clear();
+}
+
+}

contrib/backends/nntpchan-daemon/libnntpchan/mime.cpp

@@ -0,0 +1,26 @@
+#include <nntpchan/mime.hpp>
+
+namespace nntpchan
+{
+bool ReadHeader(const FileHandle_ptr &file, RawHeader &header)
+{
+  std::string 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;
+
+    if (idx != std::string::npos && idx + 2 < endidx)
+    {
+      k = line.substr(0, idx);
+      v = line.substr(idx + 2, endidx);
+      header[k] = v;
+    }
+  }
+  return file->good();
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/net.cpp

@@ -0,0 +1,47 @@
+#include <cstring>
+#include <nntpchan/net.hpp>
+#include <sstream>
+#include <stdexcept>
+#include <arpa/inet.h>
+
+
+namespace nntpchan
+{
+std::string NetAddr::to_string()
+{
+  std::string str("invalid");
+  const size_t s = 128;
+  char *buff = new char[s];
+  if (inet_ntop(AF_INET6, &addr, buff, sizeof(sockaddr_in6)))
+  {
+    str = std::string(buff);
+    delete[] buff;
+  }
+  std::stringstream ss;
+  ss << "[" << str << "]:" << ntohs(addr.sin6_port);
+  return ss.str();
+}
+
+NetAddr::NetAddr() { std::memset(&addr, 0, sizeof(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 (addr[0] != '[')
+  {
+    throw std::runtime_error("invalid address: " + addr);
+  }
+  auto p = addr.substr(n + 2);
+  int port = std::atoi(p.c_str());
+  auto a = addr.substr(0, n);
+  saddr.addr.sin6_port = htons(port);
+  saddr.addr.sin6_family = AF_INET6;
+  inet_pton(AF_INET6, a.c_str(), &saddr.addr);
+  return saddr;
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/nntp_auth.cpp

@@ -0,0 +1,97 @@
+#include <array>
+#include <fstream>
+#include <iostream>
+#include <nntpchan/base64.hpp>
+#include <nntpchan/crypto.hpp>
+#include <nntpchan/nntp_auth.hpp>
+
+namespace nntpchan
+{
+HashedCredDB::HashedCredDB() : LineReader() {}
+
+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;
+  m_passwd = passwd;
+  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];
+  // read file
+  m_instream->read(buff, l);
+  Data(buff, l);
+  delete[] buff;
+  return m_found;
+}
+
+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)
+      part = part.substr(0, comment);
+    else
+      break;
+  }
+  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);
+
+  idx = part.find(":");
+  if (idx == std::string::npos)
+    return false; // bad format
+  std::string cred = part.substr(0, idx);
+  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))
+    m_found = true;
+}
+
+void HashedCredDB::SetStream(std::istream *s) { m_instream = s; }
+
+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);
+  return B64Encode(h.data(), h.size());
+}
+
+HashedFileDB::HashedFileDB(const std::string &fname) : m_fname(fname), f(nullptr) {}
+
+HashedFileDB::~HashedFileDB() {}
+
+void HashedFileDB::Close()
+{
+  if (f.is_open())
+    f.close();
+}
+
+bool HashedFileDB::Open()
+{
+  if (!f.is_open())
+    f.open(m_fname);
+  if (f.is_open())
+  {
+    SetStream(&f);
+    return true;
+  }
+  return false;
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/nntp_handler.cpp

@@ -0,0 +1,242 @@
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+#include <iostream>
+#include <nntpchan/nntp_handler.hpp>
+#include <nntpchan/sanitize.hpp>
+#include <sstream>
+#include <string>
+
+namespace nntpchan
+{
+NNTPServerHandler::NNTPServerHandler(fs::path storage)
+    : LineReader(), m_article(nullptr), m_auth(nullptr), m_store(storage), m_authed(false),
+      m_state(eStateReadCommand)
+{
+}
+
+NNTPServerHandler::~NNTPServerHandler() {}
+
+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);
+    }
+    if (command.size())
+      HandleCommand(command);
+    else
+      QueueLine("501 Syntax error");
+  }
+  else if (m_state == eStateStoreArticle)
+  {
+    std::string l = line + "\r\n";
+    OnData(l.c_str(), l.size());
+  }
+  else
+  {
+    std::cerr << "invalid state" << std::endl;
+  }
+}
+
+void NNTPServerHandler::OnData(const char *data, ssize_t l)
+{
+  if (l <= 0)
+    return;
+  if (m_state == eStateStoreArticle)
+  {
+    std::cerr << "storing " << l << " bytes" << std::endl;
+    if (strncmp(data, ".\r\n", l) == 0)
+    {
+      ArticleObtained();
+      return;
+    }
+    const char *end = strstr(data, "\r\n.\r\n");
+    if (end)
+    {
+      std::size_t diff = end - data;
+      if (m_article)
+      {
+        m_article->write(data, diff + 2);
+        m_article->flush();
+      }
+      ArticleObtained();
+      diff += 5;
+      if (l - diff)
+        Data(end + 5, l - diff);
+      return;
+    }
+    if (m_article)
+    {
+      m_article->write(data, l);
+      m_article->flush();
+    }
+  }
+  else
+    Data(data, l);
+}
+
+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)
+    std::cerr << " " << part;
+  std::cerr << std::endl;
+  if (cmd == "QUIT")
+  {
+    Quit();
+    return;
+  }
+  else if (cmd[0] == '5')
+  {
+    return;
+  }
+  else if (cmd == "MODE")
+  {
+    if (cmdlen == 2)
+    {
+      // set mode
+      SwitchMode(command[1]);
+    }
+    else if (cmdlen)
+    {
+      // too many arguments
+      QueueLine("500 too many arguments");
+    }
+    else
+    {
+      // get mode
+      QueueLine("500 wrong arguments");
+    }
+  }
+  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))
+      {
+        QueueLine("238 " + msgid);
+      }
+      else
+        QueueLine("438 " + msgid);
+    }
+    else
+      QueueLine("501 syntax error");
+  }
+  else if (cmd == "TAKETHIS")
+  {
+    if (cmdlen >= 2)
+    {
+      const std::string &msgid = command[1];
+      if (m_store.Accept(msgid))
+      {
+        m_article = m_store.OpenWrite(msgid);
+      }
+      m_articleName = msgid;
+      EnterState(eStateStoreArticle);
+      return;
+    }
+    QueueLine("501 invalid syntax");
+  }
+  else
+  {
+    // unknown command
+    QueueLine("500 Unknown Command");
+  }
+}
+
+void NNTPServerHandler::ArticleObtained()
+{
+  if (m_article)
+  {
+    m_article->close();
+    m_article = nullptr;
+    m_store.EnsureSymlinks(m_articleName);
+    QueueLine("239 " + m_articleName);
+    std::cerr << "stored " << m_articleName << std::endl;
+  }
+  else
+    QueueLine("439 " + m_articleName);
+  m_articleName = "";
+  EnterState(eStateReadCommand);
+}
+
+void NNTPServerHandler::SwitchMode(const std::string &mode)
+{
+  std::string m = mode;
+  std::transform(m.begin(), m.end(), m.begin(), ::toupper);
+  if (m == "READER")
+  {
+    m_mode = m;
+    if (PostingAllowed())
+    {
+      QueueLine("200 Posting is permitted yo");
+    }
+    else
+    {
+      QueueLine("201 Posting is not permitted yo");
+    }
+  }
+  else if (m == "STREAM")
+  {
+    m_mode = m;
+    if (PostingAllowed())
+    {
+      QueueLine("203 Streaming enabled");
+    }
+    else
+    {
+      QueueLine("483 Streaming Denied");
+    }
+  }
+  else
+  {
+    // unknown mode
+    QueueLine("500 Unknown mode");
+  }
+}
+
+void NNTPServerHandler::EnterState(State st)
+{
+  std::cerr << "enter state " << st << std::endl;
+  m_state = st;
+}
+
+void NNTPServerHandler::Quit()
+{
+  EnterState(eStateQuit);
+  QueueLine("205 quitting");
+}
+
+bool NNTPServerHandler::ShouldClose() { return m_state == eStateQuit; }
+
+bool NNTPServerHandler::PostingAllowed() { return m_authed || m_auth == nullptr; }
+
+void NNTPServerHandler::Greet()
+{
+  if (PostingAllowed())
+    QueueLine("200 Posting allowed");
+  else
+    QueueLine("201 Posting not allowed");
+}
+
+void NNTPServerHandler::SetAuth(CredDB_ptr creds) { m_auth = creds; }
+}

contrib/backends/nntpchan-daemon/libnntpchan/nntp_server.cpp

@@ -0,0 +1,51 @@
+
+#include <cassert>
+#include <cstring>
+#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(ev::Loop *loop) : Server(loop), m_frontend(nullptr) {}
+
+NNTPServer::~NNTPServer() {}
+
+IServerConn *NNTPServer::CreateConn(int f)
+{
+  CredDB_ptr creds;
+
+  std::ifstream i;
+  i.open(m_logindbpath);
+  if (i.is_open())
+    creds = std::make_shared<HashedFileDB>(m_logindbpath);
+
+  NNTPServerHandler *handler = new NNTPServerHandler(m_storagePath);
+  if (creds)
+    handler->SetAuth(creds);
+
+  return new NNTPServerConn(f, this, handler);
+}
+
+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() " << strerror(status) << std::endl; }
+
+void NNTPServerConn::Greet()
+{
+  IConnHandler *handler = GetHandler();
+  handler->Greet();
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/sanitize.cpp

@@ -0,0 +1,45 @@
+#include <algorithm>
+#include <cctype>
+#include <nntpchan/sanitize.hpp>
+#include <regex>
+
+namespace nntpchan
+{
+
+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);
+  return sane;
+}
+
+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); });
+  return lower;
+}
+
+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; }
+
+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; }
+
+std::string StripWhitespaces(const std::string &str)
+{
+  std::string stripped;
+  for (const auto &ch : str)
+    if (!(std::isspace(ch) || std::iscntrl(ch)))
+      stripped += ch;
+
+  return stripped;
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/server.cpp

@@ -0,0 +1,156 @@
+#include <cassert>
+#include <iostream>
+#include <nntpchan/net.hpp>
+#include <nntpchan/server.hpp>
+
+namespace nntpchan
+{
+
+Server::Server(ev::Loop *loop) : ev::io(-1), m_Loop(loop) {}
+
+void Server::close()
+{
+  auto itr = m_conns.begin();
+  while (itr != m_conns.end())
+  {
+    itr = m_conns.erase(itr);
+  }
+  m_Loop->UntrackConn(this);
+  ev::io::close();
+}
+bool Server::Bind(const std::string &addr)
+{
+  auto saddr = ParseAddr(addr);
+  return m_Loop->BindTCP(saddr, this);
+}
+
+void Server::OnAccept(int f)
+{
+  IServerConn *conn = CreateConn(f);
+  if (!m_Loop->SetNonBlocking(conn))
+  {
+    conn->close();
+    delete conn;
+  }
+  else if (m_Loop->TrackConn(conn))
+  {
+    m_conns.push_back(conn);
+    conn->Greet();
+    conn->write(1024);
+  }
+  else
+  {
+    conn->close();
+    delete conn;
+  }
+}
+
+int Server::accept()
+{
+  int res = ::accept(fd, nullptr, nullptr);
+  if (res == -1)
+    return res;
+  OnAccept(res);
+  return res;
+}
+
+void Server::RemoveConn(IServerConn *conn)
+{
+  auto itr = m_conns.begin();
+  while (itr != m_conns.end())
+  {
+    if (*itr == conn)
+      itr = m_conns.erase(itr);
+    else
+      ++itr;
+  }
+  m_Loop->UntrackConn(conn);
+}
+
+void IConnHandler::QueueLine(const std::string &line) { m_sendlines.push_back(line + "\r\n"); }
+
+bool IConnHandler::HasNextLine() { return m_sendlines.size() > 0; }
+
+std::string IConnHandler::GetNextLine()
+{
+  std::string line = m_sendlines[0];
+  m_sendlines.pop_front();
+  return line;
+}
+
+IServerConn::IServerConn(int fd, Server *parent, IConnHandler *h) : ev::io(fd), m_parent(parent), m_handler(h) {}
+
+IServerConn::~IServerConn() { delete m_handler; }
+
+int IServerConn::read(char *buf, size_t sz)
+{
+  ssize_t readsz = ::read(fd, buf, sz);
+  if (readsz > 0)
+  {
+    m_handler->OnData(buf, readsz);
+  }
+  return readsz;
+}
+
+bool IServerConn::keepalive() { return !m_handler->ShouldClose(); }
+
+int IServerConn::write(size_t avail)
+{
+  auto leftovers = m_writeLeftover.size();
+  int written = 0;
+  if (leftovers)
+  {
+    if (leftovers > avail)
+    {
+      leftovers = avail;
+    }
+    written = ::write(fd, m_writeLeftover.c_str(), leftovers);
+    if (written > 0)
+    {
+      avail -= written;
+      m_writeLeftover = m_writeLeftover.substr(written);
+    }
+    else
+    {
+      // too much leftovers
+      return -1;
+    }
+  }
+  do
+  {
+    if (!m_handler->HasNextLine())
+    {
+      return written;
+    }
+    auto line = m_handler->GetNextLine();
+    int wrote;
+    if (line.size() <= avail)
+    {
+      wrote = ::write(fd, line.c_str(), line.size());
+    }
+    else
+    {
+      auto subline = line.substr(0, avail);
+      wrote = ::write(fd, subline.c_str(), subline.size());
+    }
+    if (wrote > 0)
+    {
+      written += wrote;
+      avail -= wrote;
+      m_writeLeftover = line.substr(wrote);
+    }
+    else
+    {
+      m_writeLeftover = line;
+      return -1;
+    }
+  } while (avail > 0);
+  return written;
+}
+
+void IServerConn::close()
+{
+  m_parent->RemoveConn(this);
+  ev::io::close();
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/sha1.cpp

@@ -0,0 +1,314 @@
+/*
+SHA-1 in C
+By Steve Reid <steve@edmweb.com>
+100% Public Domain
+
+Test Vectors (from FIPS PUB 180-1)
+"abc"
+  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
+"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
+  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
+A million repetitions of "a"
+  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
+*/
+
+/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */
+/* #define SHA1HANDSOFF * Copies data before messing with it. */
+
+#include "crypto_old.hpp"
+#include <string>
+
+extern "C" {
+#define SHA1HANDSOFF
+
+#include <stdio.h>
+#include <string.h>
+
+/* 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))
+#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))
+
+/* (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);
+
+/* Hash a single 512-bit block. This is the core of the algorithm. */
+
+void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
+{
+  uint32_t a, b, c, d, e;
+
+  typedef union {
+    unsigned char c[64];
+    uint32_t l[16];
+  } CHAR64LONG16;
+
+#ifdef SHA1HANDSOFF
+  CHAR64LONG16 block[1]; /* use array to appear as a pointer */
+
+  memcpy(block, buffer, 64);
+#else
+  /* The following had better never be used because it causes the
+   * pointer-to-const buffer to be cast into a pointer to non-const.
+   * And the result is written through.  I threw a "const" in, hoping
+   * this will cause a diagnostic.
+   */
+  CHAR64LONG16 *block = (const CHAR64LONG16 *)buffer;
+#endif
+  /* Copy context->state[] to working vars */
+  a = state[0];
+  b = state[1];
+  c = state[2];
+  d = state[3];
+  e = state[4];
+  /* 4 rounds of 20 operations each. Loop unrolled. */
+  R0(a, b, c, d, e, 0);
+  R0(e, a, b, c, d, 1);
+  R0(d, e, a, b, c, 2);
+  R0(c, d, e, a, b, 3);
+  R0(b, c, d, e, a, 4);
+  R0(a, b, c, d, e, 5);
+  R0(e, a, b, c, d, 6);
+  R0(d, e, a, b, c, 7);
+  R0(c, d, e, a, b, 8);
+  R0(b, c, d, e, a, 9);
+  R0(a, b, c, d, e, 10);
+  R0(e, a, b, c, d, 11);
+  R0(d, e, a, b, c, 12);
+  R0(c, d, e, a, b, 13);
+  R0(b, c, d, e, a, 14);
+  R0(a, b, c, d, e, 15);
+  R1(e, a, b, c, d, 16);
+  R1(d, e, a, b, c, 17);
+  R1(c, d, e, a, b, 18);
+  R1(b, c, d, e, a, 19);
+  R2(a, b, c, d, e, 20);
+  R2(e, a, b, c, d, 21);
+  R2(d, e, a, b, c, 22);
+  R2(c, d, e, a, b, 23);
+  R2(b, c, d, e, a, 24);
+  R2(a, b, c, d, e, 25);
+  R2(e, a, b, c, d, 26);
+  R2(d, e, a, b, c, 27);
+  R2(c, d, e, a, b, 28);
+  R2(b, c, d, e, a, 29);
+  R2(a, b, c, d, e, 30);
+  R2(e, a, b, c, d, 31);
+  R2(d, e, a, b, c, 32);
+  R2(c, d, e, a, b, 33);
+  R2(b, c, d, e, a, 34);
+  R2(a, b, c, d, e, 35);
+  R2(e, a, b, c, d, 36);
+  R2(d, e, a, b, c, 37);
+  R2(c, d, e, a, b, 38);
+  R2(b, c, d, e, a, 39);
+  R3(a, b, c, d, e, 40);
+  R3(e, a, b, c, d, 41);
+  R3(d, e, a, b, c, 42);
+  R3(c, d, e, a, b, 43);
+  R3(b, c, d, e, a, 44);
+  R3(a, b, c, d, e, 45);
+  R3(e, a, b, c, d, 46);
+  R3(d, e, a, b, c, 47);
+  R3(c, d, e, a, b, 48);
+  R3(b, c, d, e, a, 49);
+  R3(a, b, c, d, e, 50);
+  R3(e, a, b, c, d, 51);
+  R3(d, e, a, b, c, 52);
+  R3(c, d, e, a, b, 53);
+  R3(b, c, d, e, a, 54);
+  R3(a, b, c, d, e, 55);
+  R3(e, a, b, c, d, 56);
+  R3(d, e, a, b, c, 57);
+  R3(c, d, e, a, b, 58);
+  R3(b, c, d, e, a, 59);
+  R4(a, b, c, d, e, 60);
+  R4(e, a, b, c, d, 61);
+  R4(d, e, a, b, c, 62);
+  R4(c, d, e, a, b, 63);
+  R4(b, c, d, e, a, 64);
+  R4(a, b, c, d, e, 65);
+  R4(e, a, b, c, d, 66);
+  R4(d, e, a, b, c, 67);
+  R4(c, d, e, a, b, 68);
+  R4(b, c, d, e, a, 69);
+  R4(a, b, c, d, e, 70);
+  R4(e, a, b, c, d, 71);
+  R4(d, e, a, b, c, 72);
+  R4(c, d, e, a, b, 73);
+  R4(b, c, d, e, a, 74);
+  R4(a, b, c, d, e, 75);
+  R4(e, a, b, c, d, 76);
+  R4(d, e, a, b, c, 77);
+  R4(c, d, e, a, b, 78);
+  R4(b, c, d, e, a, 79);
+  /* Add the working vars back into context.state[] */
+  state[0] += a;
+  state[1] += b;
+  state[2] += c;
+  state[3] += d;
+  state[4] += e;
+  /* Wipe variables */
+  a = b = c = d = e = 0;
+#ifdef SHA1HANDSOFF
+  memset(block, '\0', sizeof(block));
+#endif
+}
+
+/* SHA1Init - Initialize new context */
+
+void SHA1Init(SHA1_CTX *context)
+{
+  /* SHA1 initialization constants */
+  context->state[0] = 0x67452301;
+  context->state[1] = 0xEFCDAB89;
+  context->state[2] = 0x98BADCFE;
+  context->state[3] = 0x10325476;
+  context->state[4] = 0xC3D2E1F0;
+  context->count[0] = context->count[1] = 0;
+}
+
+/* Run your data through this. */
+
+void SHA1Update(SHA1_CTX *context, const unsigned char *data, uint32_t len)
+{
+  uint32_t i;
+
+  uint32_t j;
+
+  j = context->count[0];
+  if ((context->count[0] += len << 3) < j)
+    context->count[1]++;
+  context->count[1] += (len >> 29);
+  j = (j >> 3) & 63;
+  if ((j + len) > 63)
+  {
+    memcpy(&context->buffer[j], data, (i = 64 - j));
+    SHA1Transform(context->state, context->buffer);
+    for (; i + 63 < len; i += 64)
+    {
+      SHA1Transform(context->state, &data[i]);
+    }
+    j = 0;
+  }
+  else
+    i = 0;
+  memcpy(&context->buffer[j], &data[i], len - i);
+}
+
+/* Add padding and return the message digest. */
+
+void SHA1Final(unsigned char digest[20], SHA1_CTX *context)
+{
+  unsigned i;
+
+  unsigned char finalcount[8];
+
+  unsigned char c;
+
+#if 0 /* untested "improvement" by DHR */
+    /* Convert context->count to a sequence of bytes
+     * in finalcount.  Second element first, but
+     * big-endian order within element.
+     * But we do it all backwards.
+     */
+    unsigned char *fcp = &finalcount[8];
+
+    for (i = 0; i < 2; i++)
+    {
+        uint32_t t = context->count[i];
+
+        int j;
+
+        for (j = 0; j < 4; t >>= 8, j++)
+            *--fcp = (unsigned char) t}
+#else
+  for (i = 0; i < 8; i++)
+  {
+    finalcount[i] =
+        (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
+  }
+#endif
+  c = 0200;
+  SHA1Update(context, &c, 1);
+  while ((context->count[0] & 504) != 448)
+  {
+    c = 0000;
+    SHA1Update(context, &c, 1);
+  }
+  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);
+  }
+  /* 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)
+{
+  SHA1_CTX ctx;
+  size_t ii;
+
+  SHA1Init(&ctx);
+  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)
+    return n + 87;
+  else
+    return n + 48;
+}
+
+std::string sha1_hex(const std::string &data)
+{
+  uint8_t digest[20];
+  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)
+  {
+    out += nibble_to_char((digest[idx] & 0xf0) >> 8) + nibble_to_char(digest[idx] & 0x0f);
+    ++idx;
+  }
+
+  return out;
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/staticfile_frontend.cpp

@@ -0,0 +1,164 @@
+#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() {}
+
+void StaticFileFrontend::ProcessNewMessage(const fs::path &fpath)
+{
+  std::clog << "process message " << fpath << std::endl;
+  auto file = OpenFile(fpath, eRead);
+  if (file)
+  {
+    // read header
+    RawHeader header;
+    if (!ReadHeader(file, header))
+    {
+      std::clog << "failed to read mime header" << std::endl;
+      return;
+    }
+
+    // read body
+
+    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))
+    {
+      std::clog << "no message id for file " << fpath << std::endl;
+      return;
+    }
+
+    std::string msgid = StripWhitespaces(msgid_itr->second);
+
+    if (!IsValidMessageID(msgid))
+    {
+      std::clog << "invalid message-id: " << msgid << std::endl;
+      return;
+    }
+
+    std::string rootmsgid;
+
+    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)
+    {
+      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))
+      {
+        /** split off first element */
+        auto idx = std::find_if(s.begin(), s.end(), checkfunc);
+        rootmsgid = s.substr(0, s.find(*idx));
+      }
+      else
+      {
+        rootmsgid = references_itr->second;
+      }
+    }
+
+    std::string rootmsgid_hash = sha1_hex(rootmsgid);
+
+    std::set<std::string> newsgroups_list;
+
+    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))
+    {
+      std::clog << "no newsgroups header" << std::endl;
+      return;
+    }
+    std::istringstream input(group->second);
+
+    std::string newsgroup;
+    while (std::getline(input, 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;
+    }
+    if (m_TemplateEngine)
+    {
+      FileHandle_ptr out = OpenFile(threadFilePath, eWrite);
+      if (!out || !m_TemplateEngine->WriteThreadPage(thread, out))
+      {
+        std::clog << "failed to write " << threadFilePath << std::endl;
+        return;
+      }
+    }
+    nntpchan::model::BoardPage page;
+    for (const auto &name : newsgroups_list)
+    {
+      uint32_t pageno = 0;
+      while (pageno < m_Pages)
+      {
+        page.threads.clear();
+        if (!m_MessageDB->LoadBoardPage(page, name, 10, m_Pages))
+        {
+          std::clog << "cannot load board page " << pageno << " for " << name << std::endl;
+          break;
+        }
+        fs::path boardPageFilename(name + "-" + std::to_string(pageno) + ".html");
+        if (m_TemplateEngine)
+        {
+          fs::path outfile = m_OutDir / boardPageFilename;
+          FileHandle_ptr out = OpenFile(outfile, eWrite);
+          if (out)
+            m_TemplateEngine->WriteBoardPage(page, out);
+          else
+            std::clog << "failed to open board page " << outfile << std::endl;
+        }
+
+        ++pageno;
+      }
+    }
+  }
+}
+
+bool StaticFileFrontend::AcceptsNewsgroup(const std::string &newsgroup) { return IsValidNewsgroup(newsgroup); }
+
+bool StaticFileFrontend::AcceptsMessage(const std::string &msgid) { return IsValidMessageID(msgid); }
+}

contrib/backends/nntpchan-daemon/libnntpchan/storage.cpp

@@ -0,0 +1,94 @@
+#include <cassert>
+#include <nntpchan/crypto.hpp>
+#include <nntpchan/sanitize.hpp>
+#include <nntpchan/storage.hpp>
+#include <sstream>
+
+namespace nntpchan
+{
+
+const fs::path posts_skiplist_dir = "posts";
+const fs::path threads_skiplist_dir = "threads";
+
+ArticleStorage::ArticleStorage(const fs::path &fpath) { SetPath(fpath); }
+
+ArticleStorage::~ArticleStorage() {}
+
+void ArticleStorage::SetPath(const fs::path &fpath)
+{
+  basedir = fpath;
+  fs::create_directories(basedir);
+  assert(init_skiplist(posts_skiplist_dir));
+  assert(init_skiplist(threads_skiplist_dir));
+  errno = 0;
+}
+
+bool ArticleStorage::init_skiplist(const std::string &subdir) const
+{
+  fs::path skiplist = skiplist_root(subdir);
+  const auto subdirs = {
+      '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', '2', '3', '4', '5', '6', '7',
+  };
+  for (const auto &s : subdirs)
+    fs::create_directories(skiplist / std::string(&s, 1));
+  return true;
+}
+
+bool ArticleStorage::Accept(const std::string &msgid) const
+{
+  if (!IsValidMessageID(msgid))
+    return false;
+  auto p = MessagePath(msgid);
+  bool ret = !fs::exists(p);
+  errno = 0;
+  return ret;
+}
+
+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
+{
+  std::string msgidhash = Blake2B_base32(msgid);
+  auto skip = skiplist_dir(skiplist_root(posts_skiplist_dir), msgidhash) / msgidhash;
+  auto path = fs::path("..") / fs::path("..") / fs::path("..") / MessagePath(msgid);
+  fs::create_symlink(path, skip);
+  errno = 0;
+}
+
+fs::path ArticleStorage::skiplist_root(const std::string &name) const { return basedir / name; }
+fs::path ArticleStorage::skiplist_dir(const fs::path &root, const std::string &name) const
+{
+  return root / name.substr(0, 1);
+}
+}

contrib/backends/nntpchan-daemon/libnntpchan/template_engine.cpp

@@ -0,0 +1,93 @@
+#include <iostream>
+#include <nntpchan/sanitize.hpp>
+#include <nntpchan/template_engine.hpp>
+#include <sstream>
+
+namespace nntpchan
+{
+  struct StdTemplateEngine : public TemplateEngine
+  {
+    struct RenderContext 
+    {
+
+      bool Load(const fs::path & path)
+      {
+        // clear out previous data
+        m_Data.clear();
+        // open file
+        std::ifstream f;
+        f.open(path);
+        if(f.is_open())
+        {
+          for(std::string line; std::getline(f, line, '\n');)
+          {
+            m_Data += line + "\n";
+          }
+          return true;
+        }
+        else 
+          return false;
+      }
+
+      virtual bool Render(const FileHandle_ptr & out) const = 0;
+
+      std::string m_Data;
+    };
+
+    struct BoardRenderContext : public RenderContext
+    {
+      const nntpchan::model::BoardPage & m_Page;
+
+      BoardRenderContext(const nntpchan::model::BoardPage & page) : m_Page(page) {};
+
+      virtual bool Render(const FileHandle_ptr & out) const
+      {
+        *out << m_Data;
+        return false;
+      }
+    };
+
+    struct ThreadRenderContext : public RenderContext
+    {
+      const nntpchan::model::Thread & m_Thread;
+
+      ThreadRenderContext(const nntpchan::model::Thread & thread) : m_Thread(thread) {};
+
+      virtual bool Render(const FileHandle_ptr & out) const 
+      {
+        *out << m_Data;
+        return false;
+      }
+
+    };
+
+    bool WriteBoardPage(const nntpchan::model::BoardPage & page, const FileHandle_ptr & out)
+    {
+      BoardRenderContext ctx(page);
+      if(ctx.Load("board.html"))
+      {
+        return ctx.Render(out);
+      }
+      return false;
+    }
+
+    bool WriteThreadPage(const nntpchan::model::Thread & thread, const FileHandle_ptr & out)
+    {
+      ThreadRenderContext ctx(thread);
+      if(ctx.Load("thread.html"))
+      { 
+        return ctx.Render(out);
+      }
+      return false;
+    }
+  };
+
+TemplateEngine *CreateTemplateEngine(const std::string &dialect)
+{
+  auto d = ToLower(dialect);
+  if (d == "std")
+    return new StdTemplateEngine;
+  else
+    return nullptr;
+}
+}

contrib/backends/nntpchan-daemon/nntpchan.ini

@@ -0,0 +1,7 @@
+[nntp]
+instance_name=nntp.server.tld
+bind=[::]:1199
+authdb=auth.txt
+
+[articles]
+store_path=./storage/

contrib/backends/nntpchan-daemon/test.cpp

@@ -0,0 +1,14 @@
+#include <cassert>
+#include <iostream>
+#include <nntpchan/exec_frontend.hpp>
+#include <nntpchan/sanitize.hpp>
+
+int main(int, char *[], char * argenv[])
+{
+  nntpchan::Frontend_ptr f(new nntpchan::ExecFrontend("./contrib/nntpchan.sh", argenv));
+  assert(f->AcceptsMessage("<test@server>"));
+  assert(f->AcceptsNewsgroup("overchan.test"));
+  assert(nntpchan::IsValidMessageID("<test@test>"));
+  assert(!nntpchan::IsValidMessageID("asd"));
+  std::cout << "all good" << std::endl;
+}

contrib/backends/nntpchan-daemon/tools/authtool.cpp

@@ -0,0 +1,100 @@
+#include <nntpchan/base64.hpp>
+#include <nntpchan/crypto.hpp>
+
+#include <cassert>
+#include <cstring>
+#include <iostream>
+#include <sodium.h>
+#include <string>
+
+static void print_help(const std::string &exename)
+{
+  std::cout << "usage: " << exename << " [help|gen|check]" << std::endl;
+}
+
+static void gen_passwd(const std::string &username, const std::string &passwd)
+{
+  std::array<uint8_t, 8> random;
+  randombytes_buf(random.data(), random.size());
+  std::string salt = nntpchan::B64Encode(random.data(), random.size());
+  std::string cred = passwd + salt;
+  nntpchan::SHA512Digest d;
+  nntpchan::SHA512((const uint8_t *)cred.c_str(), cred.size(), d);
+  std::string hash = nntpchan::B64Encode(d.data(), d.size());
+  std::cout << username << ":" << hash << ":" << salt << std::endl;
+}
+
+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);
+  idx = part.find(":");
+  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;
+  nntpchan::SHA512Digest d;
+  std::string l = passwd + salt;
+  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[])
+{
+  assert(sodium_init() == 0);
+  if (argc == 1)
+  {
+    print_help(argv[0]);
+    return 0;
+  }
+  std::string cmd(argv[1]);
+  if (cmd == "help")
+  {
+    print_help(argv[0]);
+    return 0;
+  }
+  if (cmd == "gen")
+  {
+    if (argc == 4)
+    {
+      gen_passwd(argv[2], argv[3]);
+      return 0;
+    }
+    else
+    {
+      std::cout << "usage: " << argv[0] << " gen username password" << std::endl;
+      return 0;
+    }
+  }
+  if (cmd == "check")
+  {
+    std::string cred;
+    std::cout << "credential: ";
+    if (!std::getline(std::cin, cred))
+    {
+      std::cout << "read error" << std::endl;
+      return 1;
+    }
+    std::string passwd;
+    std::cout << "password: ";
+    if (!std::getline(std::cin, passwd))
+    {
+      std::cout << "read error" << std::endl;
+      return 1;
+    }
+    if (check_cred(cred, passwd))
+    {
+      std::cout << "okay" << std::endl;
+      return 0;
+    }
+    std::cout << "bad login" << std::endl;
+    return 1;
+  }
+  print_help(argv[0]);
+  return 1;
+}

contrib/backends/nntpchan-daemon/tools/testtool.cpp

@@ -0,0 +1,12 @@
+#include <cassert>
+#include <iostream>
+#include <nntpchan/exec_frontend.hpp>
+#include <nntpchan/sanitize.hpp>
+
+int main(int, char *[], char * argenv[])
+{
+  nntpchan::Frontend_ptr f(new nntpchan::ExecFrontend("./contrib/nntpchan.sh", argenv));
+  assert(nntpchan::IsValidMessageID("<a28a71493831188@web.oniichan.onion>"));
+  assert(f->AcceptsNewsgroup("overchan.test"));
+  std::cout << "all good" << std::endl;
+}

contrib/backends/nntpchand/.dir-locals.el

@@ -0,0 +1,8 @@
+;; thanks stack overflow
+;; https://stackoverflow.com/questions/4012321/how-can-i-access-the-path-to-the-current-directory-in-an-emacs-directory-variabl
+((nil . ((eval . (set (make-local-variable 'my-project-path)
+                      (file-name-directory
+                       (let ((d (dir-locals-find-file ".")))
+                         (if (stringp d) d (car d))))))
+         (eval . (setenv "GOPATH" my-project-path))
+         (eval . (message "Project directory set to `%s'." my-project-path)))))

contrib/backends/nntpchand/.gitignore

@@ -0,0 +1 @@
+nntpchand

contrib/backends/nntpchand/Makefile

@@ -0,0 +1,14 @@
+REPO=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
+
+all: clean build
+
+build: nntpchand
+
+nntpchand:
+	GOROOT=$(GOROOT) GOPATH=$(REPO) go build -v
+
+test:
+	GOROOT=$(GOROOT) GOPATH=$(REPO) go test ./...
+
+clean:
+	GOPATH=$(REPO) go clean -v

contrib/backends/nntpchand/main.go

@@ -0,0 +1,9 @@
+package main
+
+import (
+	"nntpchan/cmd/nntpchan"
+)
+
+func main() {
+	nntpchan.Main()
+}

contrib/backends/nntpchand/src/nntpchan/cmd/nntpchan/main.go

@@ -0,0 +1,175 @@
+package nntpchan
+
+import (
+	log "github.com/Sirupsen/logrus"
+	"net"
+	_ "net/http/pprof"
+	"nntpchan/lib/config"
+	"nntpchan/lib/database"
+	"nntpchan/lib/frontend"
+	"nntpchan/lib/nntp"
+	"nntpchan/lib/store"
+	"nntpchan/lib/webhooks"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
+type runStatus struct {
+	nntpListener net.Listener
+	run          bool
+	done         chan error
+}
+
+func (st *runStatus) Stop() {
+	st.run = false
+	if st.nntpListener != nil {
+		st.nntpListener.Close()
+	}
+	st.nntpListener = nil
+	log.Info("stopping daemon process")
+}
+
+func Main() {
+	st := &runStatus{
+		run:  true,
+		done: make(chan error),
+	}
+	log.Info("starting up nntpchan...")
+	cfgFname := "nntpchan.json"
+	conf, err := config.Ensure(cfgFname)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if conf.Log == "debug" {
+		log.SetLevel(log.DebugLevel)
+	}
+
+	sconfig := conf.Store
+
+	if sconfig == nil {
+		log.Fatal("no article storage configured")
+	}
+
+	nconfig := conf.NNTP
+
+	if nconfig == nil {
+		log.Fatal("no nntp server configured")
+	}
+
+	dconfig := conf.Database
+
+	if dconfig == nil {
+		log.Fatal("no database configured")
+	}
+
+	// create nntp server
+	nserv := nntp.NewServer()
+	nserv.Config = nconfig
+	nserv.Feeds = conf.Feeds
+
+	if nconfig.LoginsFile != "" {
+		nserv.Auth = nntp.FlatfileAuth(nconfig.LoginsFile)
+	}
+
+	// create article storage
+	nserv.Storage, err = store.NewFilesytemStorage(sconfig.Path, true)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if conf.WebHooks != nil && len(conf.WebHooks) > 0 {
+		// put webhooks into nntp server event hooks
+		nserv.Hooks = webhooks.NewWebhooks(conf.WebHooks, nserv.Storage)
+	}
+
+	if conf.NNTPHooks != nil && len(conf.NNTPHooks) > 0 {
+		var hooks nntp.MulitHook
+		if nserv.Hooks != nil {
+			hooks = append(hooks, nserv.Hooks)
+		}
+		for _, h := range conf.NNTPHooks {
+			hooks = append(hooks, nntp.NewHook(h))
+		}
+		nserv.Hooks = hooks
+	}
+	var frontends []frontend.Frontend
+	var db database.Database
+	for _, fconf := range conf.Frontends {
+		var f frontend.Frontend
+		f, err = frontend.NewHTTPFrontend(&fconf, db, nserv.Storage)
+		if err == nil {
+			log.Infof("serving frontend %s", f.Name())
+			go f.Serve()
+			frontends = append(frontends, f)
+		} else {
+			log.Fatalf("failed to set up frontend %s: %s", fconf.Name(), err.Error())
+		}
+	}
+
+	// start persisting feeds
+	go nserv.PersistFeeds()
+
+	// handle signals
+	sigchnl := make(chan os.Signal, 1)
+	signal.Notify(sigchnl, syscall.SIGHUP, os.Interrupt)
+	go func() {
+		for {
+			s := <-sigchnl
+			if s == syscall.SIGHUP {
+				// handle SIGHUP
+				conf, err := config.Ensure(cfgFname)
+				if err == nil {
+					log.Infof("reloading config: %s", cfgFname)
+					nserv.ReloadServer(conf.NNTP)
+					nserv.ReloadFeeds(conf.Feeds)
+					nserv.ReloadStorage(conf.Store)
+					for idx := range frontends {
+						f := frontends[idx]
+						for i := range conf.Frontends {
+							c := conf.Frontends[i]
+							if c.Name() == f.Name() {
+								// TODO: inject storage config?
+								f.Reload(&c)
+							}
+						}
+					}
+				} else {
+					log.Errorf("failed to reload config: %s", err)
+				}
+			} else if s == os.Interrupt {
+				// handle interrupted, clean close
+				st.Stop()
+				return
+			}
+		}
+	}()
+	go func() {
+		var err error
+		for st.run {
+			var nl net.Listener
+			naddr := conf.NNTP.Bind
+			log.Infof("Bind nntp server to %s", naddr)
+			nl, err = net.Listen("tcp", naddr)
+			if err == nil {
+				st.nntpListener = nl
+				err = nserv.Serve(nl)
+				if err != nil {
+					nl.Close()
+					log.Errorf("nntpserver.serve() %s", err.Error())
+				}
+			} else {
+				log.Errorf("nntp server net.Listen failed: %s", err.Error())
+			}
+			time.Sleep(time.Second)
+		}
+		st.done <- err
+	}()
+	e := <-st.done
+	if e != nil {
+		log.Fatal(e)
+	}
+	log.Info("ended")
+}

contrib/backends/nntpchand/src/nntpchan/cmd/nntpserver/main.go

@@ -0,0 +1,42 @@
+package main
+
+// simple nntp server
+
+import (
+	log "github.com/Sirupsen/logrus"
+	"net"
+	"nntpchan/lib/config"
+	"nntpchan/lib/nntp"
+	"nntpchan/lib/store"
+)
+
+func main() {
+
+	log.Info("starting NNTP server...")
+	conf, err := config.Ensure("settings.json")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if conf.Log == "debug" {
+		log.SetLevel(log.DebugLevel)
+	}
+
+	serv := &nntp.Server{
+		Config: conf.NNTP,
+		Feeds:  conf.Feeds,
+	}
+	serv.Storage, err = store.NewFilesytemStorage(conf.Store.Path, false)
+	if err != nil {
+		log.Fatal(err)
+	}
+	l, err := net.Listen("tcp", conf.NNTP.Bind)
+	if err != nil {
+		log.Fatal(err)
+	}
+	log.Info("listening on ", l.Addr())
+	err = serv.Serve(l)
+	if err != nil {
+		log.Fatal(err)
+	}
+}

contrib/backends/nntpchand/src/nntpchan/lib/admin/doc.go

@@ -0,0 +1,4 @@
+//
+// server admin panel
+//
+package admin

contrib/backends/nntpchand/src/nntpchan/lib/admin/server.go

@@ -0,0 +1,16 @@
+package admin
+
+import (
+	"net/http"
+)
+
+type Server struct {
+}
+
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+
+}
+
+func NewServer() *Server {
+	return &Server{}
+}

contrib/backends/nntpchand/src/nntpchan/lib/api/api.go

@@ -0,0 +1,10 @@
+package api
+
+import (
+	"nntpchan/lib/model"
+)
+
+// json api
+type API interface {
+	MakePost(p model.Post)
+}

contrib/backends/nntpchand/src/nntpchan/lib/api/doc.go

@@ -0,0 +1,2 @@
+// json api
+package api

contrib/backends/nntpchand/src/nntpchan/lib/api/server.go

@@ -0,0 +1,20 @@
+package api
+
+import (
+	"github.com/gorilla/mux"
+	"net/http"
+)
+
+// api server
+type Server struct {
+}
+
+func (s *Server) HandlePing(w http.ResponseWriter, r *http.Request) {
+
+}
+
+// inject api routes
+func (s *Server) SetupRoutes(r *mux.Router) {
+	// setup api pinger
+	r.Path("/ping").HandlerFunc(s.HandlePing)
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/article.go

@@ -0,0 +1,73 @@
+package config
+
+import "regexp"
+
+// configration for local article policies
+type ArticleConfig struct {
+	// explicitly allow these newsgroups (regexp)
+	AllowGroups []string `json:"whitelist"`
+	// explicitly disallow these newsgroups (regexp)
+	DisallowGroups []string `json:"blacklist"`
+	// only allow explicitly allowed groups
+	ForceWhitelist bool `json:"force-whitelist"`
+	// allow anonymous posts?
+	AllowAnon bool `json:"anon"`
+	// allow attachments?
+	AllowAttachments bool `json:"attachments"`
+	// allow anonymous attachments?
+	AllowAnonAttachments bool `json:"anon-attachments"`
+}
+
+func (c *ArticleConfig) AllowGroup(group string) bool {
+
+	for _, g := range c.DisallowGroups {
+		r := regexp.MustCompile(g)
+		if r.MatchString(group) && c.ForceWhitelist {
+			// disallowed
+			return false
+		}
+	}
+
+	// check allowed groups first
+	for _, g := range c.AllowGroups {
+		r := regexp.MustCompile(g)
+		if r.MatchString(g) {
+			return true
+		}
+	}
+
+	return !c.ForceWhitelist
+}
+
+// allow an article?
+func (c *ArticleConfig) Allow(msgid, group string, anon, attachment bool) bool {
+
+	// check attachment policy
+	if c.AllowGroup(group) {
+		allow := true
+		// no anon ?
+		if anon && !c.AllowAnon {
+			allow = false
+		}
+		// no attachments ?
+		if allow && attachment && !c.AllowAttachments {
+			allow = false
+		}
+		// no anon attachments ?
+		if allow && attachment && anon && !c.AllowAnonAttachments {
+			allow = false
+		}
+		return allow
+	} else {
+		return false
+	}
+}
+
+var DefaultArticlePolicy = ArticleConfig{
+	AllowGroups:          []string{"ctl", "overchan.test"},
+	DisallowGroups:       []string{"overchan.cp"},
+	ForceWhitelist:       false,
+	AllowAnon:            true,
+	AllowAttachments:     true,
+	AllowAnonAttachments: false,
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/cache.go

@@ -0,0 +1,13 @@
+package config
+
+// caching interface configuration
+type CacheConfig struct {
+	// backend cache driver name
+	Backend string `json:"backend"`
+	// address for cache
+	Addr string `json:"addr"`
+	// username for login
+	User string `json:"user"`
+	// password for login
+	Password string `json:"password"`
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/config.go

@@ -0,0 +1,87 @@
+package config
+
+import (
+	"bytes"
+	"encoding/json"
+	"io/ioutil"
+	"os"
+)
+
+// main configuration
+type Config struct {
+	// nntp server configuration
+	NNTP *NNTPServerConfig `json:"nntp"`
+	// log level
+	Log string `json:"log"`
+	// article storage config
+	Store *StoreConfig `json:"storage"`
+	// web hooks to call
+	WebHooks []*WebhookConfig `json:"webhooks"`
+	// external scripts to call
+	NNTPHooks []*NNTPHookConfig `json:"nntphooks"`
+	// database backend configuration
+	Database *DatabaseConfig `json:"db"`
+	// list of feeds to add on runtime
+	Feeds []*FeedConfig `json:"feeds"`
+	// frontend config
+	Frontends []FrontendConfig `json:"frontends"`
+	// unexported fields ...
+
+	// absolute filepath to configuration
+	fpath string
+}
+
+// default configuration
+var DefaultConfig = Config{
+	Store:     &DefaultStoreConfig,
+	NNTP:      &DefaultNNTPConfig,
+	Database:  &DefaultDatabaseConfig,
+	WebHooks:  []*WebhookConfig{DefaultWebHookConfig},
+	NNTPHooks: []*NNTPHookConfig{DefaultNNTPHookConfig},
+	Feeds:     DefaultFeeds,
+	Frontends: []FrontendConfig{DefaultFrontendConfig},
+	Log:       "debug",
+}
+
+// reload configuration
+func (c *Config) Reload() (err error) {
+	var b []byte
+	b, err = ioutil.ReadFile(c.fpath)
+	if err == nil {
+		err = json.Unmarshal(b, c)
+	}
+	return
+}
+
+// ensure that a config file exists
+// creates one if it does not exist
+func Ensure(fname string) (cfg *Config, err error) {
+	_, err = os.Stat(fname)
+	if os.IsNotExist(err) {
+		err = nil
+		var d []byte
+		d, err = json.Marshal(&DefaultConfig)
+		if err == nil {
+			b := new(bytes.Buffer)
+			err = json.Indent(b, d, "", "  ")
+			if err == nil {
+				err = ioutil.WriteFile(fname, b.Bytes(), 0600)
+			}
+		}
+	}
+	if err == nil {
+		cfg, err = Load(fname)
+	}
+	return
+}
+
+// load configuration file
+func Load(fname string) (cfg *Config, err error) {
+	cfg = new(Config)
+	cfg.fpath = fname
+	err = cfg.Reload()
+	if err != nil {
+		cfg = nil
+	}
+	return
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/database.go

@@ -0,0 +1,18 @@
+package config
+
+type DatabaseConfig struct {
+	// url or address for database connector
+	Addr string `json:"addr"`
+	// password to use
+	Password string `json:"password"`
+	// username to use
+	Username string `json:"username"`
+	// type of database to use
+	Type string `json:"type"`
+}
+
+var DefaultDatabaseConfig = DatabaseConfig{
+	Type:     "postgres",
+	Addr:     "/var/run/postgresql",
+	Password: "",
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/doc.go

@@ -0,0 +1,4 @@
+//
+// package for parsing config files
+//
+package config

contrib/backends/nntpchand/src/nntpchan/lib/config/feed.go

@@ -0,0 +1,33 @@
+package config
+
+// configuration for 1 nntp feed
+type FeedConfig struct {
+	// feed's policy, filters articles
+	Policy *ArticleConfig `json:"policy"`
+	// remote server's address
+	Addr string `json:"addr"`
+	// proxy server config
+	Proxy *ProxyConfig `json:"proxy"`
+	// nntp username to log in with
+	Username string `json:"username"`
+	// nntp password to use when logging in
+	Password string `json:"password"`
+	// do we want to use tls?
+	TLS bool `json:"tls"`
+	// the name of this feed
+	Name string `json:"name"`
+	// how often to pull articles from the server in minutes
+	// 0 for never
+	PullInterval int `json:"pull"`
+}
+
+var DuummyFeed = FeedConfig{
+	Policy: &DefaultArticlePolicy,
+	Addr:   "nntp.dummy.tld:1119",
+	Proxy:  &DefaultTorProxy,
+	Name:   "dummy",
+}
+
+var DefaultFeeds = []*FeedConfig{
+	&DuummyFeed,
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/frontend.go

@@ -0,0 +1,31 @@
+package config
+
+import (
+	"fmt"
+)
+
+type FrontendConfig struct {
+	// bind to address
+	BindAddr string `json:"bind"`
+	// frontend cache
+	Cache *CacheConfig `json:"cache"`
+	// frontend ssl settings
+	SSL *SSLSettings `json:"ssl"`
+	// static files directory
+	Static string `json:"static_dir"`
+	// http middleware configuration
+	Middleware *MiddlewareConfig `json:"middleware"`
+	// storage config
+	Storage *StoreConfig `json:"-"`
+}
+
+func (cfg *FrontendConfig) Name() string {
+	return fmt.Sprintf("frontend-%s", cfg.BindAddr)
+}
+
+// default Frontend Configuration
+var DefaultFrontendConfig = FrontendConfig{
+	BindAddr:   "127.0.0.1:18888",
+	Static:     "./files/static/",
+	Middleware: &DefaultMiddlewareConfig,
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/hook.go

@@ -0,0 +1,15 @@
+package config
+
+// config for external callback for nntp articles
+type NNTPHookConfig struct {
+	// name of hook
+	Name string `json:"name"`
+	// executable script path to be called with arguments: /path/to/article
+	Exec string `json:"exec"`
+}
+
+// default dummy hook
+var DefaultNNTPHookConfig = &NNTPHookConfig{
+	Name: "dummy",
+	Exec: "/bin/true",
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/middleware.go

@@ -0,0 +1,17 @@
+package config
+
+// configuration for http middleware
+type MiddlewareConfig struct {
+	// middleware type, currently just 1 is available: overchan
+	Type string `json:"type"`
+	// directory for our html templates
+	Templates string `json:"templates_dir"`
+	// directory for static files
+	StaticDir string `json:"static_dir"`
+}
+
+var DefaultMiddlewareConfig = MiddlewareConfig{
+	Type:      "overchan",
+	Templates: "./files/templates/overchan/",
+	StaticDir: "./files/",
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/nntp.go

@@ -0,0 +1,24 @@
+package config
+
+type NNTPServerConfig struct {
+	// address to bind to
+	Bind string `json:"bind"`
+	// name of the nntp server
+	Name string `json:"name"`
+	// default inbound article policy
+	Article *ArticleConfig `json:"policy"`
+	// do we allow anonymous NNTP sync?
+	AnonNNTP bool `json:"anon-nntp"`
+	// ssl settings for nntp
+	SSL *SSLSettings
+	// file with login credentials
+	LoginsFile string `json:"authfile"`
+}
+
+var DefaultNNTPConfig = NNTPServerConfig{
+	AnonNNTP:   false,
+	Bind:       "0.0.0.0:1119",
+	Name:       "nntp.server.tld",
+	Article:    &DefaultArticlePolicy,
+	LoginsFile: "",
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/proxy.go

@@ -0,0 +1,13 @@
+package config
+
+// proxy configuration
+type ProxyConfig struct {
+	Type string `json:"type"`
+	Addr string `json:"addr"`
+}
+
+// default tor proxy
+var DefaultTorProxy = ProxyConfig{
+	Type: "socks",
+	Addr: "127.0.0.1:9050",
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/ssl.go

@@ -0,0 +1,11 @@
+package config
+
+// settings for setting up ssl
+type SSLSettings struct {
+	// path to ssl private key
+	SSLKeyFile string `json:"key"`
+	// path to ssl certificate signed by CA
+	SSLCertFile string `json:"cert"`
+	// domain name to use for ssl
+	DomainName string `json:"fqdn"`
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/store.go

@@ -0,0 +1,10 @@
+package config
+
+type StoreConfig struct {
+	// path to article directory
+	Path string `json:"path"`
+}
+
+var DefaultStoreConfig = StoreConfig{
+	Path: "storage",
+}

contrib/backends/nntpchand/src/nntpchan/lib/config/webhooks.go

@@ -0,0 +1,17 @@
+package config
+
+// configuration for a single web hook
+type WebhookConfig struct {
+	// user provided name for this hook
+	Name string `json:"name"`
+	// callback URL for webhook
+	URL string `json:"url"`
+	// dialect to use when calling webhook
+	Dialect string `json:"dialect"`
+}
+
+var DefaultWebHookConfig = &WebhookConfig{
+	Name:    "vichan",
+	Dialect: "vichan",
+	URL:     "http://localhost/webhook.php",
+}

contrib/backends/nntpchand/src/nntpchan/lib/crypto/doc.go

@@ -0,0 +1,5 @@
+//
+// nntpchan crypto package
+// wraps all external crypro libs
+//
+package crypto

contrib/backends/nntpchand/src/nntpchan/lib/crypto/hash.go

@@ -0,0 +1,8 @@
+package crypto
+
+import (
+	"github.com/dchest/blake256"
+)
+
+// common hash function is blake2
+var Hash = blake256.New

contrib/backends/nntpchand/src/nntpchan/lib/crypto/nacl.go

@@ -0,0 +1,77 @@
+package crypto
+
+import (
+	"crypto/sha512"
+	"hash"
+	"nntpchan/lib/crypto/nacl"
+)
+
+type fuckyNacl struct {
+	k    []byte
+	hash hash.Hash
+}
+
+func (fucky *fuckyNacl) Write(d []byte) (int, error) {
+	return fucky.hash.Write(d)
+}
+
+func (fucky *fuckyNacl) Sign() (s Signature) {
+	h := fucky.hash.Sum(nil)
+	if h == nil {
+		panic("fuck.hash.Sum == nil")
+	}
+
+	_, sec := nacl.SeedToKeyPair(fucky.k)
+	sig := nacl.CryptoSignFucky(h, sec)
+	if sig == nil {
+		panic("fucky signer's call to nacl.CryptoSignFucky returned nil")
+	}
+	s = Signature(sig)
+	fucky.resetState()
+	return
+}
+
+// reset inner state so we can reuse this fuckyNacl for another operation
+func (fucky *fuckyNacl) resetState() {
+	fucky.hash = sha512.New()
+}
+
+func (fucky *fuckyNacl) Verify(sig Signature) (valid bool) {
+	h := fucky.hash.Sum(nil)
+	if h == nil {
+		panic("fucky.hash.Sum == nil")
+	}
+	valid = nacl.CryptoVerifyFucky(h, sig, fucky.k)
+	fucky.resetState()
+	return
+}
+
+func createFucky(k []byte) *fuckyNacl {
+	return &fuckyNacl{
+		k:    k,
+		hash: sha512.New(),
+	}
+}
+
+// create a standard signer given a secret key
+func CreateSigner(sk []byte) Signer {
+	return createFucky(sk)
+}
+
+// create a standard verifier given a public key
+func CreateVerifier(pk []byte) Verifer {
+	return createFucky(pk)
+}
+
+// get the public component given the secret key
+func ToPublic(sk []byte) (pk []byte) {
+	pk, _ = nacl.SeedToKeyPair(sk)
+	return
+}
+
+// create a standard keypair
+func GenKeypair() (pk, sk []byte) {
+	sk = RandBytes(32)
+	pk, _ = nacl.SeedToKeyPair(sk)
+	return
+}

contrib/backends/nntpchand/src/nntpchan/lib/crypto/nacl/cryptography.go

@@ -0,0 +1,44 @@
+package nacl
+
+import (
+	"crypto/sha512"
+	"edwards25519"
+	"golang.org/x/crypto/ed25519"
+)
+
+func CryptoVerifyFucky(h, sig, pk []byte) bool {
+	pub := make(ed25519.PublicKey, ed25519.PublicKeySize)
+	copy(pub, pk)
+	return ed25519.Verify(pub, h, sig)
+}
+
+func CryptoSignFucky(hash, sk []byte) []byte {
+	sec := make(ed25519.PrivateKey, ed25519.PrivateKeySize)
+	copy(sec, sk)
+	return ed25519.Sign(sec, hash)
+}
+
+func SeedToKeyPair(seed []byte) (pk, sk []byte) {
+
+	h := sha512.Sum512(seed[0:32])
+	sk = h[:]
+	sk[0] &= 248
+	sk[31] &= 63
+	sk[31] |= 64
+	// scalarmult magick shit
+	pk = scalarBaseMult(sk[0:32])
+	copy(sk[0:32], seed[0:32])
+	copy(sk[32:64], pk[0:32])
+	return
+}
+
+func scalarBaseMult(sk []byte) (pk []byte) {
+	var skey [32]byte
+	var pkey [32]byte
+	copy(skey[:], sk[0:32])
+	var h edwards25519.ExtendedGroupElement
+	edwards25519.GeScalarMultBase(&h, &skey)
+	h.ToBytes(&pkey)
+	pk = pkey[:]
+	return
+}

contrib/backends/nntpchand/src/nntpchan/lib/crypto/nacl_test.go

@@ -0,0 +1,34 @@
+package crypto
+
+import (
+	"bytes"
+	"crypto/rand"
+	"io"
+	"testing"
+)
+
+func TestNaclToPublic(t *testing.T) {
+	pk, sk := GenKeypair()
+	t_pk := ToPublic(sk)
+	if !bytes.Equal(pk, t_pk) {
+		t.Logf("%q != %q", pk, t_pk)
+		t.Fail()
+	}
+}
+
+func TestNaclSignVerify(t *testing.T) {
+	var msg [1024]byte
+	pk, sk := GenKeypair()
+	io.ReadFull(rand.Reader, msg[:])
+
+	signer := CreateSigner(sk)
+	signer.Write(msg[:])
+	sig := signer.Sign()
+
+	verifier := CreateVerifier(pk)
+	verifier.Write(msg[:])
+	if !verifier.Verify(sig) {
+		t.Logf("%q is invalid signature and is %dB long", sig, len(sig))
+		t.Fail()
+	}
+}

contrib/backends/nntpchand/src/nntpchan/lib/crypto/rand.go

@@ -0,0 +1,13 @@
+package crypto
+
+import (
+	"crypto/rand"
+	"io"
+)
+
+// generate random bytes
+func RandBytes(n int) []byte {
+	b := make([]byte, n)
+	io.ReadFull(rand.Reader, b)
+	return b
+}

contrib/backends/nntpchand/src/nntpchan/lib/crypto/sig.go

@@ -0,0 +1,25 @@
+package crypto
+
+import "io"
+
+// a detached signature
+type Signature []byte
+
+type SigEncoder interface {
+	// encode a signature to an io.Writer
+	// return error if one occurrened while writing out signature
+	Encode(sig Signature, w io.Writer) error
+	// encode a signature to a string
+	EncodeString(sig Signature) string
+}
+
+// a decoder of signatures
+type SigDecoder interface {
+	// decode signature from io.Reader
+	// reads all data until io.EOF
+	// returns singaure or error if an error occured while reading
+	Decode(r io.Reader) (Signature, error)
+	// decode a signature from string
+	// returns signature or error if an error ocurred while decoding
+	DecodeString(str string) (Signature, error)
+}

contrib/backends/nntpchand/src/nntpchan/lib/crypto/sign.go

@@ -0,0 +1,14 @@
+package crypto
+
+import "io"
+
+//
+// provides generic signing interface for producing detached signatures
+// call Write() to feed data to be signed, call Sign() to generate
+// a detached signature
+//
+type Signer interface {
+	io.Writer
+	// generate detached Signature from previously fed body via Write()
+	Sign() Signature
+}

contrib/backends/nntpchand/src/nntpchan/lib/crypto/verify.go

@@ -0,0 +1,14 @@
+package crypto
+
+import "io"
+
+// provides generic signature
+// call Write() to feed in message body
+// once the entire body has been fed in via Write() call Verify() with detached
+// signature to verify the detached signature against the previously fed body
+type Verifer interface {
+	io.Writer
+	// verify detached signature from body previously fed via Write()
+	// return true if the detached signature is valid given the body
+	Verify(sig Signature) bool
+}

contrib/backends/nntpchand/src/nntpchan/lib/database/database.go

@@ -0,0 +1,29 @@
+package database
+
+import (
+	"errors"
+	"nntpchan/lib/config"
+	"nntpchan/lib/model"
+	"strings"
+)
+
+//
+type Database interface {
+	ThreadByMessageID(msgid string) (*model.Thread, error)
+	ThreadByHash(hash string) (*model.Thread, error)
+	MessageIDByHash(hash string) (string, error)
+	BoardPage(newsgroup string, pageno, perpage int) (*model.BoardPage, error)
+	StorePost(post model.Post) error
+	Init() error
+}
+
+// get new database connector from configuration
+func NewDBFromConfig(c *config.DatabaseConfig) (db Database, err error) {
+	dbtype := strings.ToLower(c.Type)
+	if dbtype == "postgres" {
+		db, err = createPostgresDatabase(c.Addr, c.Username, c.Password)
+	} else {
+		err = errors.New("no such database driver: " + c.Type)
+	}
+	return
+}

contrib/backends/nntpchand/src/nntpchan/lib/database/doc.go

@@ -0,0 +1,4 @@
+//
+// database driver
+//
+package database

contrib/backends/nntpchand/src/nntpchan/lib/database/postgres.go

@@ -0,0 +1,58 @@
+package database
+
+import (
+	"database/sql"
+	_ "github.com/lib/pq"
+	"nntpchan/lib/model"
+)
+
+type PostgresDB struct {
+	conn *sql.DB
+}
+
+func (db *PostgresDB) ThreadByMessageID(msgid string) (thread *model.Thread, err error) {
+
+	return
+}
+
+func (db *PostgresDB) ThreadByHash(hash string) (thread *model.Thread, err error) {
+	return
+}
+
+func (db *PostgresDB) MessageIDByHash(hash string) (msgid string, err error) {
+
+	return
+}
+
+func (db *PostgresDB) BoardPage(newsgroup string, pageno, perpage int) (page *model.BoardPage, err error) {
+
+	return
+}
+
+func (db *PostgresDB) StorePost(post model.Post) (err error) {
+	return
+}
+
+func (db *PostgresDB) Init() (err error) {
+
+	return
+}
+
+func createPostgresDatabase(addr, user, passwd string) (p *PostgresDB, err error) {
+	p = new(PostgresDB)
+	var authstring string
+	if len(addr) > 0 {
+		authstring += " host=" + addr
+	}
+	if len(user) > 0 {
+		authstring += " username=" + user
+	}
+	if len(passwd) > 0 {
+		authstring += " password=" + passwd
+	}
+	p.conn, err = sql.Open("postgres", authstring)
+	if err != nil {
+		p = nil
+	}
+	return
+}