dynamic: Add dynamicpostrenderer

user-input to this function might become possible soon

.gitignore

@@ -3,6 +3,8 @@
 *.out
 *.gch
 *.user
+*.swp
+*.kate-swp
 qswiki
 wikiqs*
 data/*

.gitmodules

@@ -4,6 +4,6 @@
 [submodule "submodules/cpp-httplib"]
 	path = submodules/cpp-httplib
 	url = https://github.com/yhirose/cpp-httplib
-[submodule "submodules/qssb.h"]
-	path = submodules/qssb.h
-	url = https://gitea.quitesimple.org/crtxcr/qssb.h.git
+[submodule "submodules/exile.h"]
+	path = submodules/exile.h
+	url = https://gitea.quitesimple.org/crtxcr/exile.h.git

Makefile

@@ -1,12 +1,14 @@
-
 CPPSTD=c++20
-CXXFLAGS=-std=$(CPPSTD) -O0 -g -no-pie -pipe -MMD -Wall -Wextra
-RELEASE_CXXFLAGS=-std=$(CPPSTD) -O3 -pipe -MMD -Wall -Wextra
-LDFLAGS=-lsqlite3 -lpthread -lcrypto -lstdc++fs
-INCLUDEFLAGS=-I submodules/sqlitemoderncpp/hdr -I submodules/cpp-httplib -I submodules/qssb.h
 
-CXX=g++
+#CFIFLAGS=-fsanitize=cfi -fvisibility=hidden -fsanitize=cfi -flto
+#Does not work reliably atm
+CFIFLAGS=
 
+CXXFLAGS=-std=$(CPPSTD) -O2 -g -no-pie -pipe -MMD -Wall -Wextra -DGLIBCXX_ASSERTIONS -D_LIBCPP_ENABLE_ASSERTIONS=1 $(CFIFLAGS)
+RELEASE_CXXFLAGS=-std=$(CPPSTD) -O3 -pipe -MMD -Wall -Wextra -DGLIBCXX_ASSERTIONS -D_LIBCPP_ENABLE_ASSERTIONS=1 $(CFIFLAGS)
+
+LDFLAGS=-lsqlite3 -lpthread -lcrypto -lstdc++fs $(CFIFLAGS)
+INCLUDEFLAGS=-I submodules/sqlitemoderncpp/hdr -I submodules/cpp-httplib -I submodules/exile.h
 
 SOURCES=$(wildcard *.cpp)
 SOURCES+=$(wildcard gateway/*.cpp)
@@ -14,6 +16,7 @@ SOURCES+=$(wildcard handlers/*.cpp)
 SOURCES+=$(wildcard database/*.cpp)
 SOURCES+=$(wildcard cache/*.cpp)
 SOURCES+=$(wildcard sandbox/*.cpp)
+SOURCES+=$(wildcard dynamic/*.cpp)
 
 HEADERS=$(wildcard *.h)
 HEADERS+=$(wildcard gateway/*.h)
@@ -21,7 +24,7 @@ HEADERS+=$(wildcard handlers/*.h)
 HEADERS+=$(wildcard database/*.h)
 HEADERS+=$(wildcard cache/*.h)
 HEADERS+=$(wildcard sandbox/*.h)
-
+HEADERS+=$(wildcard dynamic/*.h)
 
 OBJECTS=$(patsubst %.cpp, %.o, $(SOURCES))
 WIKIOBJECTS=$(filter-out test.o, $(OBJECTS))
@@ -48,8 +51,12 @@ profile: LDFLAGS+= -pg
 release: qswiki
 profile: qswiki
 
-qswiki: $(WIKIOBJECTS)
-	$(CXX) $(WIKIOBJECTS) ${LDFLAGS} ${INCLUDEFLAGS}  -o qswiki
+
+exile.o: submodules/exile.h/exile.c
+	$(CC) -std=c99 -DHAVE_LANDLOCK=0 -c submodules/exile.h/exile.c -o exile.o
+
+qswiki: $(WIKIOBJECTS) exile.o
+	$(CXX) $(shell shuf -e $(WIKIOBJECTS) exile.o ) ${LDFLAGS} ${INCLUDEFLAGS}  -o qswiki
 
 test: $(TESTOBJECTS)
 	$(CXX) $(TESTOBJECTS) ${LDFLAGS} -o test
@@ -63,6 +70,6 @@ gtest: $(GTESTS_TESTDIR)/*.cpp $(GTEST_OBJECTS)
 version.o:version.cpp
 	$(CXX) ${CXXFLAGS} ${INCLUDEFLAGS} -DGITCOMMIT=\"$(shell git rev-parse --short HEAD)\" -c -o $@ $<
 clean:
-	rm -f $(OBJECTS) $(DEPENDS)
+	rm -f exile.o $(OBJECTS) $(DEPENDS)
 
 

README.md

@@ -1,81 +1,84 @@
 # qswiki
 
-About
-====
-qswiki is a wiki software, intended for small wikis. Originally 
-implemented in C, it's now written in C++.
+## About
+qswiki is a wiki software, intended for my needs. Originally  implemented in C, it's now written in C++.
 
-History
-====
-A couple of years ago, I wanted to setup a personal wiki on my raspberry 
-pi. However, the distribution I used back then did not have a PHP package 
+## Dude... why?
+
+tl;dr: It was a playground, an experiment (taken too far). I guess at some point I couldn't stop, because I've already
+started.
+
+### History
+Several years ago, I wanted to setup a personal wiki on my raspberry
+pi. However, the distribution I used back then did not have a PHP package
 for ARM. So instead of switching distributions or searching for other
-wikis that I could use, I decided I would write one in C. Yes, 
-that's an odd way  to approach the problem and indeed, I may have had too 
-much time back  then. Also, I wanted to see how it's like to write a 
+wikis that I could use, I simply decided I would write one in C. Yes,
+that's an odd way  to approach the problem and indeed, I may have had too
+much time back  then. Also, I wanted to see how it's like to write a
 "web app" in C and wanted to sharpen my C skills a little bit.
 
-Of course, it's pretty straightforward at first. No really: Just use CGI. 
-And indeed, that would have been more than enough for my use cases. 
-Then I decided to play around and started using FastCGI (with the official 
+Of course, it's pretty straightforward at first. No really: Just use CGI
+and print your HTML to stdout.And indeed, that would have been more than enough for my use cases.
+
+But then I decided to play around and started using FastCGI (with the official
 library from now  defunct fastcgi.com) and created a multi-threaded version.
-It initially  used a "pile of files database", but that became too painful, 
+It initially  used a "pile of files database", but that became too painful,
 so then I started using sqlite.
 
 C++
 ---
-Eventually, since it was mostly a playground for me, the code became 
-unmaintainable. Furthermore, I wanted something quick and given that 
-it was CGI, I didn't bother taking care of memory leaks. 
-After initiating a FastCGI interface, they became an issue and then the 
+Eventually, since it was mostly a playground for me, the code became
+unmaintainable. Furthermore, I initially wanted something quick and given that
+it was CGI, I didn't bother taking care of memory leaks.
+After initiating a FastCGI interface, they became an issue and then the
 task of avoiding memory leaks became too annoying. And of course, C does n
-ot include any "batteries" and while I could manage, this too was another 
+ot include any "batteries" and while I could manage, this too was another
 good reason.
 
-Overall, I am just continuing the experiment with C++17 now. It's not 
-nearly as bad as you would expect perhaps. Some things are surprisingly 
-convenient even. Still, the standard library is lacking and 
-I would hope for a some better built-in Unicode support in future C++ 
+Overall, I am just continuing the experiment with >=C++17 now. It's not
+nearly as bad as you would expect perhaps. Some things are surprisingly
+convenient even. Still, the standard library is lacking and
+I would hope for a some better built-in Unicode support in future C++
 standards.
 
-Features
-========
-To be fair, at this point it doesn't even have a "diff" between revisions 
-yet and does not have features that would make you prefer it over other 
-wikis.
+
+## Features
+Some essential features are lacking, such as a diff between revisions,
+user registration UI, etc.
+
+It doesn't compete with any other software anyway.
 
  - CGI
- - HTTP server using the header only library cpp-httplib. It's more 
- portable and more "future-proof" than FastCGI (since the official website 
+ - HTTP server using the header only library [cpp-httplib](https://github.com/yhirose/cpp-httplib). It's more
+ portable and more "future-proof" than FastCGI (since the official website
  disappeared, the library's future appears to be uncertain).
  - Support for user accounts. Passwords are stored using PBKDF2.
-  sqlite database, but not too much of an effort to add other types of 
-  storage backends. sqlite is using the great header only library 
-  sqlite_modern_cpp
+  sqlite database, but not too much of an effort to add other types of
+  storage backends. sqlite is using the great header only library
+  [sqlite_modern_cpp](https://github.com/SqliteModernCpp)
  - Relatively fine-grained permission system.
  - Categories
  - Templates
  - FTS search
  - Caching
+ - Blog-like functionality
+ - RSS/Atom feeds
 
-Security
-========
-On Linux namespaces are used to restrict the process to only access
-files it needs. It doesn't have access to other paths in the system.
-In addition, Seccomp is used to restrict the syscalls the qswiki process
-can call.  As for "web security", all POST requests are centrally
-protected against CSRF attacks and all input is escaped against XSS 
+## Security
+[exile.h](https://github.com/quitesimpleorg/exile.h) is used
+to restrict access to the files the wiki needs.  It doesn't have access to other paths
+in the system and the system calls that the qswiki process can make are restricted.
+
+As for "web security", all POST requests are centrally protected against CSRF attacks and all input is escaped against XSS
 attacks.
 
-Building
-========
+## Building
 Dependencies:
   - cpp-httplib: https://github.com/yhirose/cpp-httplib
   - SqliteModernCpp: https://github.com/SqliteModernCpp
-  - qssb.h: https://gitea.quitesimple.org/crtxcr/qssb.h
-  - libseccomp: https://github.com/seccomp/libseccomp
+  - exile.h: https://gitea.quitesimple.org/crtxcr/exile.h
   - sqlite3: https://sqlite.org/index.html
-    
+
 The first three are header-only libraries that are included as a git submodule. The others must
 be installed, e. g. by using your distributions standard method.
 

cache/fscache.cpp

@@ -46,7 +46,7 @@ void FsCache::removePrefix(std::string_view prefix)
 	// TODO: lock dir
 	for(auto &entry : std::filesystem::directory_iterator(std::filesystem::path{this->path}))
 	{
-		if(std::string_view(entry.path().filename().c_str()).starts_with(prefix) == 0)
+		if(std::string_view(entry.path().filename().c_str()).starts_with(prefix))
 		{
 			std::filesystem::remove_all(entry);
 		}

cache/mapcache.h

@@ -4,6 +4,7 @@
 #include <set>
 #include <shared_mutex>
 #include <optional>
+#include <string>
 
 /* Thread-Safe Key-Value store */
 template <class T> class MapCache

cache/nocache.h

@@ -0,0 +1,30 @@
+#include "icache.h"
+
+class NoCache : public ICache
+{
+public:
+	NoCache(std::string p)
+	{
+
+	}
+	virtual std::optional<std::string> get(std::string_view key) const
+	{
+		return {};
+	}
+	virtual void put(std::string_view key, std::string val)
+	{
+		return;
+	}
+	virtual void remove(std::string_view key)
+	{
+		return;
+	}
+	virtual void removePrefix(std::string_view prefix)
+	{
+		return;
+	}
+	virtual void clear()
+	{
+		return;
+	}
+};

cli.cpp

@@ -141,10 +141,9 @@ std::pair<bool, std::string> CLIHandler::page_list([[maybe_unused]] const std::v
 	QueryOption o;
 	auto result = pageDao->getPageList(o);
 	std::stringstream stream;
-	for(std::string pagename : result)
+	for(Page &page : result)
 	{
-		Page p = pageDao->find(pagename).value();
-		stream << p.name << " " << p.pageid << " " << std::string(p.listed ? "listed" : "unlisted") << std::endl;
+		stream << page.name << " " << page.pageid << " " << std::string(page.listed ? "listed" : "unlisted") << std::endl;
 	}
 	return {true, stream.str()};
 }
@@ -271,9 +270,9 @@ std::pair<bool, std::string> CLIHandler::category_show(const std::vector<std::st
 	auto categoryDao = this->db->createCategoryDao();
 	auto members = categoryDao->fetchMembers(args.at(0), QueryOption{});
 	std::stringstream stream;
-	for(std::string &member : members)
+	for(Page &member : members)
 	{
-		stream << member << std::endl;
+		stream << member.name << std::endl;
 	}
 	return {true, stream.str()};
 }

config.cpp

@@ -24,6 +24,7 @@ SOFTWARE.
 #include "config.h"
 #include "permissions.h"
 #include "varreplacer.h"
+
 std::string Config::required(const std::string &key)
 {
 	auto it = this->configmap.find(key);
@@ -77,13 +78,16 @@ Config::Config(const std::map<std::string, std::string> &map)
 	this->templatepath = required("templatepath");
 	this->urls.linkallcats = required("linkallcats");
 	this->urls.linkallpages = required("linkallpages");
+	this->urls.linkallpagesrendertype = required ("linkallpagesrendertype");
 	this->urls.linkcategory = required("linkcategory");
+	this->urls.linkcategoryrendertype = required("linkcategoryrendertype");
 	this->urls.linkdelete = required("linkdelete");
 	this->urls.linkedit = required("linkedit");
 	this->urls.linkhistory = required("linkhistory");
 	this->urls.linkindex = required("linkindex");
 	this->urls.linklogout = required("linklogout");
 	this->urls.linkpage = required("linkpage");
+	this->urls.linkpagebytitle = required("linkpagebytitle");
 	this->urls.linkrecent = required("linkrecent");
 	this->urls.linkrevision = required("linkrevision");
 	this->urls.linksettings = required("linksettings");
@@ -96,6 +100,8 @@ Config::Config(const std::map<std::string, std::string> &map)
 	this->urls.deletionurl = required("deletionurl");
 	this->urls.adminregisterurl = required("adminregisterurl");
 	this->urls.usersettingsurl = required("usersettingsurl");
+	this->urls.rooturl = required("rooturl");
+	this->urls.atomurl = required("atomurl");
 	this->connectionstring = required("connectionstring");
 
 	this->handlersConfig.max_pagename_length = optional("max_pagename_length", 256);
@@ -108,7 +114,7 @@ Config::Config(const std::map<std::string, std::string> &map)
 
 	this->templateprefix = "{qswiki:";
 
-	this->max_payload_length = optional("max_payload_length", 10 * 1024 * 1024);
+	this->max_payload_length = optional("max_payload_length", 60 * 1024 * 1024);
 
 	ConfigVariableResolver resolver{this->configmap};
 	this->configVarResolver = resolver;

config.h

@@ -23,9 +23,11 @@ struct ConfigUrls
 	std::string linkindex;
 	std::string linkrecent;
 	std::string linkallpages;
+	std::string linkallpagesrendertype;
 	std::string linkallcats;
 	std::string linkshere;
 	std::string linkpage;
+	std::string linkpagebytitle;
 	std::string linkrevision;
 	std::string linkhistory;
 	std::string linkedit;
@@ -33,6 +35,7 @@ struct ConfigUrls
 	std::string linkdelete;
 	std::string linklogout;
 	std::string linkcategory;
+	std::string linkcategoryrendertype;
 	std::string loginurl;
 	std::string linkrecentsort;
 	std::string actionurl;
@@ -41,6 +44,8 @@ struct ConfigUrls
 	std::string linkhistorysort;
 	std::string adminregisterurl;
 	std::string usersettingsurl;
+	std::string rooturl;
+	std::string atomurl;
 };
 
 class ConfigVariableResolver

