Revise README for installation instructions and formatting

Updated README.md for clarity and formatting improvements.
fix pubkey loading, captcha replies only, admin post styling, krane CSS updates
2026-05-14 05:05:40 +02:00 · 2026-05-11 16:19:45 -04:00 · 2026-05-11 19:43:12 +00:00 · 2026-05-11 03:58:08 +00:00 · 2026-05-10 17:41:15 -04:00 · 2025-10-10 13:51:07 -04:00
1564 changed files with 576060 additions and 1338 deletions
@@ -0,0 +1,5 @@
+
+* be awesome to each other
+* fun is required, don't be a killjoy
+* **vendor everything**
+
@@ -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]
@@ -19,23 +19,24 @@ webroot

 # built binaries
 go
-srndv2
+gopherjs_go
+./srndv2

 # private key
 *.key
-*.txt

 # certificates
 certs


 rebuild.sh
-vendor
 .gx

 # generated js
 contrib/static/nntpchan.js
+contrib/static/js/nntpchan.js
 contrib/static/miner-js.js

+
 #docs trash
 doc/.trash
@@ -1,34 +0,0 @@
-#
-# .gxignore for nntpchan repo
-#
-
-# emacs temp files
-*~
-\#*
-.\#*
-
-# srnd config files
-srnd.ini
-feeds.ini
-
-# default article store directory
-articles/
-
-# generated files
-webroot/
-
-# built binaries
-go/
-srndv2
-nntpchan
-
-# private key
-*.key
-*.txt
-
-# certificates
-certs/
-
-rebuild.sh
-
-.git
@@ -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.
@@ -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
@@ -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)
@@ -1,39 +1,233 @@
-NNTPChan
-========
+![le ebin logo](nntpchan.png "ebin logo")
+![MIT License](https://img.shields.io/github/license/majestrate/nntpchan.svg)
+![Logo is ebin](https://img.shields.io/badge/logo-ebin-brightgreen.svg)

-**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 protocol) to synchronize content between many different servers. It utilizes cryptographically signed posts to perform optional/opt-in decentralized moderation.
+**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.

-This repository contains resources used by the core daemon which is located on [GitHub](https://github.com/majestrate/srndv2) (for now) along with general documentation, [here](doc/)
+## Getting started — Ubuntu 24.04 installation guide

-##Getting started
+Tested and working on Ubuntu 24.04.

-[This](doc) is a step-by-step guide for getting up-and-running with NNTPChan as well as documentation for developers wwho want to either work on NNTPChan directly or use NNTPChan in their aplications with the API.
+### Step 1: Install dependencies

-##Bugs and issues
+```bash
+sudo apt-get update
+sudo apt-get --no-install-recommends install -y \
+    imagemagick ffmpeg sox build-essential git ca-certificates \
+    postgresql postgresql-client golang
+```

-*PLEASE* report any bugs you find while building, setting-up or using NNTPChan on the [GitHub issue tracker](https://github.com/majestrate/nntpchan/issues) or on the [GitGud issue tracker](https://gitgud.io/uguu/nntpchan/issues) so that the probelms can be resolved or discussed.
+### Step 2: Install Go 1.23+

-##Active NNTPChan nodes
+Ubuntu 24.04 ships Go 1.22 which is too old. Install 1.23+ manually:

-Below is a list of known NNTPChan nodes:
+```bash
+curl -L -o /tmp/go1.23.0.tar.gz https://dl.google.com/go/go1.23.0.linux-amd64.tar.gz
+sudo tar -C /usr/local -xzf /tmp/go1.23.0.tar.gz
+export PATH=/usr/local/go/bin:$PATH
+go version  # should show go1.23.x
+```

-1. [2hu-ch.org](https://2hu-ch.org)
-2. [nsfl.tk](https://nsfl.tk)
-3. [i2p.rocks](https://i2p.rocks/ib/)
+Add to your shell profile to persist:

-##Support
+```bash
+echo 'export PATH=/usr/local/go/bin:$PATH' >> ~/.bashrc
+```

-Need help? Join us on IRC.
+### Step 3: Get the NNTPChan source

-1. [freenode: #nntpchan](https://webchat.freenode.net/?channels=#nntpchan)
-2. [rizon: #nntpchan](https://qchat.rizon.net/?channels=#nntpchan) - Most active
+```bash
+git clone https://github.com/tomoko-dev9/nntpchan
+cd nntpchan
+```

-##Donations
+### Step 4: Build minify

-Like this project? Why not help by funding it?
+The Makefile uses old `go get` syntax. Install minify manually:

-Bitcoin: [15yuMzuueV8y5vPQQ39ZqQVz5Ey98DNrjE](bitcoin://15yuMzuueV8y5vPQQ39ZqQVz5Ey98DNrjE)
+```bash
+GONOSUMDB=* GOPROXY=direct GOPATH=/root/nntpchan/go go install github.com/tdewolff/minify/v2/cmd/minify@latest
+```

-##Acknowledgements
+### Step 5: Fix the Makefile for modern Go

-* [Deavmi](deavmi.carteronline.net/~deavmi) - Making the documentation beautiful.
+```bash
+sed -i 's|GOPATH=$(REPO)|GO111MODULE=off GOPATH=/tmp/srnd-gopath|g' \
+    /root/nntpchan/contrib/backends/srndv2/Makefile
+```
+
+Set up the GOPATH symlink:
+
+```bash
+mkdir -p /tmp/srnd-gopath/src
+ln -s /root/nntpchan/contrib/backends/srndv2/src/srnd /tmp/srnd-gopath/src/srnd
+```
+
+### Step 6: Compile
+
+```bash
+make
+```
+
+If the srndv2 step fails, build it manually:
+
+```bash
+cd /root/nntpchan/contrib/backends/srndv2
+GO111MODULE=off GOPATH=/tmp/srnd-gopath GOROOT=/usr/local/go /usr/local/go/bin/go build -v -o /root/nntpchan/srndv2 .
+```
+
+### Step 7: Build the JavaScript bundle
+
+```bash
+curl -o /tmp/jquery.js https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js
+
+cat /tmp/jquery.js \
+    /root/nntpchan/contrib/js/entry.js \
+    /root/nntpchan/contrib/js/nntpchan/local_storage.js \
+    /root/nntpchan/contrib/js/nntpchan/api.js \
+    /root/nntpchan/contrib/js/nntpchan/banner.js \
+    /root/nntpchan/contrib/js/nntpchan/theme.js \
+    /root/nntpchan/contrib/js/nntpchan/expand-image.js \
+    /root/nntpchan/contrib/js/nntpchan/expand-video.js \
+    /root/nntpchan/contrib/js/nntpchan/hide-post.js \
+    /root/nntpchan/contrib/js/nntpchan/post-reply.js \
+    /root/nntpchan/contrib/js/nntpchan/reply.js \
+    /root/nntpchan/contrib/js/nntpchan/report.js \
+    /root/nntpchan/contrib/js/nntpchan/captcha-reload.js \
+    /root/nntpchan/contrib/js/nntpchan/crypto.js \
+    /root/nntpchan/contrib/js/nntpchan/livechan.js \
+    > /root/nntpchan/contrib/static/nntpchan.js
+```
+
+### Step 8: Set up PostgreSQL
+
+```bash
+sudo -u postgres psql -c "CREATE DATABASE root;"
+sudo -u postgres psql -c "CREATE USER root WITH PASSWORD 'root';"
+sudo -u postgres psql -c "GRANT ALL PRIVILEGES ON DATABASE root TO root;"
+sudo -u postgres psql -d root -c "GRANT ALL ON SCHEMA public TO root;"
+sudo -u postgres psql -d root -c "ALTER SCHEMA public OWNER TO root;"
+```
+
+> **Note:** Default database, user, and password are all `root`. Default port is `5432`.
+
+### Step 9: Initial setup
+
+```bash
+cd /root/nntpchan
+./srndv2 setup
+```
+
+Edit `srnd.ini` as needed. To disable captcha add `rapeme=omgyesplz` under `[frontend]`. To enable captcha only for new threads (not replies), leave it as `rapeme=no`.
+
+### Step 10: Generate admin keypair
+
+```bash
+./srndv2 tool keygen
+```
+
+Save the secret key securely. Add the public key as admin:
+
+```bash
+./srndv2 tool mod add YOUR_PUBLIC_KEY
+```
+
+To post as admin, use your secret key in the name field:
+
+```
+Admin#YOUR_SECRET_KEY
+```
+
+To show admin styling on posts, add this to your theme CSS (e.g. `krane.css`):
+
+```css
+[data-pubkey="YOUR_PUBLIC_KEY"] {
+    background-image: url('/static/admin.png');
+    background-size: 25%;
+    background-repeat: repeat;
+}
+```
+
+### Step 11: Run as a systemd service
+
+```bash
+cat > /etc/systemd/system/nntpchan.service << 'SERVICE'
+[Unit]
+Description=nntpchan srndv2
+After=network.target postgresql.service
+
+[Service]
+Type=simple
+User=root
+WorkingDirectory=/root/nntpchan
+ExecStart=/root/nntpchan/srndv2 run
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=multi-user.target
+SERVICE
+
+systemctl daemon-reload
+systemctl enable nntpchan
+systemctl start nntpchan
+```
+
+The web interface is available at `http://127.0.0.1:18000` by default (configurable in `srnd.ini`).
+
+### Step 12: Set up .onion address (optional)
+
+```bash
+apt-get install -y tor
+cat >> /etc/tor/torrc << 'TOR'
+HiddenServiceDir /var/lib/tor/nntpchan/
+HiddenServicePort 80 127.0.0.1:80
+TOR
+systemctl restart tor
+cat /var/lib/tor/nntpchan/hostname
+```
+
+---
+
+## What was fixed in this fork
+
+- Fixed compilation for modern Go (1.23+)
+- Fixed old-style GOPATH builds in the Makefile
+- Added posts-per-day graph (overcock graph) to front page
+- Added board stats table (Posts this Hour, Posts Today, Total)
+- Fixed date offset bug in posts graph
+- Built and fixed the JavaScript bundle (livechan, banners, post reply, etc.)
+- Captcha only required for new threads, not replies
+- Admin posts highlighted with admin.png via pubkey CSS
+- Fixed pubkey not loading correctly in thread view
+- Fixed PostgreSQL schema permissions for Ubuntu 24.04
+
+---
+
+## Support
+
+[Discord](https://discord.gg)
+
+## Bugs and issues
+
+Please report bugs on the [GitHub issue tracker](https://github.com/tomoko-dev9/nntpchan/issues).
+
+## 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
+
+![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.
@@ -1,6 +1,10 @@
 ## TODO ##

+* imrpove frontend templates
 * extra stylesheets
-* more alternative templates
-* javascript free mod panel
-* liveui 
+* 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)
@@ -1,71 +0,0 @@
-#!/usr/bin/env bash
-root=$(readlink -e $(dirname $0))
-set -e
-if [ "x" == "x$root" ] ; then
-    root=$PWD/${0##*}
-fi
-cd $root
-
-if [ -z "$GOPATH" ]; then
-	export GOPATH=$root/go
-	mkdir -p $GOPATH
-fi
-
-if [ ! -f $GOPATH/bin/minify ]; then
-  echo "set up minifiy"  
-	go get -v github.com/tdewolff/minify/cmd/minify
-fi
-if [ ! -f $GOPATH/bin/gopherjs ]; then
-        echo "set up gopherjs"
-        go get -v -u github.com/gopherjs/gopherjs
-fi
-
-# build cuckoo miner
-echo "Building cuckoo miner"
-go get -v -u github.com/ZiRo-/cuckgo/miner_js
-$GOPATH/bin/gopherjs -m -v build github.com/ZiRo-/cuckgo/miner_js
-mv ./miner_js.js ./contrib/static/miner-js.js
-rm ./miner_js.js.map
-
-outfile=$PWD/contrib/static/nntpchan.js
-
-lint() {
-    if [ "x$(which jslint)" == "x" ] ; then
-        # no jslint
-        true
-    else
-        echo "jslint: $1"
-        jslint --browser $1
-    fi
-}
-
-mini() {
-    echo "minify $1"
-    echo "" >> $2
-    echo "/* local file: $1 */" >> $2
-    $GOPATH/bin/minify --mime=text/javascript >> $2 < $1
-}
-
-# do linting too
-if [ "x$1" == "xlint" ] ; then
-    echo "linting..."
-    for f in ./contrib/js/*.js ; do
-        lint $f
-    done
-fi
-
-echo -e "//For source code and license information please check https://github.com/majestrate/nntpchan \n" > $outfile
-
-if [ -e ./contrib/js/contrib/*.js ] ; then
-    for f in ./contrib/js/contrib/*.js ; do
-        mini $f $outfile
-    done
-fi
-    
-mini ./contrib/js/main.js_ $outfile
-
-# local js
-for f in ./contrib/js/*.js ; do
-  mini $f $outfile
-done
-echo "ok"
@@ -1,92 +0,0 @@
-#!/usr/bin/env bash
-root=$(readlink -e $(dirname $0))
-set -e
-if [ "x" == "x$root" ] ; then
-    root=$PWD/${0##*}
-fi
-cd $root
-
-tags=""
-
-help_text="usage: $0 [--disable-redis]"
-
-# check for help flags first
-for arg in $@ ; do
-    case $arg in
-        -h|--help)
-            echo $help_text
-            exit 0
-            ;;
-    esac
-done
-
-rev="QmPAqM7anxdr1ngPmJz9J9AAxDLinDz2Eh9aAzLF9T7LNa"
-ipfs="no"
-rebuildjs="yes"
-_next=""
-# check for build flags
-for arg in $@ ; do
-    case $arg in
-        "--no-js")
-            rebuildjs="no"
-            ;;
-        "--ipfs")
-            ipfs="yes"
-            ;;
-        "--cuckoo")
-            cuckoo="yes"
-            ;;
-        "--disable-redis")
-            tags="$tags -tags disable_redis"
-            ;;
-        "--revision")
-            _next="rev"
-            ;;
-        "--revision=*")
-            rev=$(echo $arg | cut -d'=' -f2)
-            ;;
-        *)
-            if [ "x$_next" == "xrev" ] ; then
-                rev="$arg"
-            fi
-    esac
-done
-
-if [ "x$rev" == "x" ] ; then
-    echo "revision not specified"
-    exit 1
-fi
-
-cd $root
-if [ "x$rebuildjs" == "xyes" ] ; then
-    echo "rebuilding generated js..."
-    ./build-js.sh
-fi
-unset GOPATH 
-export GOPATH=$PWD/go
-mkdir -p $GOPATH
-
-if [ "x$ipfs" == "xyes" ] ; then
-    if [ ! -e $GOPATH/bin/gx ] ; then
-        echo "obtaining gx"
-        go get -u -v github.com/whyrusleeping/gx
-    fi
-    if [ ! -e $GOPATH/bin/gx-go ] ; then
-        echo "obtaining gx-go"
-        go get -u -v github.com/whyrusleeping/gx-go
-    fi
-    echo "building stable revision, this will take a bit. to speed this part up install and run ipfs locally"
-    mkdir -p $GOPATH/src/gx/ipfs
-    cd $GOPATH/src/gx/ipfs
-    $GOPATH/bin/gx get $rev
-    cd $root
-    go get -d -v 
-    go build -v .
-    mv nntpchan srndv2
-else
-    go get -u -v github.com/majestrate/srndv2  
-    cp $GOPATH/bin/srndv2 $root
-fi
-
-echo -e "Built\n"
-echo "Now configure NNTPChan with ./srndv2 setup"
@@ -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
@@ -0,0 +1,6 @@
+*.o
+*.a
+nntpd
+tools/authtool
+tools/testtool
+.gdb_history
@@ -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)
@@ -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
@@ -0,0 +1,2 @@
+#!/bin/sh
+exit 0
@@ -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
@@ -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;
+  }
+}
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -0,0 +1,4 @@
+#ifndef NNTPCHAN_HTTP_HPP
+#define NNTPCHAN_HTTP_HPP
+
+#endif
@@ -0,0 +1,4 @@
+#ifndef NNTPCHAN_HTTP_CLIENT_HPP
+#define NNTPCHAN_HTTP_CLIENT_HPP
+
+#endif
@@ -0,0 +1,4 @@
+#ifndef NNTPCHAN_HTTP_SERVER_HPP
+#define NNTPCHAN_HTTP_SERVER_HPP
+
+#endif
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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;
+}
+}
@@ -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() {}
+}
@@ -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
@@ -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);
+    }
+};
+}
+}
@@ -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; }
+}
@@ -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;
+}
+}
@@ -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;
+}
+}
@@ -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);
+        }
+    };
+}
+}
@@ -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();
+}
+
+}
@@ -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();
+}
+}
@@ -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;
+}
+}
@@ -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;
+}
+}
@@ -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; }
+}
@@ -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();
+}
+}
@@ -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;
+}
+}
@@ -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();
+}
+}
@@ -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;
+}
+}
@@ -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); }
+}
@@ -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);
+}
+}
@@ -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;
+}
+}
@@ -0,0 +1,7 @@
+[nntp]
+instance_name=nntp.server.tld
+bind=[::]:1199
+authdb=auth.txt
+
+[articles]
+store_path=./storage/
@@ -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;
+}
@@ -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;
+}
@@ -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;
+}
@@ -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)))))
@@ -0,0 +1 @@
+nntpchand
@@ -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
@@ -0,0 +1,9 @@
+package main
+
+import (
+	"nntpchan/cmd/nntpchan"
+)
+
+func main() {
+	nntpchan.Main()
+}
@@ -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")
+}
@@ -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)
+	}
+}
@@ -0,0 +1,4 @@
+//
+// server admin panel
+//
+package admin
@@ -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{}
+}
@@ -0,0 +1,10 @@
+package api
+
+import (
+	"nntpchan/lib/model"
+)
+
+// json api
+type API interface {
+	MakePost(p model.Post)
+}
@@ -0,0 +1,2 @@
+// json api
+package api
@@ -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)
+}
@@ -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,
+}
@@ -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"`
+}
@@ -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
+}
@@ -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: "",
+}
@@ -0,0 +1,4 @@
+//
+// package for parsing config files
+//
+package config
@@ -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,
+}
@@ -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,
+}
@@ -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",
+}
@@ -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/",
+}
@@ -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: "",
+}
@@ -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",
+}
@@ -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"`
+}
@@ -0,0 +1,10 @@
+package config
+
+type StoreConfig struct {
+	// path to article directory
+	Path string `json:"path"`
+}
+
+var DefaultStoreConfig = StoreConfig{
+	Path: "storage",
+}
@@ -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",
+}
@@ -0,0 +1,5 @@
+//
+// nntpchan crypto package
+// wraps all external crypro libs
+//
+package crypto
@@ -0,0 +1,8 @@
+package crypto
+
+import (
+	"github.com/dchest/blake256"
+)
+
+// common hash function is blake2
+var Hash = blake256.New
@@ -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
+}
@@ -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
+}
@@ -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()
+	}
+}
@@ -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
+}
@@ -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)
+}
@@ -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
+}
@@ -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
+}
--- a/Show More
+++ b/Show More