database/categorydao.h

@@ -5,7 +5,7 @@
 #include <optional>
 #include "queryoption.h"
 #include "../category.h"
-
+#include "../page.h"
 class CategoryDao
 {
   public:
@@ -14,7 +14,8 @@ class CategoryDao
 	virtual std::vector<std::string> fetchList(QueryOption o) = 0;
 	virtual std::optional<Category> find(std::string name) = 0;
 	virtual void deleteCategory(std::string name) = 0;
-	virtual std::vector<std::string> fetchMembers(std::string name, QueryOption o) = 0;
+	virtual std::vector<Page> fetchMembers(std::string name, QueryOption o) = 0;
+	virtual ~CategoryDao() = default;
 };
 
 #endif // CATEGORYDAO_H

database/categorydaosqlite.cpp

@@ -72,6 +72,7 @@ void CategoryDaoSqlite::deleteCategory(std::string name)
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
+		*db << "ROLLBACK";
 		throwFrom(e);
 	}
 }
@@ -94,21 +95,36 @@ std::vector<std::string> CategoryDaoSqlite::fetchList(QueryOption o)
 	}
 	return result;
 }
-std::vector<std::string> CategoryDaoSqlite::fetchMembers(std::string name, QueryOption o)
+
+std::vector<Page> CategoryDaoSqlite::fetchMembers(std::string name, QueryOption o)
 {
-	std::vector<std::string> result;
+	std::vector<Page> result;
 
 	SqliteQueryOption queryOption{o};
 	std::string queryoptions =
-		queryOption.setOrderByColumn("name").setVisibleColumnName("page.visible").setPrependWhere(false).build();
+		queryOption.setOrderByColumn("name").setListedColumnName("page.listed").setPrependWhere(false).build();
 
 	try
 	{
-		auto query = *db << "SELECT page.name AS name FROM categorymember INNER JOIN page ON page.id = "
-							"categorymember.page WHERE category = (SELECT id FROM category WHERE name = ? ) AND " +
-								queryoptions
-						 << name;
-		query >> [&](std::string p) { result.push_back(p); };
+		auto query =
+			*db
+			<< "SELECT page.id, page.name AS name, page.title, page.lastrevision, page.listed, page.feedlisted FROM "
+			   "categorymember INNER JOIN page ON page.id = "
+			   "categorymember.page WHERE category = (SELECT id FROM category WHERE name = ? ) AND " +
+				   queryoptions
+			<< name;
+		query >> [&](unsigned int id, std::string name, std::string title, unsigned int lastrevision, bool listed,
+					 bool feedlisted)
+		{
+			Page p;
+			p.name = name;
+			p.pageid = id;
+			p.title = title;
+			p.current_revision = lastrevision;
+			p.listed = listed;
+			p.feedlisted = feedlisted;
+			result.push_back(p);
+		};
 	}
 	catch(const sqlite::exceptions::no_rows &e)
 	{

database/categorydaosqlite.h

@@ -3,12 +3,13 @@
 
 #include "categorydao.h"
 #include "sqlitedao.h"
+#include "../page.h"
 class CategoryDaoSqlite : public CategoryDao, protected SqliteDao
 {
   public:
 	CategoryDaoSqlite();
 	std::vector<std::string> fetchList(QueryOption o) override;
-	std::vector<std::string> fetchMembers(std::string name, QueryOption o) override;
+	std::vector<Page> fetchMembers(std::string name, QueryOption o) override;
 	void save(const Category &c) override;
 	void deleteCategory(std::string name) override;
 	std::optional<Category> find(std::string name) override;

database/database.h

@@ -13,7 +13,7 @@
 #include "permissionsdao.h"
 class Database
 {
-  private:
+  protected:
 	std::string connnectionstring;
 
   public:

database/pagedao.h

@@ -13,8 +13,9 @@ class PageDao
 	virtual bool exists(std::string page) const = 0;
 	virtual bool exists(unsigned int id) const = 0;
 	virtual std::optional<Page> find(std::string name) = 0;
+	virtual std::optional<Page> findByTitle(std::string title) = 0;
 	virtual std::optional<Page> find(unsigned int id) = 0;
-	virtual std::vector<std::string> getPageList(QueryOption option) = 0;
+	virtual std::vector<Page> getPageList(QueryOption option) = 0;
 	virtual std::vector<std::string> fetchCategories(std::string pagename, QueryOption option) = 0;
 	virtual void deletePage(std::string page) = 0;
 	virtual void save(const Page &page) = 0;
@@ -22,6 +23,8 @@ class PageDao
 	virtual void setCategories(std::string pagename, const std::vector<std::string> &catnames) = 0;
 	virtual std::vector<SearchResult> search(std::string query, QueryOption option) = 0;
 
+	virtual std::vector<std::string> getChildren(std::string pagename) = 0;
+
 	virtual ~PageDao()
 	{
 	}

database/pagedaosqlite.cpp

@@ -52,15 +52,43 @@ std::optional<Page> PageDaoSqlite::find(std::string name)
 	}
 }
 
+std::optional<Page> PageDaoSqlite::findByTitle(std::string title)
+{
+	Page result;
+	try
+	{
+		auto ps =
+			*db
+			<< "SELECT id, name, title, lastrevision, listed, feedlisted, (SELECT name FROM page WHERE id = parent) "
+			   "FROM page WHERE title = ?";
+		ps << title >> std::tie(result.pageid, result.name, result.title, result.current_revision, result.listed,
+								result.feedlisted, result.parentpage);
+	}
+	catch(const sqlite::errors::no_rows &e)
+	{
+		return {};
+	}
+	catch(sqlite::sqlite_exception &e)
+	{
+		throwFrom(e);
+	}
+
+	return result;
+}
+
 std::optional<Page> PageDaoSqlite::find(unsigned int id)
 {
 	Page result;
 	result.pageid = id;
 	try
 	{
-		auto ps = *db << "SELECT name, lastrevision, visible FROM page WHERE id = ?";
+		auto ps =
+			*db
+			<< "SELECT name, title, lastrevision, listed, feedlisted, (SELECT name FROM page WHERE id = parent) FROM "
+			   "page WHERE id = ?";
 
-		ps << id >> std::tie(result.name, result.current_revision, result.listed);
+		ps << id >> std::tie(result.name, result.title, result.current_revision, result.listed, result.feedlisted,
+							 result.parentpage);
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -89,6 +117,7 @@ void PageDaoSqlite::deletePage(std::string page)
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
+		*db << "ROLLBACK";
 		throwFrom(e);
 	}
 }
@@ -97,30 +126,44 @@ void PageDaoSqlite::save(const Page &page)
 {
 	try
 	{
-		*db << "INSERT OR REPLACE INTO page (id, name, lastrevision, visible) VALUES((SELECT id FROM page WHERE name = "
-			   "? OR id = ?), ?, ?, ?)"
-			<< page.name << page.pageid << page.name << page.current_revision << page.listed;
+		*db << "INSERT OR REPLACE INTO page (id, name, title, lastrevision, listed, feedlisted, parent) VALUES((SELECT "
+			   "id FROM page WHERE name = ? OR id = ?), ?, ?, ?, ?, ?, (SELECT id FROM page WHERE name = ?))"
+			<< page.name << page.pageid << page.name << page.title << page.current_revision << page.listed
+			<< page.feedlisted << page.parentpage;
 	}
 	catch(sqlite::sqlite_exception &e)
 	{
 		throwFrom(e);
 	}
 }
-std::vector<std::string> PageDaoSqlite::getPageList(QueryOption option)
+
+std::vector<Page> PageDaoSqlite::getPageList(QueryOption option)
 {
-	std::vector<std::string> result;
+	std::vector<Page> result;
 
 	try
 	{
-
 		std::string queryOption = SqliteQueryOption(option)
 									  .setOrderByColumn("lower(name)")
-									  .setVisibleColumnName("visible")
+									  .setListedColumnName("listed")
 									  .setPrependWhere(true)
 									  .build();
-		std::string query = "SELECT name FROM page " + queryOption;
-
-		*db << query >> [&](std::string name) { result.push_back(name); };
+		std::string query = "SELECT id, name, title, lastrevision, listed, feedlisted,  (SELECT name FROM page WHERE "
+							"id = parent) FROM page " +
+							queryOption;
+		*db << query >> [&](unsigned int pageid, std::string name, std::string title, unsigned int current_revision,
+							bool listed, bool feedlisted, std::string parent)
+		{
+			Page tmp;
+			tmp.pageid = pageid;
+			tmp.name = name;
+			tmp.title = title;
+			tmp.current_revision = current_revision;
+			tmp.listed = listed;
+			tmp.feedlisted = feedlisted;
+			tmp.parentpage = parent;
+			result.push_back(tmp);
+		};
 	}
 	catch(const sqlite::errors::no_rows &e)
 	{
@@ -183,7 +226,8 @@ std::vector<SearchResult> PageDaoSqlite::search(std::string name, QueryOption op
 		auto query =
 			*db << "SELECT page.name FROM search INNER JOIN page ON search.page = page.id WHERE search MATCH ? "
 				<< ftsEscape(name);
-		query >> [&](std::string pagename) {
+		query >> [&](std::string pagename)
+		{
 			SearchResult sresult;
 			sresult.pagename = pagename;
 			sresult.query = name;
@@ -230,3 +274,11 @@ int PageDaoSqlite::fetchPageId(std::string pagename)
 	auto binder = *db << "SELECT id FROM page WHERE name = ?" << pagename;
 	return execInt(binder);
 }
+
+std::vector<std::string> PageDaoSqlite::getChildren(std::string pagename)
+{
+	std::vector<std::string> result;
+	auto query = *db << "SELECT name FROM page WHERE parent = (SELECT id FROM page WHERE name = ?)" << pagename;
+	query >> [&](std::string page) { result.push_back(page); };
+	return result;
+}

database/pagedaosqlite.h

@@ -20,13 +20,16 @@ class PageDaoSqlite : public PageDao, protected SqliteDao
 	bool exists(std::string name) const override;
 	void save(const Page &page) override;
 	std::optional<Page> find(std::string name) override;
+	std::optional<Page> findByTitle(std::string title) override;
 	std::optional<Page> find(unsigned int id) override;
-	std::vector<std::string> getPageList(QueryOption option) override;
+	std::vector<Page> getPageList(QueryOption option) override;
 	std::vector<std::string> fetchCategories(std::string pagename, QueryOption option) override;
 	using SqliteDao::SqliteDao;
 	int fetchPageId(std::string pagename);
 	std::vector<SearchResult> search(std::string query, QueryOption option) override;
 	void setCategories(std::string pagename, const std::vector<std::string> &catnames) override;
+	std::vector<std::string> getChildren(std::string pagename) override;
+
 };
 
 #endif // PAGEDAOSQLITE_H

database/permissionsdao.h

@@ -9,6 +9,9 @@ class PermissionsDao
 	PermissionsDao();
 	virtual std::optional<Permissions> find(std::string pagename, std::string username) = 0;
 	virtual void save(std::string pagename, std::string username, Permissions perms) = 0;
+	virtual void clearForPage(std::string pagename) = 0;
+
+	virtual ~PermissionsDao() = default;
 };
 
 #endif // PERMISSIONSDAO_H

database/permissionsdaosqlite.cpp

@@ -59,3 +59,16 @@ void PermissionsDaoSqlite::save(std::string pagename, std::string username, Perm
 		throwFrom(e);
 	}
 }
+
+void PermissionsDaoSqlite::clearForPage(std::string pagename)
+{
+	try
+	{
+		auto stmt = *db << "DELETE FROM permissions WHERE page = (SELECT id FROM page WHERE name = ?)" << pagename;
+		stmt.execute();
+	}
+	catch(sqlite::sqlite_exception &e)
+	{
+		throwFrom(e);
+	}
+}

database/permissionsdaosqlite.h

@@ -10,6 +10,7 @@ class PermissionsDaoSqlite : public PermissionsDao, protected SqliteDao
 
 	std::optional<Permissions> find(std::string pagename, std::string username) override;
 	virtual void save(std::string pagename, std::string username, Permissions perms) override;
+	virtual void clearForPage(std::string pagename) override;
 	using SqliteDao::SqliteDao;
 };
 

database/queryoption.h

@@ -13,7 +13,7 @@ class QueryOption
 	unsigned int offset = 0;
 	unsigned int limit = 0;
 	SORT_ORDER order = ASCENDING;
-	bool includeInvisible = true;
+	bool includeUnlisted = true;
 };
 
 #endif // QUERYOPTION_H

database/revisiondaosqlite.cpp

@@ -52,7 +52,7 @@ std::vector<Revision> RevisionDaoSqlite::getAllRevisions(QueryOption &options)
 	{
 		SqliteQueryOption queryOption{options};
 		std::string queryOptionSql = queryOption.setPrependWhere(true)
-										 .setVisibleColumnName("page.visible")
+										 .setListedColumnName("page.listed")
 										 .setOrderByColumn("creationtime")
 										 .build();
 		auto query =
@@ -61,7 +61,8 @@ std::vector<Revision> RevisionDaoSqlite::getAllRevisions(QueryOption &options)
 			   "page.name, revisionid FROM revision INNER JOIN page ON revision.page = page.id " +
 				   queryOptionSql;
 		query >> [&](std::string author, std::string comment, std::string content, time_t creationtime,
-					 std::string page, unsigned int revisionid) {
+					 std::string page, unsigned int revisionid)
+		{
 			Revision r;
 			r.author = author;
 			r.comment = comment;
@@ -91,7 +92,7 @@ std::vector<Revision> RevisionDaoSqlite::getAllRevisionsForPage(std::string page
 	{
 		SqliteQueryOption queryOption{option};
 		std::string queryOptionSql = queryOption.setPrependWhere(false)
-										 .setVisibleColumnName("page.visible")
+										 .setListedColumnName("page.listed")
 										 .setOrderByColumn("creationtime")
 										 .build();
 		auto query = *db << "SELECT (SELECT username FROM user WHERE id = author), comment, content, "
@@ -101,7 +102,8 @@ std::vector<Revision> RevisionDaoSqlite::getAllRevisionsForPage(std::string page
 						 << pagename;
 
 		query >> [&](std::string author, std::string comment, std::string content, time_t creationtime,
-					 std::string page, unsigned int revisionid) {
+					 std::string page, unsigned int revisionid)
+		{
 			Revision r;
 			r.author = author;
 			r.comment = comment;
@@ -129,9 +131,9 @@ std::optional<Revision> RevisionDaoSqlite::getCurrentForPage(std::string pagenam
 	try
 	{
 		auto query = *db << "SELECT (SELECT username FROM user WHERE id = author), comment, content, "
-							"strftime('%s',creationtime), page, revisionid FROM revision WHERE page = (SELECT id FROM "
-							"page WHERE name = ? ) AND revisionid = (SELECT lastrevision FROM page WHERE name = ?)";
-		query << pagename << pagename;
+							"strftime('%s',creationtime), page.name, revisionid FROM revision INNER JOIN page ON "
+							"revision.page = page.id WHERE page.name = ? AND page.lastrevision = revision.revisionid";
+		query << pagename;
 		query >>
 			std::tie(result.author, result.comment, result.content, result.timestamp, result.page, result.revision);
 	}
@@ -155,7 +157,8 @@ std::optional<Revision> RevisionDaoSqlite::getRevisionForPage(std::string pagena
 		auto query =
 			*db
 			<< "SELECT (SELECT username FROM user WHERE id = author), comment, content, strftime('%s',creationtime), "
-			   "page, revisionid FROM revision WHERE page = (SELECT id FROM page WHERE name = ? ) AND revisionid = ?";
+			   "page.name, revisionid FROM revision INNER JOIN page ON revision.page = page.id WHERE page.name = ? AND "
+			   "revisionid = ?  ";
 		query << pagename << revision;
 		query >>
 			std::tie(result.author, result.comment, result.content, result.timestamp, result.page, result.revision);

database/sessiondao.h

@@ -10,6 +10,7 @@ class SessionDao
 	virtual void save(const Session &session) = 0;
 	virtual std::optional<Session> find(std::string token) = 0;
 	virtual void deleteSession(std::string token) = 0;
+	virtual std::vector<Session> fetch() = 0;
 	virtual ~SessionDao()
 	{
 	}

database/sessiondaosqlite.cpp

@@ -50,6 +50,29 @@ void SessionDaoSqlite::deleteSession(std::string token)
 	}
 }
 
+void SessionDaoSqlite::fillSession(int userid, Session &sess)
+{
+	if(userid > -1)
+	{
+		UserDaoSqlite userDao{*this->db};
+		auto u = userDao.find(userid);
+		if(u)
+		{
+			sess.user = *u;
+		}
+		else
+		{
+			Logger::error() << "Session for non existent user";
+			throw DatabaseQueryException("Session for non existent user");
+		}
+	}
+	else
+	{
+		sess.user = User::Anonymous();
+	}
+	sess.loggedIn = userid != -1;
+}
+
 std::optional<Session> SessionDaoSqlite::find(std::string token)
 {
 	Session result;
@@ -62,25 +85,7 @@ std::optional<Session> SessionDaoSqlite::find(std::string token)
 		int userid;
 		q >> std::tie(userid, result.token, result.csrf_token, result.creation_time);
 
-		if(userid > -1)
-		{
-			UserDaoSqlite userDao{this->db};
-			auto u = userDao.find(userid);
-			if(u)
-			{
-				result.user = *u;
-			}
-			else
-			{
-				Logger::error() << "Session for non existent user";
-				throw DatabaseQueryException("Session for non existent user");
-			}
-		}
-		else
-		{
-			result.user = User::Anonymous();
-		}
-		result.loggedIn = userid != -1;
+		fillSession(userid, result);
 	}
 	catch(const sqlite::exceptions::no_rows &e)
 	{
@@ -92,3 +97,23 @@ std::optional<Session> SessionDaoSqlite::find(std::string token)
 	}
 	return result;
 }
+
+std::vector<Session> SessionDaoSqlite::fetch()
+{
+	std::vector<Session> result;
+
+	*db << "SELECT userid, token, csrf_token, strftime('%s', creationtime) FROM session" >>
+		[this, &result](int userid, std::string token, std::string csrf_token, time_t creationtime)
+	{
+		Session tmp;
+		tmp.csrf_token = csrf_token;
+		tmp.token = token;
+		tmp.creation_time = creationtime;
+
+		fillSession(userid, tmp);
+
+		result.push_back(tmp);
+	};
+
+	return result;
+}

database/sessiondaosqlite.h

@@ -6,11 +6,15 @@
 
 class SessionDaoSqlite : public SessionDao, protected SqliteDao
 {
+private:
+  void fillSession(int userid, Session &sess);
+
   public:
 	SessionDaoSqlite();
 	void save(const Session &session) override;
 	std::optional<Session> find(std::string token) override;
 	void deleteSession(std::string token) override;
+	std::vector<Session> fetch() override;
 	using SqliteDao::SqliteDao;
 };
 

database/sqlite.cpp

@@ -18,23 +18,43 @@ 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.
 */
+#include <atomic>
 #include "sqlite.h"
-#include "../logger.h"
 #include "pagedaosqlite.h"
 #include "revisiondaosqlite.h"
 #include "sessiondaosqlite.h"
+#include "sqlite_modern_cpp.h"
 #include "userdaosqlite.h"
 #include "categorydaosqlite.h"
-#include "exceptions.h"
 #include "permissionsdaosqlite.h"
 
+thread_local sqlite::database *Sqlite::db = nullptr;
+
+std::atomic<int> instances = 0;
 Sqlite::Sqlite(std::string path) : Database(path)
 {
-	this->db = std::make_shared<sqlite::database>(path);
-
-	*db << "PRAGMA journal_mode=WAL;";
+	instances++;
+	if(instances.load() > 1)
+	{
+		std::cerr << "temporal (yeah, right) HACK... only one instance allowed" << std::endl;
+		abort();
+	}
 }
 
+std::mutex dbmutex;
+sqlite::database &Sqlite::database() const
+{
+	if(Sqlite::db == nullptr)
+	{
+		sqlite::sqlite_config config;
+		config.flags = config.flags | sqlite::OpenFlags::FULLMUTEX;
+		std::lock_guard<std::mutex> dbguard(dbmutex);
+		Sqlite::db = new sqlite::database(this->connnectionstring, config);
+		*Sqlite::db << "PRAGMA journal_mode=WAL;";
+		*Sqlite::db << "PRAGMA busy_timeout=10000;";
+	}
+	return *Sqlite::db;
+}
 std::unique_ptr<RevisionDao> Sqlite::createRevisionDao() const
 {
 	return create<RevisionDaoSqlite>();
@@ -67,27 +87,20 @@ std::unique_ptr<PermissionsDao> Sqlite::createPermissionsDao() const
 
 void Sqlite::beginTransaction()
 {
-	if(!inTransaction)
-	{
-		*db << "begin;";
-		inTransaction = true;
-	}
+	*db << "begin;";
 }
 
 void Sqlite::rollbackTransaction()
 {
-	if(inTransaction)
-	{
-		*db << "rollback;";
-		inTransaction = false;
-	}
+	*db << "rollback;";
 }
 
 void Sqlite::commitTransaction()
 {
-	if(inTransaction)
-	{
-		*db << "commit;";
-		inTransaction = false;
-	}
+	*db << "commit;";
+}
+
+Sqlite::~Sqlite()
+{
+	delete this->db;
 }

database/sqlite.h

@@ -8,14 +8,15 @@
 class Sqlite : public Database
 {
   private:
-	bool inTransaction = false;
-	std::shared_ptr<sqlite::database> db;
+	static thread_local sqlite::database *db;
 
 	template <class T> std::unique_ptr<T> create() const
 	{
-		return std::make_unique<T>(db);
+		return std::make_unique<T>(database());
 	}
 
+	sqlite::database &database() const;
+
   public:
 	Sqlite(std::string path);
 	std::unique_ptr<PageDao> createPageDao() const;
@@ -27,6 +28,7 @@ class Sqlite : public Database
 	void beginTransaction();
 	void commitTransaction();
 	void rollbackTransaction();
+	virtual ~Sqlite();
 };
 
 #endif // SQLITE_H

database/sqlitedao.h

@@ -12,20 +12,20 @@
 class SqliteDao
 {
   protected:
-	std::shared_ptr<sqlite::database> db;
+	sqlite::database *db = nullptr;
 
   public:
 	SqliteDao()
 	{
 	}
 
-	SqliteDao(std::shared_ptr<sqlite::database> db)
+	SqliteDao(sqlite::database &db)
 	{
-		this->db = db;
+		this->db = &db;
 	}
-	void setDb(std::shared_ptr<sqlite::database> db)
+	void setDb(sqlite::database &db)
 	{
-		this->db = db;
+		this->db = &db;
 	}
 
 	inline void throwFrom(const sqlite::sqlite_exception &e) const
@@ -37,6 +37,8 @@ class SqliteDao
 
 	bool execBool(sqlite::database_binder &binder) const;
 	int execInt(sqlite::database_binder &binder) const;
+
+	virtual ~SqliteDao() = default;
 };
 
 #endif // SQLITEDAO_H

database/sqlitequeryoption.cpp

@@ -31,9 +31,9 @@ SqliteQueryOption &SqliteQueryOption::setOrderByColumn(std::string name)
 	return *this;
 }
 
-SqliteQueryOption &SqliteQueryOption::setVisibleColumnName(std::string name)
+SqliteQueryOption &SqliteQueryOption::setListedColumnName(std::string name)
 {
-	this->visibleColumnName = name;
+	this->listedColumnName = name;
 	return *this;
 }
 
@@ -50,9 +50,9 @@ std::string SqliteQueryOption::build()
 	{
 		result += "WHERE ";
 	}
-	if(!o.includeInvisible && !this->visibleColumnName.empty())
+	if(!o.includeUnlisted && !this->listedColumnName.empty())
 	{
-		result += this->visibleColumnName + " = 1";
+		result += this->listedColumnName + " = 1";
 	}
 	else
 	{

database/sqlitequeryoption.h

@@ -7,7 +7,7 @@ class SqliteQueryOption
 {
   private:
 	QueryOption o;
-	std::string visibleColumnName;
+	std::string listedColumnName;
 	std::string orderByColumnName;
 
 	bool prependWhere;
@@ -17,7 +17,7 @@ class SqliteQueryOption
 
 	SqliteQueryOption &setOrderByColumn(std::string name);
 
-	SqliteQueryOption &setVisibleColumnName(std::string name);
+	SqliteQueryOption &setListedColumnName(std::string name);
 
 	SqliteQueryOption &setPrependWhere(bool b);
 

dynamic/dynamiccontent.cpp

@@ -0,0 +1,9 @@
+#include "dynamiccontent.h"
+
+DynamicContent::DynamicContent(Template &templ, Database &database, UrlProvider &provider, Session &session)
+{
+	this->templ = &templ;
+	this->database = &database;
+	this->urlProvider = &provider;
+	this->userSession = &session;
+}

dynamic/dynamiccontent.h

@@ -0,0 +1,29 @@
+#ifndef DYNAMICCONTENT_H
+#define DYNAMICCONTENT_H
+#include <string>
+#include "../database/database.h"
+#include "../template.h"
+#include "../urlprovider.h"
+class DynamicContent
+{
+  protected:
+	Template *templ;
+	Database *database;
+	UrlProvider *urlProvider;
+	Session *userSession;
+
+	std::string argument;
+
+  public:
+	DynamicContent(Template &templ, Database &database, UrlProvider &urlProvider, Session &session);
+	virtual std::string render() = 0;
+	virtual void setArgument(std::string argument)
+	{
+		this->argument = argument;
+	}
+	virtual ~DynamicContent()
+	{
+	}
+};
+
+#endif // DYNAMICCONTENT_H

dynamic/dynamiccontentfactory.h

@@ -0,0 +1,30 @@
+#ifndef DYNAMICCONTENTFACTORY_H
+#define DYNAMICCONTENTFACTORY_H
+
+#include "dynamiccontent.h"
+
+class DynamicContentFactory
+{
+private:
+	Template *templ;
+	Database *db;
+	UrlProvider *urlProvider;
+	Session *session;
+	
+public:
+	DynamicContentFactory(Template &templ, Database &db, UrlProvider &urlProvider, Session &session)
+	{
+		this->templ = &templ;
+		this->db = &db;
+		this->urlProvider = &urlProvider;
+		this->session = &session;
+	}
+	
+	template <class T> inline std::shared_ptr<T> createDynamicContent()
+	{
+		return std::make_shared<T>(*this->templ, *this->db, *this->urlProvider, *this->session);
+	}
+	
+	
+};
+#endif // DYNAMICCONTENTFACTORY_H_INCLUDED

dynamic/dynamiccontentgetvar.cpp

@@ -0,0 +1,11 @@
+#include "dynamiccontentgetvar.h"
+
+std::string DynamicContentGetVar::render()
+{
+	return (*this->map)[this->argument];
+}
+
+void DynamicContentGetVar::setMap(std::map<std::string, std::string> &map)
+{
+	this->map = &map;
+}

dynamic/dynamiccontentgetvar.h

@@ -0,0 +1,19 @@
+#ifndef DYNAMICCONTENTGETVAR_H
+#define DYNAMICCONTENTGETVAR_H
+
+#include "dynamiccontent.h"
+class DynamicContentGetVar : public DynamicContent
+{
+  private:
+	std::map<std::string, std::string> *map;
+
+  public:
+	using DynamicContent::DynamicContent;
+
+	// DynamicContent interface
+  public:
+	std::string render();
+	void setMap(std::map<std::string, std::string> &map);
+};
+
+#endif // DYNAMICCONTENTGETVAR_H

dynamic/dynamiccontentincludepage.cpp

@@ -0,0 +1,16 @@
+#include "dynamiccontentincludepage.h"
+#include "../parser.h"
+std::string DynamicContentIncludePage::render()
+{
+	auto revisionDao = this->database->createRevisionDao();
+	auto rev = revisionDao->getCurrentForPage(this->argument);
+	if(rev)
+	{
+		/* Quite dirty */
+		if(rev->content.find("[cmd:allowinclude]1[") != std::string::npos)
+		{
+			return rev->content;
+		}
+	}
+	return {};
+}

dynamic/dynamiccontentincludepage.h

@@ -0,0 +1,12 @@
+#ifndef DYNAMICCONTENTINCLUDEPAGE_H
+#define DYNAMICCONTENTINCLUDEPAGE_H
+#include "dynamiccontent.h"
+class DynamicContentIncludePage : public DynamicContent
+{
+  public:
+	using DynamicContent::DynamicContent;
+
+	std::string render();
+};
+
+#endif // DYNAMICCONTENTINCLUDEPAGE_H

dynamic/dynamiccontentpostlist.cpp

@@ -0,0 +1,46 @@
+#include <chrono>
+#include "dynamiccontentpostlist.h"
+
+std::string DynamicContentPostList::render()
+{
+	auto categoryDao = this->database->createCategoryDao();
+	auto pageDao = this->database->createPageDao();
+	auto revisionDao = this->database->createRevisionDao();
+	auto permissionDao = this->database->createPermissionsDao();
+
+	QueryOption option;
+	option.includeUnlisted = false;
+	auto members = categoryDao->fetchMembers(this->argument, option);
+	std::vector<std::pair<std::string, time_t>> pageList;
+	for(const Page &member : members)
+	{
+		Permissions perms = permissionDao->find(member.name, this->userSession->user.login)
+								.value_or(this->userSession->user.permissions);
+		if(perms.canRead()) /* TODO: Maybe add canList() */
+		{
+			auto revision = revisionDao->getRevisionForPage(member.name, 1);
+			pageList.push_back({member.name, revision->timestamp});
+		}
+	}
+	std::sort(pageList.begin(), pageList.end(),
+			  [](std::pair<std::string, time_t> &a, std::pair<std::string, time_t> &b) { return a.second > b.second; });
+
+	std::string postListBegin = this->templ->loadResolvedPart("dynamic/postlistbegin");
+	std::string postListEnd = this->templ->loadResolvedPart("dynamic/postlistend");
+	std::string postLink = this->templ->loadResolvedPart("dynamic/postlistlink");
+	std::stringstream stream;
+	stream << postListBegin;
+	for(auto &pair : pageList)
+	{
+		std::string link = this->urlProvider->page(pair.first);
+		std::string date = utils::toISODate(pair.second);
+		Varreplacer replacer{"{"};
+		replacer.addKeyValue("url", link);
+		replacer.addKeyValue("date", date);
+		replacer.addKeyValue("title", pageDao->find(pair.first)->title);
+
+		stream << replacer.parse(postLink);
+	}
+	stream << postListEnd;
+	return stream.str();
+}

dynamic/dynamiccontentpostlist.h

@@ -0,0 +1,12 @@
+#ifndef DYNAMICCONTENTPOSTLIST_H
+#define DYNAMICCONTENTPOSTLIST_H
+
+#include "dynamiccontent.h"
+class DynamicContentPostList : public DynamicContent
+{
+  public:
+	using DynamicContent::DynamicContent;
+	std::string render() override;
+};
+
+#endif // DYNAMICCONTENTPOSTLIST_H

dynamic/dynamiccontentsetvar.cpp

@@ -0,0 +1,21 @@
+#include "dynamiccontentsetvar.h"
+
+std::string DynamicContentSetVar::render()
+{
+	auto result = utils::split(this->argument, '=');
+	if(result.size() == 2)
+	{
+		this->map->emplace(std::make_pair(result[0], result[1]));
+	}
+	return {};
+}
+
+void DynamicContentSetVar::setArgument(std::string argument)
+{
+	this->argument = argument;
+}
+
+void DynamicContentSetVar::setMap(std::map<std::string, std::string> &map)
+{
+	this->map = &map;
+}

dynamic/dynamiccontentsetvar.h

@@ -0,0 +1,17 @@
+#ifndef DYNAMCCONTENTPUSHVAR_H
+#define DYNAMCCONTENTPUSHVAR_H
+#include "dynamiccontent.h"
+class DynamicContentSetVar : public DynamicContent
+{
+  private:
+	std::map<std::string, std::string> *map;
+
+  public:
+	using DynamicContent::DynamicContent;
+
+	std::string render();
+	void setArgument(std::string argument);
+	void setMap(std::map<std::string, std::string> &map);
+};
+
+#endif // DYNAMCCONTENTPUSHVAR_H

dynamic/dynamicpostrenderer.cpp

@@ -0,0 +1,73 @@
+#include <chrono>
+#include "dynamicpostrenderer.h"
+#include "../parser.h"
+#include "../utils.h"
+
+void DynamicPostRenderer::setArgument(std::string argument)
+{
+	auto splitted = utils::split(argument, '|');
+	this->category = splitted[0];
+	if(splitted.size() >= 2)
+	{
+		this->templatepartname = splitted[1];
+	}
+	if(splitted.size() >= 3)
+	{
+		this->customlinkurl = splitted[2];
+	}
+}
+
+std::string DynamicPostRenderer::linkToPage(std::string page)
+{
+	if(this->customlinkurl.empty())
+	{
+		return this->urlProvider->page(page);
+	}
+	return utils::strreplace(this->customlinkurl, "{page}", page);
+}
+
+std::string DynamicPostRenderer::render()
+{
+	auto categoryDao = this->database->createCategoryDao();
+	auto pageDao = this->database->createPageDao();
+	auto revisionDao = this->database->createRevisionDao();
+	auto permissionDao = this->database->createPermissionsDao();
+
+	QueryOption option;
+	option.includeUnlisted = true;
+	auto members = categoryDao->fetchMembers(this->category, option);
+	std::vector<std::pair<std::string, time_t>> pageList;
+	for(const Page &member : members)
+	{
+		Permissions perms = permissionDao->find(member.name, this->userSession->user.login)
+								.value_or(this->userSession->user.permissions);
+		if(perms.canRead())
+		{
+			auto revision = revisionDao->getRevisionForPage(member.name, 1);
+			pageList.push_back({member.name, revision->timestamp});
+		}
+	}
+	std::sort(pageList.begin(), pageList.end(),
+			  [](std::pair<std::string, time_t> &a, std::pair<std::string, time_t> &b) { return a.second > b.second; });
+
+	std::string entry = this->templ->loadResolvedPart(this->templatepartname);
+	std::stringstream stream;
+	for(auto &pair : pageList)
+	{
+		std::optional<Revision> revision = revisionDao->getCurrentForPage(pair.first);
+		if(revision)
+		{
+			std::string link = linkToPage(pair.first);
+			Parser parser;
+
+			std::string date = utils::toISODateTime(revision->timestamp);
+			Varreplacer replacer{"{"};
+			replacer.addKeyValue("url", link);
+			replacer.addKeyValue("date", date);
+			replacer.addKeyValue("content", parser.parse(*pageDao, *this->urlProvider,
+														 parser.extractFirstTag("content", revision->content)));
+			stream << replacer.parse(entry);
+		}
+	}
+	return stream.str();
+}

dynamic/dynamicpostrenderer.h

@@ -0,0 +1,18 @@
+#ifndef DYNAMICPOSTRENDERER_H
+#define DYNAMICPOSTRENDERER_H
+#include "dynamiccontent.h"
+class DynamicPostRenderer : public DynamicContent
+{
+private:
+	std::string category;
+	std::string customlinkurl;
+	std::string templatepartname = "dynamic/categoryrendererentry";
+
+  public:
+	using DynamicContent::DynamicContent;
+	std::string render() override;
+	void setArgument(std::string argument) override;
+	std::string linkToPage(std::string page);
+};
+
+#endif // DYNAMICPOSTRENDERER_H

gateway/httpgateway.h

@@ -1,5 +1,8 @@
 #ifndef HTTPGATEWAY_H
 #define HTTPGATEWAY_H
+
+#define CPPHTTPLIB_FORM_URL_ENCODED_PAYLOAD_MAX_LENGTH 65536
+
 #include <httplib.h>
 #include "gatewayinterface.h"
 #include "../requestworker.h"

grouper.h

@@ -0,0 +1,26 @@
+#include "utils.h"
+
+template<class G, class V, class C>
+class Grouper
+{
+	std::map<G, std::vector<const V*>, C> results;
+public:
+
+	Grouper(C c)
+	{
+		results = std::map<G, std::vector<const V*>, C>(c);
+	}
+
+	void group(const std::function<G(const V&)> &map, const std::vector<V> &values)
+	{
+		for(const V &v : values)
+		{
+			results[map(v)].push_back(&v);
+		}
+	}
+
+	std::map<G, std::vector<const V*>, C> &getResults()
+	{
+		return this->results;
+	}
+};

handlers/handler.cpp

@@ -53,7 +53,7 @@ std::string Handler::createPageTitle(std::string title)
 QueryOption Handler::queryOption(const Request &r, SORT_ORDER defaultSort) const
 {
 	QueryOption result;
-	result.includeInvisible = false;
+	result.includeUnlisted = false;
 	try
 	{
 		result.limit = utils::toUInt(r.get("limit"));
@@ -98,7 +98,10 @@ Response Handler::handle(const Request &r)
 
 Permissions Handler::effectivePermissions(std::string page)
 {
-	return this->database->createPermissionsDao()
-		->find(page, this->userSession->user.login)
-		.value_or(this->userSession->user.permissions);
+	Permissions &userPerms = this->userSession->user.permissions;
+	if(userPerms.isAdmin())
+	{
+		return userPerms;
+	}
+	return this->database->createPermissionsDao()->find(page, this->userSession->user.login).value_or(userPerms);
 }

handlers/handler.h

@@ -1,5 +1,6 @@
 #ifndef HANDLER_H
 #define HANDLER_H
+#include <memory>
 #include "../config.h"
 #include "../response.h"
 #include "../request.h"
@@ -9,6 +10,8 @@
 #include "../database/queryoption.h"
 #include "../logger.h"
 #include "../cache/icache.h"
+#include "../dynamic/dynamiccontent.h"
+
 class Handler
 {
   protected:
@@ -53,6 +56,12 @@ class Handler
 	virtual ~Handler()
 	{
 	}
+
+	template <class T> inline std::shared_ptr<T> createDynamic()
+	{
+		return std::make_shared<T>(*this->templ, *this->database, *this->urlProvider);
+	}
+
 	Response errorResponse(std::string errortitle, std::string errormessage, int status = 200);
 	std::string createPageTitle(std::string append);
 };

handlers/handlerallpages.cpp

@@ -19,6 +19,8 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 #include "handlerallpages.h"
+#include "../grouper.h"
+#include "../pagelistrenderer.h"
 
 Response HandlerAllPages::handleRequest(const Request &r)
 {
@@ -27,17 +29,21 @@ Response HandlerAllPages::handleRequest(const Request &r)
 		Response response;
 		auto pageDao = this->database->createPageDao();
 		QueryOption qo = queryOption(r);
-		auto resultList = pageDao->getPageList(qo);
-		if(resultList.size() == 0)
+		std::vector<Page> pageList = pageDao->getPageList(qo);
+		if(pageList.size() == 0)
 		{
 			return errorResponse("No pages", "This wiki does not have any pages yet");
 		}
-		TemplatePage searchPage = this->templ->getPage("allpages");
-		std::string body = this->templ->renderSearch(resultList);
-		searchPage.setVar("pagelist", body);
-		searchPage.setVar("title", createPageTitle("All pages"));
-		setGeneralVars(searchPage);
-		response.setBody(searchPage.render());
+		
+		PageListRenderer pagelistrender(*this->templ, *this->urlProvider, *this->database);
+		TemplatePage allPages = this->templ->getPage("allpages");
+		allPages.setVar("pagelistcontent", pagelistrender.render(pageList, r.get("rendertype")));
+		allPages.setVar("pagelistletterlink", this->urlProvider->allPages(PageListRenderer::RENDER_GROUP_BY_LETTER));
+		allPages.setVar("pagelistcreationdatelink",  this->urlProvider->allPages(PageListRenderer::RENDER_GROUP_BY_CREATIONDATE));
+				
+		allPages.setVar("title", createPageTitle("All pages"));
+		setGeneralVars(allPages);
+		response.setBody(allPages.render());
 		response.setStatus(200);
 		return response;
 	}

handlers/handlercategory.cpp

@@ -19,6 +19,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 #include "handlercategory.h"
+#include "../pagelistrenderer.h"
 
 Response HandlerCategory::handleRequest(const Request &r)
 {
@@ -34,8 +35,12 @@ Response HandlerCategory::handleRequest(const Request &r)
 		QueryOption qo = queryOption(r);
 		auto resultList = categoryDao->fetchMembers(categoryname, qo);
 		TemplatePage searchPage = this->templ->getPage("show_category");
-		std::string body = this->templ->renderSearch(resultList);
-		searchPage.setVar("pagelist", body);
+		PageListRenderer pagelistrender(*this->templ, *this->urlProvider, *this->database);
+
+		std::string body = pagelistrender.render(resultList, r.get("rendertype"));
+		searchPage.setVar("pagelistcontent", body);
+		searchPage.setVar("pagelistletterlink", this->urlProvider->category(categoryname, PageListRenderer::RENDER_GROUP_BY_LETTER));
+		searchPage.setVar("pagelistcreationdatelink",  this->urlProvider->category(categoryname, PageListRenderer::RENDER_GROUP_BY_CREATIONDATE));
 		searchPage.setVar("categoryname", categoryname);
 		setGeneralVars(searchPage);
 		searchPage.setVar("title", createPageTitle("Category: " + categoryname));

handlers/handlerfactory.cpp

@@ -34,6 +34,7 @@ SOFTWARE.
 #include "handlerpagedelete.h"
 #include "handlerusersettings.h"
 #include "handlerversion.h"
+#include "handlerfeedgenerator.h"
 std::unique_ptr<Handler> HandlerFactory::createHandler(const std::string &action, Session &userSession)
 {
 	if(action == "" || action == "index")
@@ -84,6 +85,10 @@ std::unique_ptr<Handler> HandlerFactory::createHandler(const std::string &action
 	{
 		return produce<HandlerVersion>(userSession);
 	}
+	if(action == "feed")
+	{
+		return produce<HandlerFeedGenerator>(userSession);
+	}
 
 	return produce<HandlerInvalidAction>(userSession);
 }

handlers/handlerfeedgenerator.cpp

@@ -0,0 +1,158 @@
+#include "handlerfeedgenerator.h"
+#include "../revisionrenderer.h"
+std::vector<HandlerFeedGenerator::EntryRevisionPair> HandlerFeedGenerator::fetchEntries(
+	std::vector<std::string> categories)
+{
+	auto revisionDao = this->database->createRevisionDao();
+	auto pageDao = this->database->createPageDao();
+	auto permissionDao = this->database->createPermissionsDao();
+
+	std::vector<EntryRevisionPair> result;
+	QueryOption option;
+	option.includeUnlisted = true;
+	// option.limit = 20;
+
+	auto comppage = [](const Page &a, const Page &b) { return a.name < b.name; };
+	std::set<Page, decltype(comppage)> members(comppage);
+	if(categories.empty())
+	{
+		auto pages = pageDao->getPageList(option);
+		std::copy(pages.begin(), pages.end(), std::inserter(members, members.end()));
+	}
+	else
+	{
+		auto categoryDao = this->database->createCategoryDao();
+		for(std::string cat : categories)
+		{
+			if(!categoryDao->find(cat))
+			{
+				throw std::runtime_error("No such category");
+			}
+			auto catmembers = categoryDao->fetchMembers(cat, option);
+			std::copy(catmembers.begin(), catmembers.end(), std::inserter(members, members.end()));
+		}
+	}
+	for(const Page &member : members)
+	{
+		if(member.feedlisted)
+		{
+			Permissions perms = permissionDao->find(member.name, this->userSession->user.login)
+									.value_or(this->userSession->user.permissions);
+			if(perms.canRead())
+			{
+				auto revision = revisionDao->getRevisionForPage(member.name, 1).value();
+				result.push_back({member, revision});
+			}
+		}
+	}
+	std::sort(result.begin(), result.end(),
+			  [](EntryRevisionPair &a, EntryRevisionPair &b) { return a.second.timestamp > b.second.timestamp; });
+
+	const int maxResults = 20;
+	if(result.size() > maxResults)
+	{
+		result.erase(result.begin() + maxResults - 1, result.end());
+	}
+
+	return result;
+}
+
+std::string HandlerFeedGenerator::generateAtom(const std::vector<HandlerFeedGenerator::EntryRevisionPair> &entries,
+											   std::string filter)
+{
+
+	std::stringstream stream;
+	// don't care about offset for now especially since "%z" does not return what we need exactly (with ':')
+	const std::string dateformat = "%Y-%m-%dT%T";
+
+	time_t newestPublished = 0;
+	std::string atomfooter = this->templ->loadResolvedPart("feeds/atomfooter");
+	auto revisionDao = this->database->createRevisionDao();
+	auto pageDao = this->database->createPageDao();
+
+	std::string subtitle = filter;
+	if(utils::trim(filter).empty())
+	{
+		subtitle = "All pages";
+	}
+
+	RevisionRenderer revisionRenderer{*this->templ, *this->database, *this->urlProvider, *this->userSession};
+
+	for(const EntryRevisionPair &entry : entries)
+	{
+		const Page &page = entry.first;
+		const Revision &initialRevision = entry.second;
+		Revision current = revisionDao->getCurrentForPage(page.name).value();
+		std::string url = this->urlProvider->rootUrl() + this->urlProvider->page(page.name);
+		if(initialRevision.timestamp > newestPublished)
+		{
+			newestPublished = initialRevision.timestamp;
+		}
+		std::string entryPublished = utils::formatLocalDate(initialRevision.timestamp, dateformat) + "Z";
+		std::string entryUpdated = utils::formatLocalDate(current.timestamp, dateformat) + "Z";
+		std::string entryurl =
+			this->urlProvider->combine({this->urlProvider->rootUrl(), this->urlProvider->page(page.name)});
+		TemplatePage atomentry = this->templ->getPage("feeds/atomentry");
+		atomentry.setVar("entrytitle", page.title);
+		atomentry.setVar("entryurl", utils::html_xss(entryurl));
+		atomentry.setVar("entryid", utils::html_xss(entryurl));
+		atomentry.setVar("entrypublished", entryPublished);
+		atomentry.setVar("entryupdated", entryUpdated);
+		atomentry.setVar("entrycontent", utils::html_xss(revisionRenderer.renderContent(current, page.title)));
+		stream << atomentry.render();
+	}
+	stream << atomfooter;
+	TemplatePage atomheader = this->templ->getPage("feeds/atomheader");
+	atomheader.setVar("subtitle", subtitle);
+	std::string selflink = utils::html_xss(this->urlProvider->atomFeed(filter));
+	atomheader.setVar("atomfeeduniqueid", selflink);
+	atomheader.setVar("atomselflink", selflink);
+	atomheader.setVar("atomfeedupdate", utils::formatLocalDate(newestPublished, dateformat) + "Z");
+	return atomheader.render() + stream.str();
+}
+
+Response HandlerFeedGenerator::handleRequest(const Request &r)
+{
+	Response response;
+	try
+	{
+		std::string type = r.get("type");
+		std::string categories = r.get("cats");
+		if(type == "atom")
+		{
+			std::string filter = categories;
+			Response result;
+			result.setStatus(200);
+			result.setContentType("application/atom+xml");
+			std::string cacheKey = "feed:atom:" + filter;
+			auto cached = this->cache->get(cacheKey);
+			if(cached)
+			{
+				result.setBody(cached.value());
+			}
+			else
+			{
+				auto entries = fetchEntries(utils::split(categories, ','));
+				std::string feed = generateAtom(entries, filter);
+				result.setBody(feed);
+				this->cache->put(cacheKey, feed);
+			}
+			response = result;
+		}
+		else
+		{
+			return errorResponse("Invalid feed type", "Unknown feed type, try atom", 400);
+		}
+	}
+	catch(std::runtime_error &e)
+	{
+		Logger::error() << "Error while serving feed: " << e.what();
+		return errorResponse("Error", "An error occured while trying to serve the feed", 500);
+	}
+	return response;
+}
+
+bool HandlerFeedGenerator::canAccess(const Permissions &perms)
+{
+	return true;
+}

handlers/handlerfeedgenerator.h

@@ -0,0 +1,21 @@
+#ifndef HANDLERFEEDGENERATOR_H
+#define HANDLERFEEDGENERATOR_H
+#include "handler.h"
+#include "../page.h"
+#include "../revision.h"
+class HandlerFeedGenerator : public Handler
+{
+	typedef std::pair<Page, Revision> EntryRevisionPair;
+
+  protected:
+	std::vector<EntryRevisionPair> fetchEntries(std::vector<std::string> categories);
+	std::string generateAtom(const std::vector<EntryRevisionPair> &entries, std::string atomtitle);
+	Response generateRss(const std::vector<EntryRevisionPair> &entries);
+
+  public:
+	using Handler::Handler;
+	Response handleRequest(const Request &r) override;
+	bool canAccess(const Permissions &perms) override;
+};
+
+#endif // HANDLERFEEDGENERATOR_H

handlers/handlerpage.cpp

@@ -27,7 +27,18 @@ Response HandlerPage::handle(const Request &r)
 	auto pageDao = this->database->createPageDao();
 	if(pagename.empty())
 	{
-		return errorResponse("No page given", "No page given to request");
+		std::string title = r.get("title");
+		if(title.empty())
+		{
+			return errorResponse("No page given", "No page given to request");
+		}
+		title = utils::strreplace(title, "-", " ");
+		auto page = pageDao->findByTitle(title);
+		if(!page)
+		{
+			return errorResponse("No page by such title", "No page with such title exists");
+		}
+		pagename = page->name;
 	}
 
 	if(pageMustExist() && !pageDao->exists(pagename))

handlers/handlerpagedelete.cpp

@@ -45,6 +45,7 @@ Response HandlerPageDelete::handleRequest(PageDao &pageDao, std::string pagename
 		{
 			pageDao.deletePage(pagename);
 			this->cache->removePrefix("page:"); // TODO: overkill?
+			this->cache->removePrefix("feed:");
 			return Response::redirectTemporarily(this->urlProvider->index());
 		}
 		TemplatePage delPage = this->templ->getPage("page_deletion");

handlers/handlerpageedit.cpp

@@ -23,6 +23,8 @@ SOFTWARE.
 #include "../request.h"
 
 #include "../parser.h"
+#include "../revisionrenderer.h"
+
 bool HandlerPageEdit::canAccess([[maybe_unused]] std::string page)
 {
 	return effectivePermissions(page).canEdit();
@@ -41,7 +43,7 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 		return errorResponse("No permission", "You don't have permission to create new pages");
 	}
 	auto revisiondao = this->database->createRevisionDao();
-	auto revision = this->database->createRevisionDao()->getCurrentForPage(pagename);
+	auto revision = revisiondao->getCurrentForPage(pagename);
 	std::string body;
 
 	unsigned int current_revision = 0;
@@ -50,6 +52,16 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 		body = revision->content;
 		current_revision = revision->revision;
 	}
+	std::string from = r.get("frompage");
+	if(!from.empty())
+	{
+		if(!effectivePermissions(from).canRead())
+		{
+			return this->errorResponse("Permission denied",
+									   "No access permissions, so you can't use this page as a template");
+		}
+		body = revisiondao->getCurrentForPage(from)->content;
+	}
 	if(r.getRequestMethod() == "POST")
 	{
 		if(r.post("do") == "submit")
@@ -64,8 +76,27 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 			try
 			{
 				this->database->beginTransaction();
+
 				std::string visiblecmd = parser.extractCommand("visible", newContent);
+				std::string listedcmd = parser.extractCommand("listed", newContent);
+				/* Backwarts compatibility */
+				if(listedcmd.empty())
+				{
+					listedcmd = visiblecmd;
+				}
+				std::string feedlistedcmd = parser.extractCommand("feedlisted", newContent);
+
 				std::string rename = parser.extractCommand("rename", newContent);
+				std::string customtitle = parser.extractCommand("pagetitle", newContent);
+				std::string parentpage = parser.extractCommand("parentpage", newContent);
+				std::vector<std::string> perms = parser.extractCommands("permissions", newContent);
+
+				if(parentpage != "" && !pageDao.find(parentpage))
+				{
+					return this->errorResponse("Invalid parent",
+											   "Specified parent page " + parentpage + " does not exist");
+				}
+
 				Page page;
 				std::optional<Page> currentPage = pageDao.find(pagename);
 				if(currentPage)
@@ -80,9 +111,52 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 					}
 					pagename = rename;
 				}
+
+				std::vector<std::pair<std::string, Permissions>> collectedPermissions;
+
+				auto permissionDao = this->database->createPermissionsDao();
+				for(const std::string &perm : perms)
+				{
+					auto splitted = utils::split(perm, '|');
+					if(splitted.size() != 2)
+					{
+						return this->errorResponse("Invalid command", "permissions command is misformated");
+					}
+					auto currentPermission = permissionDao->find(pagename, splitted[0]);
+
+					Permissions newPermissions = Permissions{splitted[1]};
+					if(!currentPermission || newPermissions != currentPermission.value())
+					{
+						if(!this->userSession->user.permissions.canSetPagePerms())
+						{
+							this->database->rollbackTransaction();
+							return errorResponse("Permission denied",
+												 "You don't have permission to change permissions. Don't touch the "
+												 "permission commands");
+						}
+					}
+					collectedPermissions.emplace_back(splitted[0], newPermissions);
+				}
+
+				if(this->userSession->user.permissions.canSetPagePerms())
+				{
+					permissionDao->clearForPage(pagename);
+					for(auto &perms : collectedPermissions)
+					{
+						permissionDao->save(pagename, perms.first, perms.second);
+					}
+				}
+
 				page.current_revision = current_revision;
-				page.listed = !(visiblecmd == "0");
+				page.listed = !(listedcmd == "0");
+				page.feedlisted = !(feedlistedcmd == "0");
 				page.name = pagename;
+				page.title = customtitle;
+				page.parentpage = parentpage;
+				if(page.title.empty())
+				{
+					page.title = page.name;
+				}
 				pageDao.save(page);
 
 				Revision newRevision;
@@ -95,9 +169,11 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 				pageDao.setCategories(pagename, cats);
 				this->database->commitTransaction();
 				this->cache->removePrefix("page:"); // TODO: overkill?
+				this->cache->removePrefix("feed:");
 			}
 			catch(const DatabaseException &e)
 			{
+				this->database->rollbackTransaction();
 				Logger::debug() << "Error saving revision: " << e.what();
 				return errorResponse("Database error", "A database error occured while trying to save this revision");
 			}
@@ -108,12 +184,16 @@ Response HandlerPageEdit::handleRequest(PageDao &pageDao, std::string pagename,
 		{
 			std::string newContent = r.post("content");
 			Parser parser;
+			std::string title = parser.extractCommand("pagetitle", newContent);
 			TemplatePage templatePage = this->templ->getPage("page_creation_preview");
 			templatePage.setVar("actionurl", urlProvider->editPage(pagename));
-			templatePage.setVar("preview_content", parser.parse(pageDao, *this->urlProvider, newContent));
+
+			RevisionRenderer revisionRenderer{*this->templ, *this->database, *this->urlProvider, *this->userSession};
+
+			templatePage.setVar("preview_content", revisionRenderer.renderContent(newContent));
 			templatePage.setVar("content", newContent);
 			setPageVars(templatePage, pagename);
-			templatePage.setVar("title", createPageTitle("Preview: " + pagename));
+			templatePage.setVar("title", createPageTitle("Preview: " + title));
 			templatePage.setVar("comment", r.post("comment"));
 			Response response;
 			response.setBody(templatePage.render());

handlers/handlerpageview.cpp

@@ -23,6 +23,11 @@ SOFTWARE.
 #include "../logger.h"
 #include "../parser.h"
 #include "../htmllink.h"
+#include "../dynamic/dynamiccontentpostlist.h"
+#include "../dynamic/dynamiccontentincludepage.h"
+#include "../dynamic/dynamiccontentsetvar.h"
+#include "../dynamic/dynamiccontentgetvar.h"
+#include "../revisionrenderer.h"
 
 bool HandlerPageView::canAccess(std::string page)
 {
@@ -86,19 +91,20 @@ Response HandlerPageView::handleRequest(PageDao &pageDao, std::string pagename,
 
 	std::optional<Revision> revision;
 	std::string templatepartname;
+	auto revisionDao = this->database->createRevisionDao();
 	try
 	{
 		if(revisionid > 0)
 		{
 			if(!effectivePermissions(pagename).canSeePageHistory())
 			{
-				auto current = this->database->createRevisionDao()->getCurrentForPage(pagename);
+				auto current = revisionDao->getCurrentForPage(pagename);
 				if(current && current->revision > revisionid)
 				{
 					return errorResponse("Error", "You are not allowed to view older revisions of this page");
 				}
 			}
-			revision = this->database->createRevisionDao()->getRevisionForPage(pagename, revisionid);
+			revision = revisionDao->getRevisionForPage(pagename, revisionid);
 			if(!revision)
 			{
 				return errorResponse("Revision not found", "No such revision found");
@@ -118,7 +124,7 @@ Response HandlerPageView::handleRequest(PageDao &pageDao, std::string pagename,
 					return r;
 				}
 			}
-			revision = this->database->createRevisionDao()->getCurrentForPage(pagename);
+			revision = revisionDao->getCurrentForPage(pagename);
 			templatepartname = "page_view";
 		}
 	}
@@ -128,52 +134,30 @@ Response HandlerPageView::handleRequest(PageDao &pageDao, std::string pagename,
 		return errorResponse("Database error", "While trying to fetch revision, a database error occured");
 	}
 
-	TemplatePage page = this->templ->getPage(templatepartname);
-
 	Parser parser;
 	Response result;
 	result.setStatus(200);
-	std::string indexcontent;
-	std::string parsedcontent;
 
-	if(revisionid > 0)
-	{
-		indexcontent = createIndexContent(parser, revision->content);
-		parsedcontent = parser.parse(pageDao, *this->urlProvider, revision->content);
-	}
-	else
-	{
-		std::string cachekeyindexcontent = "page:indexcontent:" + pagename;
-		std::string cachekeyparsedcontent = "page:parsedcontent:" + pagename;
-		auto cachedindexcontent = this->cache->get(cachekeyindexcontent);
-		auto cachedparsedcontent = this->cache->get(cachekeyparsedcontent);
-		if(cachedindexcontent)
-		{
-			indexcontent = *cachedindexcontent;
-		}
-		else
-		{
-			indexcontent = createIndexContent(parser, revision->content);
-			this->cache->put(cachekeyindexcontent, indexcontent);
-		}
-		if(cachedparsedcontent)
-		{
-			parsedcontent = *cachedparsedcontent;
-		}
-		else
-		{
-			parsedcontent = parser.parse(pageDao, *this->urlProvider, revision->content);
-			this->cache->put(cachekeyparsedcontent, parsedcontent);
-		}
-	}
+	RevisionRenderer revisionRenderer{*this->templ, *this->database, *this->urlProvider, *this->userSession};
+
+	std::string customtitle = parser.extractCommand("pagetitle", revision->content);
+	std::string parsedcontent = revisionRenderer.renderContent(revision.value(), customtitle);
+	/* TODO: Dynamic includes not considered, probably fine in practise */
+	std::string indexcontent = createIndexContent(parser, revision->content);
+
 	std::string revisionstr = std::to_string(revision->revision);
+	TemplatePage page = this->templ->getPage(templatepartname);
 	page.setVar("content", parsedcontent);
 	page.setVar("index", indexcontent);
 	page.setVar("editedby", revision->author);
-	page.setVar("editedon", utils::toISODate(revision->timestamp));
+	page.setVar("editedon", utils::toISODateTime(revision->timestamp));
 	page.setVar("historyurl", this->urlProvider->pageHistory(pagename));
 	page.setVar("revision", revisionstr);
 	setPageVars(page, pagename);
+	if(!customtitle.empty())
+	{
+		page.setVar("title", createPageTitle(customtitle));
+	}
 	std::string body = page.render();
 	if(revisionid == 0 && !this->userSession->loggedIn)
 	{

handlers/handlersearch.cpp

@@ -25,7 +25,11 @@ Response HandlerSearch::handleRequest(const Request &r)
 	std::string q = r.get("q");
 	if(q.empty())
 	{
-		return errorResponse("Missing search term", "No search term supplied");
+		TemplatePage searchForm = this->templ->getPage("searchform");
+		response.setBody(searchForm.render());
+		response.setStatus(200);
+		setGeneralVars(searchForm);
+		return response;
 	}
 
 	auto pageDao = this->database->createPageDao();

iparser.h

@@ -2,16 +2,35 @@
 #define IPARSER_H
 #include <vector>
 #include <string_view>
+#include <functional>
 #include "headline.h"
 #include "database/pagedao.h"
 #include "urlprovider.h"
 class IParser
 {
+  protected:
+	static std::string empty(std::string_view key, std::string_view content)
+	{
+		return "";
+	}
+
   public:
-	virtual std::string extractCommand(std::string cmdname, std::string content) const = 0;
-	virtual std::vector<Headline> extractHeadlines(std::string content) const = 0;
-	virtual std::string parse(const PageDao &pagedao, UrlProvider &provider, std::string content) const = 0;
-	virtual std::vector<std::string> extractCategories(std::string content) const = 0;
+	virtual std::string extractFirstTag(std::string tagname, const std::string &content) const = 0;
+	virtual std::string extractCommand(std::string cmdname, const std::string &content) const = 0;
+	virtual std::vector<std::string> extractCommands(std::string cmdname, const std::string &content) const = 0;
+
+	virtual std::vector<Headline> extractHeadlines(const std::string &content) const = 0;
+	virtual inline std::string parse(const PageDao &pagedao, UrlProvider &provider, const std::string &content) const
+	{
+		return parse(pagedao, provider, content, empty);
+	}
+	virtual std::string parse(const PageDao &pagedao, UrlProvider &provider, const std::string &content,
+							  const std::function<std::string(std::string_view, std::string_view)> &callback) const = 0;
+
+	virtual std::string parseDynamics(
+		const std::string &content,
+		const std::function<std::string(std::string_view, std::string_view)> &callback) const = 0;
+	virtual std::vector<std::string> extractCategories(const std::string &content) const = 0;
 
 	virtual ~IParser(){};
 };

logger.h

@@ -7,8 +7,8 @@ class Logger
   private:
 	class LogEntry
 	{
-		bool headerSent;
-		std::ostream *out;
+		bool headerSent = false;
+		std::ostream *out = nullptr;
 		std::string prefix;
 
 	  public:

page.h

@@ -7,7 +7,10 @@ class Page
   public:
 	Page();
 	std::string name;
+	std::string title;
+	std::string parentpage;
 	bool listed;
+	bool feedlisted;
 	unsigned int current_revision;
 	unsigned int pageid;
 };

pagelistrenderer.cpp

@@ -0,0 +1,66 @@
+#include "pagelistrenderer.h"
+#include "grouper.h"
+
+PageListRenderer::PageListRenderer(Template &templ, UrlProvider &provider, Database &database)
+{
+	this->templ = &templ;
+	this->urlProvider = &provider;
+	this->database = &database;
+}
+
+std::string PageListRenderer::render(const std::vector<Page> &pagelist, std::string type) const
+{
+	TemplatePage pagelistrendergroup = this->templ->loadResolvedPart("pagelistrender_group");
+	TemplatePage pagelistlink = this->templ->loadResolvedPart("pagelistrender_link");
+
+
+	std::function<bool(const std::string &, const std::string &)> lesser = [](const std::string &a, const std::string &b) -> bool {
+		return a < b;
+	};
+
+	std::function<bool(const std::string &, const std::string &)> greater = [](const std::string &a, const std::string &b) -> bool {
+		return a > b;
+	};
+
+	using Grouper = Grouper<std::string, Page, std::function<bool(const std::string &,const std::string &)>>;
+
+	Grouper grouper = (type == "letter") ? Grouper(lesser) : Grouper(greater);
+	if(type == "letter")
+	{
+		auto az = [&](const Page &p) -> std::string {
+			int upper = toupper(p.title[0]); // TODO: this is not unicode safe.
+			return { (char)upper };
+		};
+		grouper.group(az, pagelist);
+	}
+	else
+	{
+		auto revisionDao = this->database->createRevisionDao();
+		auto creationdate = [&revisionDao](const Page &p) -> std::string {
+			return utils::formatLocalDate(revisionDao->getRevisionForPage(p.name, 1).value().timestamp, "%Y-%m");
+		};
+		grouper.group(creationdate, pagelist);
+	}
+
+	std::stringstream stream;
+	std::string lastGroup = "";
+
+	for(auto &entry : grouper.getResults())
+	{
+		std::string groupname = entry.first;
+		const std::vector<const Page*> &pages = entry.second;
+		if(lastGroup != groupname)
+		{
+			lastGroup = groupname;
+			pagelistrendergroup.setVar("groupname", groupname);
+			stream << pagelistrendergroup.render();
+		}
+		for(const Page *p : pages)
+		{
+			pagelistlink.setVar("inner", p->title);
+			pagelistlink.setVar("href", this->urlProvider->page(p->name));
+			stream << pagelistlink.render();
+		}
+	}
+	return stream.str();
+}

pagelistrenderer.h

@@ -0,0 +1,27 @@
+#ifndef PAGELISTRENDERER_H
+#define PAGELISTRENDERER_H
+#include "utils.h"
+#include "page.h"
+#include "template.h"
+#include "htmllink.h"
+#include "urlprovider.h"
+#include "database/database.h"
+
+class PageListRenderer
+{
+private:
+	Template *templ;
+	UrlProvider *urlProvider;
+	Database *database;
+
+public:
+	PageListRenderer(Template &templ, UrlProvider &provider, Database &database);
+
+	std::string render(const std::vector<Page> &pages, std::string type) const;
+
+	inline static const std::string RENDER_GROUP_BY_LETTER { "letter" };
+	inline static const std::string RENDER_GROUP_BY_CREATIONDATE { "creationdate" };
+
+
+};
+#endif

parser.cpp

@@ -27,10 +27,11 @@ SOFTWARE.
 #include "parser.h"
 #include "utils.h"
 #include "htmllink.h"
-std::vector<Headline> Parser::extractHeadlines(std::string content) const
+std::vector<Headline> Parser::extractHeadlines(const std::string &content) const
 {
 	std::vector<Headline> result;
-	std::string reg = R"(\[h(1|2|3)\](.*?)\[/h\1\])";
+
+	std::string reg = R"(\[h(1|2|3)\](\[.*?\])*(.*?)(\[.*?\])*\[\/h\1\])";
 	std::regex headerfinder(reg);
 	auto begin = std::sregex_iterator(content.begin(), content.end(), headerfinder);
 	auto end = std::sregex_iterator();
@@ -40,13 +41,13 @@ std::vector<Headline> Parser::extractHeadlines(std::string content) const
 		auto smatch = *it;
 		Headline h;
 		h.level = utils::toUInt(smatch.str(1));
-		h.title = smatch.str(2);
+		h.title = smatch.str(3);
 		result.push_back(h);
 	}
 	return result;
 }
 
-std::vector<std::string> Parser::extractCategories(std::string content) const
+std::vector<std::string> Parser::extractCategories(const std::string &content) const
 {
 	std::vector<std::string> result;
 	std::string reg = R"(\[category\](.*?)\[/category\])";
@@ -62,11 +63,10 @@ std::vector<std::string> Parser::extractCategories(std::string content) const
 	return result;
 }
 
-std::string Parser::extractCommand(std::string cmdname, std::string content) const
+std::string Parser::extractFirstTag(std::string tagname, const std::string &content) const
 {
-	std::string cmd = "[cmd:" + cmdname + "]";
-	std::string cmdend = "[/cmd:" + cmdname + "]";
-
+	std::string cmd = "[" + tagname + "]";
+	std::string cmdend = "[/" + tagname + "]";
 	std::string_view view = content;
 	size_t pos = 0;
 	if((pos = view.find(cmd)) != std::string::npos)
@@ -81,6 +81,34 @@ std::string Parser::extractCommand(std::string cmdname, std::string content) con
 	}
 	return "";
 }
+
+std::string Parser::extractCommand(std::string cmdname, const std::string &content) const
+{
+
+	return extractFirstTag("cmd:" + cmdname, content);
+}
+
+std::vector<std::string> Parser::extractCommands(std::string cmdname, const std::string &content) const
+{
+	std::vector<std::string> result;
+
+	std::string cmd = "[cmd:" + cmdname + "]";
+	std::string cmdend = "[/cmd:" + cmdname + "]";
+
+	std::string_view view = content;
+	size_t pos = 0;
+	while((pos = view.find(cmd)) != std::string::npos)
+	{
+		view.remove_prefix(pos);
+		view.remove_prefix(cmd.size());
+		if((pos = view.find(cmdend)) != std::string::npos)
+		{
+			result.emplace_back(view.substr(0, pos));
+		}
+	}
+	return result;
+}
+
 std::string Parser::processLink(const PageDao &pageDao, UrlProvider &urlProvider, std::smatch &match) const
 {
 	std::string linktag = match.str(1);
@@ -116,31 +144,86 @@ std::string Parser::processLink(const PageDao &pageDao, UrlProvider &urlProvider
 	return htmllink.render();
 }
 
-std::string Parser::parse(const PageDao &pagedao, UrlProvider &provider, std::string content) const
+std::string Parser::processImage(std::smatch &match) const
+{
+	std::string tag = match.str(1);
+	std::string inside = match.str(2);
+	std::vector<std::string> splitted = utils::split(inside, '|');
+	std::string width;
+	std::string height;
+	std::string src;
+	if(splitted.size() == 3)
+	{
+		width = splitted[0];
+		height = splitted[1];
+		src = splitted[2];
+	}
+	else
+	{
+		src = splitted[0];
+	}
+	if(!width.empty() && !height.empty())
+	{
+		return "<img src=\"" + src + "\" width=\"" + width + "\" height=\"" + height + "\"/>";
+	}
+	return "<img src=\"" + src + "\"/>";
+}
+
+std::string Parser::parse(const PageDao &pagedao, UrlProvider &provider, const std::string &content,
+						  const std::function<std::string(std::string_view, std::string_view)> &callback) const
 {
 	std::string result;
 	// we don't care about commands, but we nevertheless replace them with empty strings
-	std::regex tagfinder(R"(\[(b|i|u|li||ul|ol|link|wikilink|h\d|cmd:rename|cmd:redirect|category)*?\]((\s|\S)*?)\[/\1])");
-	result = utils::regex_callback_replacer(tagfinder, content, [&](std::smatch &match) {
-		std::string tag = match.str(1);
-		std::string content = match.str(2);
-		std::string justreplace[] = {"b", "i", "u", "ul", "li", "ol"};
-		content = parse(pagedao, provider, content);
-		if(std::find(std::begin(justreplace), std::end(justreplace), tag) != std::end(justreplace))
+	std::regex tagfinder(
+		R"(\[(b|i|u|s|li||ul|ol|code|blockquote|img|link|wikilink|h\d|cmd:visible|cmd:listed|cmd:feedlisted|cmd:rename|cmd:redirect|cmd:pagetitle|cmd:allowinclude|cmd:permissions|cmd:parentpage|content|category|dynamic:postlist|dynamic:includepage|dynamic:getvar|dynamic:setvar)*?\]((\s|\S)*?)\[/\1])");
+	result = utils::regex_callback_replacer(
+		tagfinder, content,
+		[&](std::smatch &match)
 		{
-			return "<" + tag + ">" + content + "</" + tag + ">";
-		}
-		if(tag == "link" || tag == "wikilink")
-		{
-			return this->processLink(pagedao, provider,
-									 match); // TODO: recreate this so we don't check inside the function stuff again
-		}
-		if(tag[0] == 'h')
-		{
-			return "<" + tag + " id='" + content + "'>" + content + "</" + tag + ">";
-		}
-		return std::string("");
-	});
+			std::string tag = match.str(1);
+			std::string content = match.str(2);
+			std::string justreplace[] = {"b", "i", "u", "ul", "li", "ol", "s"};
+			if(tag != "code" && tag != "blockquote")
+			{
+				content = parse(pagedao, provider, content, callback);
+			}
+			/* [content] just helps extracting the actual content of a page, pretty much noop otherwise */
+			if(tag == "content")
+			{
+				return parse(pagedao, provider, content, callback);
+			}
+			if(std::find(std::begin(justreplace), std::end(justreplace), tag) != std::end(justreplace))
+			{
+				return "<" + tag + ">" + content + "</" + tag + ">";
+			}
+			if(tag == "link" || tag == "wikilink")
+			{
+				return this->processLink(
+					pagedao, provider,
+					match); // TODO: recreate this so we don't check inside the function stuff again
+			}
+			if(tag == "img")
+			{
+				return this->processImage(match);
+			}
+			if(tag[0] == 'h')
+			{
+				return "<" + tag + " id='" + content + "'>" + content + "</" + tag + ">";
+			}
+			if(tag == "code" || tag == "blockquote")
+			{
+				return "<pre><" + tag + ">" + utils::strreplace(content, "\r\n", "\n") + "</" + tag + "></pre>";
+			}
+			return callback(tag, content);
+		});
 	result = utils::strreplace(result, "\r\n", "<br>");
 	return result;
 }
+
+std::string Parser::parseDynamics(const std::string &content,
+								  const std::function<std::string(std::string_view, std::string_view)> &callback) const
+{
+	std::regex tagfinder(R"(\[(dynamic:\w+)*?\]((\s|\S)*?)\[/\1])");
+	return utils::regex_callback_replacer(tagfinder, content,
+										  [&](std::smatch &match) { return callback(match.str(1), match.str(2)); });
+}

parser.h

@@ -6,14 +6,23 @@ class Parser : public IParser
 {
   private:
 	std::string processLink(const PageDao &pageDao, UrlProvider &urlProvider, std::smatch &match) const;
+	std::string processImage(std::smatch &match) const;
 
   public:
-	std::string extractCommand(std::string cmdname, std::string content) const;
-	std::vector<Headline> extractHeadlines(std::string content) const override;
-	std::vector<std::string> extractCategories(std::string content) const override;
-	std::string parse(const PageDao &pagedao, UrlProvider &provider, std::string content) const override;
+	std::string extractFirstTag(std::string tagname, const std::string &content) const override;
+	std::string extractCommand(std::string cmdname, const std::string &content) const override;
+	std::vector<std::string> extractCommands(std::string cmdname, const std::string &content) const override;
+	std::vector<Headline> extractHeadlines(const std::string &content) const override;
+	std::vector<std::string> extractCategories(const std::string &content) const override;
+	using IParser::parse;
+	virtual std::string parse(
+		const PageDao &pagedao, UrlProvider &provider, const std::string &content,
+		const std::function<std::string(std::string_view, std::string_view)> &callback) const override;
+	std::string parseDynamics(
+		const std::string &content,
+		const std::function<std::string(std::string_view, std::string_view)> &callback) const override;
+
 	using IParser::IParser;
-	~Parser(){};
 };
 
 #endif // PARSER_H

permissions.cpp

@@ -20,7 +20,8 @@ SOFTWARE.
 */
 #include "permissions.h"
 
-static const std::map<std::string, int> permmap = {{"can_read", PERM_CAN_READ},
+static const std::map<std::string, int> permmap = {{"can_nothing", PERM_CAN_NOTHING},
+												   {"can_read", PERM_CAN_READ},
 												   {"can_edit", PERM_CAN_EDIT},
 												   {"can_page_history", PERM_CAN_PAGE_HISTORY},
 												   {"can_global_history", PERM_CAN_GLOBAL_HISTORY},
@@ -29,7 +30,8 @@ static const std::map<std::string, int> permmap = {{"can_read", PERM_CAN_READ},
 												   {"can_create", PERM_CAN_CREATE},
 												   {"can_see_category_list", PERM_CAN_SEE_CATEGORY_LIST},
 												   {"can_see_links_here", PERM_CAN_SEE_LINKS_HERE},
-												   {"can_search", PERM_CAN_SEARCH}};
+												   {"can_search", PERM_CAN_SEARCH},
+												   {"can_set_page_perms", PERM_CAN_SET_PAGE_PERMS}};
 
 Permissions::Permissions(int permissions)
 {

permissions.h

@@ -1,6 +1,7 @@
 #ifndef PERMISSIONS_H
 #define PERMISSIONS_H
 
+#define PERM_CAN_NOTHING 0
 #define PERM_CAN_READ 1 << 0
 #define PERM_CAN_EDIT 1 << 1
 #define PERM_CAN_PAGE_HISTORY 1 << 2
@@ -11,6 +12,8 @@
 #define PERM_CAN_SEE_CATEGORY_LIST 1 << 7
 #define PERM_CAN_SEE_LINKS_HERE 1 << 8
 #define PERM_CAN_SEARCH 1 << 9
+#define PERM_CAN_SET_PAGE_PERMS 1 << 10
+#define PERM_IS_ADMIN (1L<<31)-1
 
 #include <string>
 #include <map>
@@ -54,10 +57,16 @@ class Permissions
 		return this->permissions;
 	}
 
+	bool canNothing() const
+	{
+		return this->permissions == PERM_CAN_NOTHING;
+	}
+
 	bool canRead() const
 	{
 		return this->permissions & PERM_CAN_READ;
 	}
+
 	bool canEdit() const
 	{
 		return this->permissions & PERM_CAN_EDIT;
@@ -95,12 +104,27 @@ class Permissions
 		return this->permissions & PERM_CAN_SEE_PAGE_LIST;
 	}
 
+	bool canSetPagePerms() const
+	{
+		return this->permissions & PERM_CAN_SET_PAGE_PERMS;
+	}
+
+	bool isAdmin() const
+	{
+		return this->permissions == PERM_IS_ADMIN;
+	}
+
 	std::string toString() const
 	{
 		return Permissions::toString(this->permissions);
 	}
 
 	static std::string toString(int perms);
+
+	bool operator==(const Permissions &o) const
+	{
+		return this->permissions == o.permissions;
+	}
 };
 
 #endif // PERMISSIONS_H

qswiki.cpp

@@ -31,12 +31,13 @@ SOFTWARE.
 #include "handlers/handlerfactory.h"
 #include "database/databasefactory.h"
 #include "config.h"
-#include "template.h"
 #include "session.h"
+#include "template.h"
 #include "logger.h"
 #include "urlprovider.h"
 #include "requestworker.h"
 #include "cache/fscache.h"
+#include "cache/nocache.h"
 #include "sandbox/sandboxfactory.h"
 #include "cli.h"
 #include "cliconsole.h"
@@ -68,12 +69,41 @@ static struct option long_options[] = {{"cli", no_argument, 0, 'c'}, {"version",
 
 std::unique_ptr<ICache> createCache(const ConfigVariableResolver &resolver)
 {
-
 	std::string path = resolver.getConfig("cache_fs_dir");
-
+	if(path == "")
+	{
+		return std::make_unique<NoCache>(path);
+	}
 	return std::make_unique<FsCache>(path);
 }
 
+std::thread background_worker;
+void start_background_worker(Database &database, Config &config)
+{
+	background_worker = std::thread(
+		[&database, &config]()
+		{
+			while(true)
+			{
+				Logger::log() << "Executing background worker";
+
+				auto sessionDao = database.createSessionDao();
+				auto sessionList = sessionDao->fetch();
+				time_t now = time(NULL);
+
+				for(Session &sess : sessionList)
+				{
+					if(now - sess.creation_time > config.session_max_lifetime)
+					{
+						sessionDao->deleteSession(sess.token);
+					}
+				}
+
+				std::this_thread::sleep_for(std::chrono::hours(1));
+			}
+		});
+}
+
 int main(int argc, char **argv)
 {
 
@@ -136,6 +166,7 @@ int main(int argc, char **argv)
 		Logger::setStream(&logstream);
 
 		auto database = createDatabase(config);
+
 		std::string socketPath = config.configVarResolver.getConfig("socketpath");
 		CLIHandler cliHandler(config, *database);
 
@@ -158,6 +189,8 @@ int main(int argc, char **argv)
 			exit(EXIT_FAILURE);
 		}
 
+		start_background_worker(*database.get(), config);
+
 		CLIServer cliServer{cliHandler};
 		if(!cliServer.detachServer(socketPath))
 		{

request.cpp

@@ -40,7 +40,7 @@ std::pair<std::string, std::string> Request::createPairFromVar(std::string var)
 	else
 	{
 		std::string key = var.substr(0, equal);
-		std::string val = utils::html_xss(var.substr(equal + 1));
+		std::string val = utils::html_xss(utils::urldecode(var.substr(equal + 1)));
 		return std::make_pair(std::move(key), std::move(val));
 	}
 }
@@ -75,7 +75,7 @@ void Request::initPostMap(const std::string &url)
 void Request::initCookies(const std::string &cookiestr)
 {
 	// TODO: find out what it really should be, ";" or "; "?
-	std::regex regex { ";+\\s?" };
+	std::regex regex{";+\\s?"};
 	auto cookiesplitted = utils::split(cookiestr, regex);
 	for(const std::string &part : cookiesplitted)
 	{

revisionrenderer.cpp

@@ -0,0 +1,78 @@
+#include "revisionrenderer.h"
+#include "templatepage.h"
+#include "dynamic/dynamiccontentpostlist.h"
+#include "dynamic/dynamiccontentincludepage.h"
+#include "dynamic/dynamiccontentgetvar.h"
+#include "dynamic/dynamiccontentsetvar.h"
+#include "dynamic/dynamicpostrenderer.h"
+#include "parser.h"
+#include "htmllink.h"
+
+std::string RevisionRenderer::dynamicCallback(std::string_view key, std::string_view value)
+{
+	if(key == "dynamic:postlist")
+	{
+		auto postlist = this->dynamicContentFactory.createDynamicContent<DynamicContentPostList>();
+		postlist->setArgument(std::string(value));
+		return postlist->render();
+	}
+	if(key == "dynamic:includepage")
+	{
+		auto includePage = this->dynamicContentFactory.createDynamicContent<DynamicContentIncludePage>();
+		includePage->setArgument(std::string(value));
+		return parser.parseDynamics(includePage->render(), std::bind(&RevisionRenderer::dynamicCallback, this,
+																	 std::placeholders::_1, std::placeholders::_2));
+	}
+	if(key == "dynamic:setvar")
+	{
+		auto setVar = this->dynamicContentFactory.createDynamicContent<DynamicContentSetVar>();
+		setVar->setMap(dynamicVarsMap);
+		setVar->setArgument(std::string(value));
+		return setVar->render();
+	}
+	if(key == "dynamic:getvar")
+	{
+		auto getVar = this->dynamicContentFactory.createDynamicContent<DynamicContentGetVar>();
+		getVar->setMap(dynamicVarsMap);
+		getVar->setArgument(std::string(value));
+		return getVar->render();
+	}
+	if(key == "dynamic:postrenderer")
+	{
+		auto renderer = this->dynamicContentFactory.createDynamicContent<DynamicPostRenderer>();
+		renderer->setArgument(std::string(value));
+		return renderer->render();
+	}
+	return std::string{};
+}
+
+std::string RevisionRenderer::renderContent(std::string content)
+{
+	dynamicVarsMap["pagetitle"] = parser.extractCommand("pagetitle", content);
+	dynamicVarsMap["createdon"] = utils::toISODate(time(NULL));
+	dynamicVarsMap["modifydatetime"] = utils::toISODateTime(time(NULL));
+
+	std::string resolvedContent = parser.parseDynamics(
+		content, std::bind(&RevisionRenderer::dynamicCallback, this, std::placeholders::_1, std::placeholders::_2));
+
+	return parser.parse(*this->db->createPageDao(), *this->urlProvider, resolvedContent);
+}
+
+std::string RevisionRenderer::renderContent(const Revision &r, std::string_view customTitle)
+{
+	auto revisionDao = this->db->createRevisionDao();
+	auto firstRevision = revisionDao->getRevisionForPage(r.page, 1);
+	if(!firstRevision)
+	{
+		throw std::runtime_error("Could not get first revision for page, which is odd. Solar flares?");
+	}
+
+	dynamicVarsMap["createdon"] = utils::toISODate(firstRevision.value().timestamp);
+	dynamicVarsMap["pagetitle"] = customTitle;
+	dynamicVarsMap["modifydatetime"] = utils::toISODateTime(r.timestamp);
+
+	std::string resolvedContent = parser.parseDynamics(
+		r.content, std::bind(&RevisionRenderer::dynamicCallback, this, std::placeholders::_1, std::placeholders::_2));
+
+	return parser.parse(*this->db->createPageDao(), *this->urlProvider, resolvedContent);
+}

revisionrenderer.h

@@ -0,0 +1,29 @@
+#ifndef REVISIONRENDERER_H
+#define REVISIONRENDERER_H
+#include "revision.h"
+#include "templatepage.h"
+#include "dynamic/dynamiccontentfactory.h"
+#include "iparser.h"
+#include "parser.h"
+class RevisionRenderer
+{
+private:
+	DynamicContentFactory dynamicContentFactory;
+	Database *db;
+	UrlProvider *urlProvider;
+	std::map<std::string, std::string> dynamicVarsMap;
+	
+	std::string dynamicCallback(std::string_view key, std::string_view value);
+	Parser parser;
+	
+public:
+	RevisionRenderer(Template &templ, Database &db, UrlProvider &urlProvider, Session &session) :dynamicContentFactory(templ, db, urlProvider, session)
+	{
+		this->db = &db;
+		this->urlProvider = &urlProvider;
+	}
+	std::string renderContent(std::string content);
+	std::string renderContent(const Revision &r, std::string_view customTitle);
+};
+
+#endif // REVISIONRENDERER_H

sandbox/sandbox-linux.cpp

@@ -12,17 +12,13 @@
 #include <filesystem>
 #include <sys/mount.h>
 #include <sys/capability.h>
-#include <qssb.h>
+#include <exile.hpp>
 #include "../logger.h"
 #include "../utils.h"
 #include "../random.h"
 
 #include "sandbox-linux.h"
 
-/* TODO: make a whitelist approach. So far we simply blacklist
- * obvious systemcalls. To whitelist, we need to analyse our
- * dependencies (http library, sqlite wrapper, sqlite lib etc.) */
-
 bool SandboxLinux::supported()
 {
 	std::fstream stream;
@@ -45,7 +41,7 @@ bool SandboxLinux::enable(std::vector<std::string> fsPaths)
 	std::sort(fsPaths.begin(), fsPaths.end(),
 			  [](const std::string &a, const std::string &b) { return a.length() < b.length(); });
 
-	struct qssb_policy *policy = qssb_init_policy();
+	struct exile_policy *policy = exile_init_policy();
 	if(policy == NULL)
 	{
 		Logger::error() << "Failed to init sandboxing policy (worker) ";
@@ -53,30 +49,19 @@ bool SandboxLinux::enable(std::vector<std::string> fsPaths)
 	}
 	for(unsigned int i = 0; i < fsPaths.size(); i++)
 	{
-		qssb_append_path_policy(policy, QSSB_FS_ALLOW_READ | QSSB_FS_ALLOW_WRITE, fsPaths[i].c_str());
+		exile_append_path_policies(policy, EXILE_FS_ALLOW_ALL_READ | EXILE_FS_ALLOW_ALL_WRITE, fsPaths[i].c_str());
 	}
 	policy->drop_caps = 1;
 	policy->not_dumpable = 1;
 	policy->no_new_privs = 1;
 	policy->mount_path_policies_to_chroot = 1;
-	/* TODO: as said, a whitelist approach is better. As such, this list is bound to be incomplete in the
-	 * sense that more could be listed here and some critical ones are probably missing */
-
-	/* TODO: use qssb groups */
-	long blacklisted_syscalls[] = {QSSB_SYS(setuid),	  QSSB_SYS(connect), QSSB_SYS(chroot),	 QSSB_SYS(pivot_root),
-								   QSSB_SYS(mount),		  QSSB_SYS(setns),	 QSSB_SYS(unshare),	 QSSB_SYS(ptrace),
-								   QSSB_SYS(personality), QSSB_SYS(prctl),	 QSSB_SYS(execveat), QSSB_SYS(execve),
-								   QSSB_SYS(fork)};
-	qssb_append_syscalls_policy(policy, QSSB_SYSCALL_DENY_KILL_PROCESS, blacklisted_syscalls,
-								sizeof(blacklisted_syscalls) / sizeof(blacklisted_syscalls[0]));
-	qssb_append_syscall_default_policy(policy, QSSB_SYSCALL_ALLOW);
-
-	if(qssb_enable_policy(policy) != 0)
+	policy->vow_promises = exile_vows_from_str("stdio wpath cpath rpath inet unix thread");
+	if(exile_enable_policy(policy) != 0)
 	{
-		Logger::error() << "Sandbox: Activation of seccomp blacklist failed!";
-		qssb_free_policy(policy);
+		Logger::error() << "Sandbox: Activation of exile failed!";
+		exile_free_policy(policy);
 		return false;
 	}
-	qssb_free_policy(policy);
+	exile_free_policy(policy);
 	return true;
 }

setup/sqlite.sql

@@ -1,4 +1,4 @@
-CREATE TABLE page(id INTEGER PRIMARY KEY, name varchar(256), lastrevision integer, visible integer DEFAULT 1);
+CREATE TABLE page(id INTEGER PRIMARY KEY, name varchar(256), title varchar(1024), lastrevision integer, listed integer DEFAULT 1, parent integer REFERENCES page(id), feedlisted integer DEFAULT 1);
 CREATE TABLE user(id INTEGER PRIMARY KEY,username varchar(64), 
 password blob, salt blob, permissions integer, enabled integer DEFAULT 1);
 CREATE TABLE session(id INTEGER PRIMARY KEY, csrf_token varchar(32), 

submodules/cpp-httplib

@@ -1 +1 @@
-Subproject commit 4f8fcdbaf7696a17c407cdd498819a7c7200c73b
+Subproject commit c7ed1796a778592ae5a122287a16b1dd4770858a

submodules/exile.h

@@ -0,0 +1 @@
+Subproject commit e711a1d53a9210f8f562f774901e5e044d20e67a

submodules/qssb.h

@@ -1 +0,0 @@
-Subproject commit 0d7c5bd6d437ae95a4900aab6b7b6cc207acbd1b

template.cpp

@@ -18,6 +18,7 @@ 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.
 */
+#include <filesystem>
 #include "template.h"
 #include "varreplacer.h"
 #include "urlprovider.h"
@@ -47,9 +48,15 @@ TemplatePage Template::getPage(const std::string &pagename)
 
 std::string Template::getPartPath(std::string_view partname)
 {
-	// TODO: utils::concatPath? C++17 paths?
-	return this->templatepath + "/" + std::string(partname);
+	auto absolute_path = std::filesystem::canonical(std::filesystem::path{this->templatepath} / partname);
+	std::string result = absolute_path.string();
+	if(result.starts_with(this->templatepath))
+	{
+		return result;
+	}
+	return "";
 }
+
 std::string Template::loadPartContent(std::string_view partname)
 {
 	std::string partpath = getPartPath(partname);
@@ -141,7 +148,7 @@ std::string Template::renderRevisionList(const std::vector<Revision> &revisions,
 				   << revision.revision << "</a></td>"
 				   << "<td>" << revision.author << "</td>"
 				   << "<td>" << revision.comment << "</td>"
-				   << "<td>" << utils::toISODate(revision.timestamp) << "</td></tr>";
+				   << "<td>" << utils::toISODateTime(revision.timestamp) << "</td></tr>";
 		}
 	};
 
@@ -155,7 +162,7 @@ std::string Template::renderRevisionList(const std::vector<Revision> &revisions,
 				   << "<td>" << revision.revision << "</td>"
 				   << "<td>" << revision.author << "</td>"
 				   << "<td>" << revision.comment << "</td>"
-				   << "<td>" << utils::toISODate(revision.timestamp) << "</td></tr>";
+				   << "<td>" << utils::toISODateTime(revision.timestamp) << "</td></tr>";
 		}
 	};
 

template.h

@@ -22,7 +22,6 @@ class Template
 	std::string resolveIncludes(std::string_view content);
 
 	std::string getPartPath(std::string_view partname);
-	std::string loadResolvedPart(std::string_view partname);
 	std::string loadPartContent(std::string_view partname);
 	TemplatePage createPage(std::string_view name);
 
@@ -31,6 +30,7 @@ class Template
 			 ConfigVariableResolver &configVarsResolver, MapCache<TemplatePage> &pageCache);
 
 	TemplatePage getPage(const std::string &pagename);
+	std::string loadResolvedPart(std::string_view partname);
 
 	std::string renderSearch(const std::vector<std::string> &results,
 							 std::function<std::string(std::string)> callback) const;

template/quitesimple/allpages

@@ -1,6 +1,6 @@
 {qswiki:include:general_header}
 <div id="content" style="margin-top: 10px;">
 <h2>All pages</h2>
-{qswiki:var:pagelist}
+{qswiki:include:pagelistrender}
 </div>
-{qswiki:include:general_footer}
+{qswiki:include:general_footer}

template/quitesimple/dynamic/postlistbegin

@@ -0,0 +1 @@
+<ul>

template/quitesimple/dynamic/postlistend

@@ -0,0 +1 @@
+</ul>

template/quitesimple/dynamic/postlistlink

@@ -0,0 +1 @@
+<li>{date}: <a href="{url}">{title}</a></li>

template/quitesimple/feeds/atomentry

@@ -0,0 +1,8 @@
+<entry>
+    <title>{qswiki:var:entrytitle}</title>
+    <link href="{qswiki:var:entryurl}"/>
+    <id>{qswiki:var:entryid}</id>
+    <published>{qswiki:var:entrypublished}</published>
+    <updated>{qswiki:var:entryupdated}</updated>
+    <content type="html">{qswiki:var:entrycontent}</content>
+</entry>

template/quitesimple/feeds/atomfooter

@@ -0,0 +1 @@
+</feed>

template/quitesimple/feeds/atomheader

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <author>
+    <name>{qswiki:config:wikiownername}</name>
+  </author>
+  <title>{qswiki:config:wikiname} - {qswiki:var:subtitle}</title>
+  <id>{qswiki:var:atomfeeduniqueid}</id>
+  <link rel="self" href="{qswiki:var:atomselflink}"/>
+  <updated>{qswiki:var:atomfeedupdate}</updated>

template/quitesimple/general_footer

@@ -4,8 +4,5 @@
 		<li style="font-size: 10pt">Powered by qswiki</li>
 	</ul>
 </footer>
-<script>
-{qswiki:include:js_session_refresh}
-</script>
 </body>
-</html>
+</html>

template/quitesimple/general_header

@@ -6,16 +6,15 @@
 <title>{qswiki:var:title}</title>
 <body>
 <nav>
-	<ul>
-	<li><a href="{qswiki:config:linkindex}"><h2>{qswiki:config:wikiname}</h2></a></li>
-	</ul>
 	<ul id="nav">
-    <li><a href="{qswiki:config:linkrecent}">Recent changes</a></li>
-    <li><a href="{qswiki:config:linkallpages}">All pages</a></li>
-    <li><a href="{qswiki:config:linkallcats}">All categories</a></li>
-    </ul>
+	<li><a href="{qswiki:config:linkindex}"><h2>{qswiki:config:wikiname}</h2></a></li>
+	<li><a href="{qswiki:config:linkrecent}">Recent changes</a></li>
+	<li><a href="{qswiki:config:linkallpages}">All pages</a></li>
+	<li><a href="{qswiki:config:linkallcats}">All categories</a></li>
+	<li id="searchlink"><a href="{qswiki:config:linksearch}">Search</a></li>
+	</ul>
 
-    <ul id="right" class="search">
-	<li><div><form action="{qswiki:config:wikipath}" method="GET"><input type="hidden" name="action" value="search"/><input type="text" name="q" value="search here" onfocus="this.value=''"></form></div></li>
+	<ul id="right" class="search">
+	<li><div id="searchbar"><form action="{qswiki:config:wikipath}" method="GET"><input type="hidden" name="action" value="search"/><input type="text" name="q" value="search here" onfocus="this.value=''"></form></div></li>
 	</ul>
 </nav>

template/quitesimple/js_session_refresh

@@ -1,5 +0,0 @@
-function refreshSession()
-{
-fetch(new Request("{qswiki:config:refreshsessionurl}"));
-}
-setInterval(refreshSession, 60*2*1000);

template/quitesimple/page_footer

@@ -5,8 +5,9 @@
 		<li style="font-size: 10pt">Powered by qswiki</li>
 	</ul>
 </footer>
+<script src="{qswiki:config:highlightjspath}"></script>
 <script>
-{qswiki:include:js_session_refresh}
+hljs.highlightAll();
 </script>
 </body>
-</html>
+</html>

template/quitesimple/page_header

@@ -3,23 +3,20 @@
 <meta http-equiv="content-type" content="text/html; charset=UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <link rel="stylesheet" type="text/css" href="{qswiki:config:csspath}">
+<link rel="stylesheet" href="{qswiki:config:highlightjsstyle}">
+
 <title>{qswiki:var:title}</title>
 <body>
 <nav>
-	<ul>
-	<li><a href="{qswiki:config:linkindex}"><h2>{qswiki:config:wikiname}</h2></a></li>
-	</ul>
 	<ul id="nav">
+	<li><a href="{qswiki:config:linkindex}"><h2>{qswiki:config:wikiname}</h2></a></li>
     <li><a href="{qswiki:config:linkrecent}">Recent changes</a></li>
     <li><a href="{qswiki:config:linkallpages}">All pages</a></li>
     <li><a href="{qswiki:config:linkallcats}">All categories</a></li>
-    </ul>
-
-    <ul>
+    <li id="searchlink"><a href="{qswiki:config:linksearch}">Search</a></li>
 	{qswiki:var:headerlinks}
-	</ul>
-
+    </ul>
     <ul id="right" class="search">
-	<li><div><form action="{qswiki:config:wikipath}" method="GET"><input type="hidden" name="action" value="search"/><input type="text" value="search here" onfocus="this.value=''" name="q"/></form></div></li>
+	<li><div id="searchbar"><form action="{qswiki:config:wikipath}" method="GET"><input type="hidden" name="action" value="search"/><input type="text" value="search here" onfocus="this.value=''" name="q"/></form></div></li>
 	</ul>
-</nav>
+</nav>

template/quitesimple/pagelistrender

@@ -0,0 +1,3 @@
+{qswiki:include:pagelistrender_header}
+{qswiki:var:pagelistcontent}
+{qswiki:include:pagelistrender_footer}

template/quitesimple/pagelistrender_group

@@ -0,0 +1 @@
+<div class="letter_search_result">{qswiki:var:groupname}</div>

template/quitesimple/pagelistrender_header

@@ -0,0 +1 @@
+Sort by: <a href="{qswiki:var:pagelistletterlink}">A-Z</a> - <a href="{qswiki:var:pagelistcreationdatelink}">Creation date</a>

template/quitesimple/pagelistrender_link

@@ -0,0 +1 @@
+<a href="{qswiki:var:href}">{qswiki:var:inner}</a><br>

template/quitesimple/searchform

@@ -0,0 +1,7 @@
+{qswiki:include:general_header}
+<main id="content">
+<h2>Search</h2><br>
+Search content of pages:
+<form action="{qswiki:config:wikipath}" method="GET"><input type="hidden" name="action" value="search"/><input type="text" name="q" value="search here" onfocus="this.value=''"></form>
+</main>
+{qswiki:include:general_footer}

template/quitesimple/show_category

@@ -1,6 +1,6 @@
 {qswiki:include:general_header}
 <main id="content">
 <h2>Category: {qswiki:var:categoryname}</h2>
-{qswiki:var:pagelist}
+{qswiki:include:pagelistrender}
 </main>
-{qswiki:include:general_footer}
+{qswiki:include:general_footer}

template/quitesimple/style.css

@@ -23,7 +23,7 @@ h1, h2, h3
 {
 	margin: 0;
 	padding: 0;
-        display: inline;
+	display: inline;
 }
 
 nav
@@ -37,6 +37,7 @@ nav
 	grid-area: nav;
 
 }
+
 nav ul
 {
 	background-color: #062463;
@@ -47,16 +48,12 @@ nav ul
 	display: flex;
 	align-items: center;
 	flex-wrap: wrap;
-
-
 }
+
 nav li
 {
 	margin: 0;
 	padding: 0;
-
-
-
 }
 
 nav a, nav a:visited
@@ -68,7 +65,6 @@ nav a, nav a:visited
 	font-weight: bold;
 	text-align: center;
 	line-height: 100%;
-
 }
 
 nav a:hover, nav a:focus
@@ -81,8 +77,6 @@ nav a:hover, nav a:focus
 	font-weight: bold;
 }
 
-
-
 a, a:visited
 {
 	color: #062463;;
@@ -92,40 +86,36 @@ a:hover
 {
 	background-color: #062463;
 	color: white;
-
 }
 
 #content
 {
-padding: 15px;
-font-family: monospace;
-font-size: 14pt;
-flex: 1;
-grid-area: main
+	padding: 15px;
+	font-family: monospace;
+	font-size: 14pt;
+	flex: 1;
+	grid-area: main
 }
 
 #sidebar
 {
-grid-area: side;
-
+	grid-area: side;
 }
 
 #sidebar ul
 {
-list-style-type: none;
-
+	list-style-type: none;
 }
 
 #sidebar a, a:visited
 {
 	color: #062463;
-
 }
 
 #sidebar a:hover
 {
-   background-color: #062463;
-   color: white;
+	background-color: #062463;
+	color: white;
 }
 
 #content a, a:visited
@@ -135,11 +125,10 @@ list-style-type: none;
 
 #content a:hover
 {
-   background-color: #062463;
-   color: white;
-
-
+	background-color: #062463;
+	color: white;
 }
+
 footer
 {
 	width: 100%;
@@ -160,6 +149,7 @@ footer ul
 	flex-wrap: wrap;
 	align-items: center;
 }
+
 footer li
 {
 	margin: 0;
@@ -168,14 +158,12 @@ footer li
 	line-height: 45px;
 	color: white;
 	font-weight: bold;
-	//flex: 1 1 0;
 	text-align: center;
 }
 
 footer a, a:visited
 {
 	text-decoration: none;
-
 	color: white;
 	display: inline-block;
 }
@@ -190,7 +178,7 @@ footer a:hover, ul#nav a:focus
 
 #cats
 {
-background-color: #062463;
+	background-color: #062463;
 }
 
 .letter_search_result
@@ -198,20 +186,27 @@ background-color: #062463;
 	text-decoration: underline;
 	font-weight: bold;
 }
+
 ol
 {
 	counter-reset: item;
 }
+
 .indexlink
 {
-display: block;
+	display: block;
 }
+
 .notexists
 {
 	color: red !important;
 	font-weight: bold;
 }
 
+#searchlink
+{
+	display: none;
+}
 
 @media screen and (orientation: portrait)
 {
@@ -219,13 +214,23 @@ display: block;
 	{
 		display: none;
 	}
+
 	#footer li:nth-child(-n+2)
 	{
 		display: none;
 	}
+
 	#footer li:nth-of-type(3)
 	{
 		text-align: center;
 		width: 100%;
 	}
+
+	#searchlink {
+		display: inline;
+	}
+
+	#searchbar {
+		display: none;
+	}
 }

urlprovider.cpp

@@ -18,6 +18,7 @@ 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.
 */
+#include <string_view>
 #include "urlprovider.h"
 
 std::string replaceSingleVar(std::string where, std::string varname, std::string replacement)
@@ -52,6 +53,11 @@ std::string UrlProvider::allPages()
 	return config->linkallpages;
 }
 
+std::string UrlProvider::allPages(std::string rendertype)
+{
+	return replaceSingleVar(config->linkallpagesrendertype, "type", rendertype);
+}
+
 std::string UrlProvider::allCats()
 {
 	return config->linkallcats;
@@ -62,6 +68,11 @@ std::string UrlProvider::page(std::string pagename)
 	return replaceOnlyPage(config->linkpage, pagename);
 }
 
+std::string UrlProvider::pageByTitle(std::string title)
+{
+	return replaceSingleVar(config->linkpagebytitle, "title", utils::strreplace(title, " ", "-"));
+}
+
 std::string UrlProvider::linksHere(std::string pagename)
 {
 	return replaceOnlyPage(config->linkshere, pagename);
@@ -115,7 +126,42 @@ std::string UrlProvider::category(std::string catname)
 {
 	return replaceSingleVar(config->linkcategory, "category", catname);
 }
+
+std::string UrlProvider::category(std::string catname, std::string rendertype)
+{
+	Varreplacer replace("{");
+	replace.addKeyValue("category", catname);
+	replace.addKeyValue("type", rendertype);
+	return replace.parse(config->linkcategoryrendertype);
+}
+
+
 std::string UrlProvider::login(std::string page)
 {
 	return replaceOnlyPage(config->loginurl, page);
 }
+
+std::string UrlProvider::rootUrl()
+{
+	return config->rooturl;
+}
+
+std::string UrlProvider::atomFeed(std::string filter)
+{
+	return combine({config->rooturl, replaceSingleVar(config->atomurl, "filter", filter)});
+}
+
+std::string UrlProvider::combine(std::initializer_list<std::string> urls)
+{
+	std::string result;
+	for(const std::string &url : urls)
+	{
+		std::string_view urlview{url};
+		if(result.back() == '/' && urlview.front() == '/')
+		{
+			urlview.remove_prefix(1);
+		}
+		result += urlview;
+	}
+	return result;
+}

urlprovider.h

@@ -22,11 +22,14 @@ class UrlProvider
 	std::string recentSorted(unsigned int limit, unsigned int offset, unsigned int sort);
 
 	std::string allPages();
-
+	std::string allPages(std::string rendertype);
+	
 	std::string allCats();
 
 	std::string page(std::string pagename);
 
+	std::string pageByTitle(std::string title);
+
 	std::string linksHere(std::string pagename);
 
 	std::string pageHistory(std::string pagename);
@@ -46,8 +49,15 @@ class UrlProvider
 	std::string refreshSession();
 
 	std::string category(std::string catname);
-
+	std::string category(std::string catname, std::string rendertype);
+	
 	std::string login(std::string page);
+
+	std::string rootUrl();
+
+	std::string atomFeed(std::string filter);
+
+	std::string combine(std::initializer_list<std::string> urls);
 };
 
 #endif // LINKCREATOR_H